diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index aed51f3..5ffbbf8 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -153,6 +153,7 @@
             android:requiredForAllUsers="true"
             android:supportsRtl="true"
             android:backupAgent="com.android.settings.backup.SettingsBackupHelper"
+            android:restoreAnyVersion="true"
             android:usesCleartextTraffic="true"
             android:defaultToDeviceProtectedStorage="true"
             android:directBootAware="true"
diff --git a/aconfig/settings_panel_flag_declarations.aconfig b/aconfig/settings_panel_flag_declarations.aconfig
deleted file mode 100644
index efab83e..0000000
--- a/aconfig/settings_panel_flag_declarations.aconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-package: "com.android.settings.flags"
-container: "system"
-
-flag {
-  name: "enable_volume_plus_quick_settings"
-  namespace: "pixel_cross_device_control"
-  description: "Gates whether to enable VolumePlus quick settings panel."
-  bug: "309052662"
-}
diff --git a/aconfig/settings_threadnetwork_flag_declarations.aconfig b/aconfig/settings_threadnetwork_flag_declarations.aconfig
new file mode 100644
index 0000000..e5448a9
--- /dev/null
+++ b/aconfig/settings_threadnetwork_flag_declarations.aconfig
@@ -0,0 +1,9 @@
+package: "com.android.settings.flags"
+container: "system"
+
+flag {
+    name: "thread_settings_enabled"
+    namespace: "thread_network"
+    description: "Controls whether the Thread Settings UX is displayed"
+    bug: "329384658"
+}
diff --git a/res-product/values-fr-feminine/strings.xml b/res-product/values-fr-feminine/strings.xml
new file mode 100644
index 0000000..4027cbd
--- /dev/null
+++ b/res-product/values-fr-feminine/strings.xml
@@ -0,0 +1,24 @@
+<?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:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="main_clear_accounts" product="default" msgid="3604029744509330786">\n\n"Vous êtes actuellement connectée aux comptes suivants :\n"</string>
+    <string name="install_all_warning" product="tablet" msgid="1732116924846572063">"Votre tablette et vos données personnelles sont très vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être la seule responsable de tout dommage causé à votre tablette ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
+    <string name="install_all_warning" product="default" msgid="4597256179485325694">"Votre téléphone et vos données personnelles sont plus vulnérables aux attaques d\'applis inconnues. En installant des applis depuis cette source, vous reconnaissez être responsable de tout dommage causé à votre téléphone ou de toute perte de données pouvant découler de leur utilisation​."</string>
+    <string name="install_all_warning" product="device" msgid="6293002353591632851">"Votre appareil et vos données personnelles sont très vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être la seule responsable de tout dommage causé à votre appareil ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
+</resources>
diff --git a/res-product/values-fr-masculine/strings.xml b/res-product/values-fr-masculine/strings.xml
new file mode 100644
index 0000000..0bca528
--- /dev/null
+++ b/res-product/values-fr-masculine/strings.xml
@@ -0,0 +1,24 @@
+<?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:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="main_clear_accounts" product="default" msgid="3604029744509330786">\n\n"Vous êtes actuellement connecté aux comptes suivants :\n"</string>
+    <string name="install_all_warning" product="tablet" msgid="1732116924846572063">"Votre tablette et vos données personnelles sont très vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être le seul responsable de tout dommage causé à votre tablette ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
+    <string name="install_all_warning" product="default" msgid="4597256179485325694">"Votre téléphone et vos données personnelles sont plus vulnérables aux attaques d\'applis inconnues. En installant des applis depuis cette source, vous reconnaissez être responsable de tout dommage causé à votre téléphone ou de toute perte de données pouvant découler de leur utilisation​."</string>
+    <string name="install_all_warning" product="device" msgid="6293002353591632851">"Votre appareil et vos données personnelles sont très vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être le seul responsable de tout dommage causé à votre appareil ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
+</resources>
diff --git a/res-product/values-fr-neuter/strings.xml b/res-product/values-fr-neuter/strings.xml
new file mode 100644
index 0000000..8777756
--- /dev/null
+++ b/res-product/values-fr-neuter/strings.xml
@@ -0,0 +1,24 @@
+<?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:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="main_clear_accounts" product="default" msgid="3604029744509330786">\n\n"Vous êtes actuellement connecté·e aux comptes suivants :\n"</string>
+    <string name="install_all_warning" product="tablet" msgid="1732116924846572063">"Votre tablette et vos données personnelles sont très vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être l\'unique responsable de tout dommage causé à votre tablette ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
+    <string name="install_all_warning" product="default" msgid="4597256179485325694">"Votre téléphone et vos données personnelles sont plus vulnérables aux attaques d\'applis inconnues. En installant des applis depuis cette source, vous reconnaissez être responsable de tout dommage causé à votre téléphone ou de toute perte de données pouvant découler de leur utilisation​."</string>
+    <string name="install_all_warning" product="device" msgid="6293002353591632851">"Votre appareil et vos données personnelles sont très vulnérables aux attaques provenant d\'applications inconnues. En installant des applications provenant de cette source, vous acceptez d\'être l\'unique responsable de tout dommage causé à votre appareil ou de toute perte de données pouvant découler de l\'utilisation de telles applications."</string>
+</resources>
diff --git a/res-product/values/drawables.xml b/res-product/values/drawables.xml
index a2d66e7..9353030 100644
--- a/res-product/values/drawables.xml
+++ b/res-product/values/drawables.xml
@@ -29,6 +29,8 @@
     <drawable name="a11y_captioning_banner" product="default">@drawable/accessibility_captioning_banner</drawable>
     <drawable name="a11y_captioning_banner" product="tablet">@drawable/accessibility_captioning_banner_tablet</drawable>
 
+    <drawable name="a11y_shortcut_type_quick_settings" product="default">@drawable/accessibility_shortcut_type_quick_settings</drawable>
+
     <drawable name="a11y_shortcut_type_hardware" product="default">@drawable/accessibility_shortcut_type_hardware</drawable>
     <drawable name="a11y_shortcut_type_hardware" product="tablet">@drawable/accessibility_shortcut_type_hardware_tablet</drawable>
 
diff --git a/res/drawable/accessibility_shortcut_type_quick_settings.xml b/res/drawable/accessibility_shortcut_type_quick_settings.xml
new file mode 100644
index 0000000..a801347
--- /dev/null
+++ b/res/drawable/accessibility_shortcut_type_quick_settings.xml
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~
+  ~ Copyright 2024 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
+  ~
+  ~      https://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.
+  ~
+  ~
+  -->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="312dp"
+    android:height="130dp"
+    android:viewportWidth="312"
+    android:viewportHeight="130">
+    <group>
+        <clip-path
+            android:pathData="M24,0L288,0A24,24 0,0 1,312 24L312,106A24,24 0,0 1,288 130L24,130A24,24 0,0 1,0 106L0,24A24,24 0,0 1,24 0z"/>
+        <path
+            android:pathData="M24,0L288,0A24,24 0,0 1,312 24L312,106A24,24 0,0 1,288 130L24,130A24,24 0,0 1,0 106L0,24A24,24 0,0 1,24 0z"
+            android:fillColor="#ffffff"/>
+        <path
+            android:pathData="M209,139.62H210V138.62V32C210,24.82 204.18,19 197,19H115C107.82,19 102,24.82 102,32V138.62V139.62H103H209Z"
+            android:strokeWidth="2"
+            android:fillColor="#00000000"
+            android:strokeColor="#6D6D6D"/>
+        <path
+            android:pathData="M103,32C103,25.37 108.37,20 115,20H197C203.63,20 209,25.37 209,32V91.93H103V32Z"
+            android:fillColor="#484848"/>
+        <path
+            android:pathData="M113.31,38.93L149.48,38.93A4,4 0,0 1,153.48 42.93L153.48,52.6A4,4 0,0 1,149.48 56.6L113.31,56.6A4,4 0,0 1,109.31 52.6L109.31,42.93A4,4 0,0 1,113.31 38.93z"
+            android:fillColor="#69B2C9"/>
+        <path
+            android:pathData="M113.31,61.64L149.48,61.64A4,4 0,0 1,153.48 65.64L153.48,75.31A4,4 0,0 1,149.48 79.31L113.31,79.31A4,4 0,0 1,109.31 75.31L109.31,65.64A4,4 0,0 1,113.31 61.64z"
+            android:fillColor="#646464"/>
+        <path
+            android:pathData="M162.52,38.93L198.69,38.93A4,4 0,0 1,202.69 42.93L202.69,52.6A4,4 0,0 1,198.69 56.6L162.52,56.6A4,4 0,0 1,158.52 52.6L158.52,42.93A4,4 0,0 1,162.52 38.93z"
+            android:fillColor="#646464"/>
+        <path
+            android:pathData="M162.52,61.64L198.69,61.64A4,4 0,0 1,202.69 65.64L202.69,75.31A4,4 0,0 1,198.69 79.31L162.52,79.31A4,4 0,0 1,158.52 75.31L158.52,65.64A4,4 0,0 1,162.52 61.64z"
+            android:fillColor="#646464"/>
+    </group>
+</vector>
+
+
+
diff --git a/res/drawable/color_contrast_preview_icon_edit_background.xml b/res/drawable/color_contrast_preview_icon_edit_background.xml
index 14c5f3c..61fe4fe 100644
--- a/res/drawable/color_contrast_preview_icon_edit_background.xml
+++ b/res/drawable/color_contrast_preview_icon_edit_background.xml
@@ -17,6 +17,6 @@
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
        android:shape="rectangle" >
-    <solid android:color="?androidprv:attr/materialColorPrimary"/>
-    <corners android:radius="20dp" />
+    <solid android:color="?androidprv:attr/materialColorPrimaryContainer"/>
+    <corners android:radius="24dp" />
 </shape>
\ No newline at end of file
diff --git a/res/drawable/color_contrast_preview_icon_group_background.xml b/res/drawable/color_contrast_preview_icon_group_background.xml
index b8554c1..46cd40d 100644
--- a/res/drawable/color_contrast_preview_icon_group_background.xml
+++ b/res/drawable/color_contrast_preview_icon_group_background.xml
@@ -17,6 +17,6 @@
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
        android:shape="oval" >
-    <solid android:color="?androidprv:attr/materialColorSurfaceContainer"/>
+    <solid android:color="?androidprv:attr/materialColorSurfaceContainerHighest"/>
     <size android:width="36dp" android:height="36dp" />
 </shape>
\ No newline at end of file
diff --git a/res/drawable/ic_bubble_all.xml b/res/drawable/ic_bubble_all.xml
deleted file mode 100644
index fdcf6dc..0000000
--- a/res/drawable/ic_bubble_all.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ 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.
-  -->
-
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:pathData="M16,11c1.66,0 2.99,-1.34 2.99,-3S17.66,5 16,5c-1.66,0 -3,1.34 -3,3s1.34,3 3,3zM8,11c1.66,0 2.99,-1.34 2.99,-3S9.66,5 8,5C6.34,5 5,6.34 5,8s1.34,3 3,3zM8,13c-2.33,0 -7,1.17 -7,3.5L1,19h14v-2.5c0,-2.33 -4.67,-3.5 -7,-3.5zM16,13c-0.29,0 -0.62,0.02 -0.97,0.05 1.16,0.84 1.97,1.97 1.97,3.45L17,19h6v-2.5c0,-2.33 -4.67,-3.5 -7,-3.5z"
-        android:fillColor="#000000"/>
-</vector>
diff --git a/res/drawable/ic_bubble_none.xml b/res/drawable/ic_bubble_none.xml
deleted file mode 100644
index e8fd7df..0000000
--- a/res/drawable/ic_bubble_none.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ 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.
-  -->
-
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:pathData="M12,2C6.5,2 2,6.5 2,12s4.5,10 10,10 10,-4.5 10,-10S17.5,2 12,2zM4,12c0,-4.4 3.6,-8 8,-8 1.8,0 3.5,0.6 4.9,1.7L5.7,16.9C4.6,15.5 4,13.8 4,12zM12,20c-1.8,0 -3.5,-0.6 -4.9,-1.7L18.3,7.1C19.4,8.5 20,10.2 20,12c0,4.4 -3.6,8 -8,8z"
-        android:fillColor="#000000"/>
-</vector>
diff --git a/res/drawable/ic_bubble_selected.xml b/res/drawable/ic_bubble_selected.xml
deleted file mode 100644
index f953328..0000000
--- a/res/drawable/ic_bubble_selected.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ 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.
-  -->
-
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:pathData="M15,8c0,-1.42 -0.5,-2.73 -1.33,-3.76 0.42,-0.14 0.86,-0.24 1.33,-0.24 2.21,0 4,1.79 4,4s-1.79,4 -4,4c-0.43,0 -0.84,-0.09 -1.23,-0.21 -0.03,-0.01 -0.06,-0.02 -0.1,-0.03C14.5,10.73 15,9.42 15,8zM16.66,13.13C18.03,14.06 19,15.32 19,17v3h4v-3c0,-2.18 -3.58,-3.47 -6.34,-3.87zM9,6c-1.1,0 -2,0.9 -2,2s0.9,2 2,2 2,-0.9 2,-2 -0.9,-2 -2,-2m0,9c-2.7,0 -5.8,1.29 -6,2.01L3,18h12v-1c-0.2,-0.71 -3.3,-2 -6,-2M9,4c2.21,0 4,1.79 4,4s-1.79,4 -4,4 -4,-1.79 -4,-4 1.79,-4 4,-4zM9,13c2.67,0 8,1.34 8,4v3L1,20v-3c0,-2.66 5.33,-4 8,-4z"
-        android:fillColor="#000000"/>
-</vector>
diff --git a/res/drawable/ic_edit_24dp.xml b/res/drawable/ic_edit_24dp.xml
index c9dbfc3..e663b52 100644
--- a/res/drawable/ic_edit_24dp.xml
+++ b/res/drawable/ic_edit_24dp.xml
@@ -21,6 +21,6 @@
         android:viewportHeight="24"
         android:tint="?attr/colorControlNormal">
 <path
-    android:fillColor="?androidprv:attr/materialColorOnPrimary"
+    android:fillColor="?androidprv:attr/materialColorOnPrimaryContainer"
     android:pathData="M20.41,4.94l-1.35,-1.35c-0.78,-0.78 -2.05,-0.78 -2.83,0L3,16.82L3,21h4.18L20.41,7.77c0.79,-0.78 0.79,-2.05 0,-2.83zM6.41,19.06L5,19v-1.36l9.82,-9.82 1.41,1.41 -9.82,9.83z"/>
 </vector>
diff --git a/res/drawable/ic_star_24dp.xml b/res/drawable/ic_star_24dp.xml
index 38535e6..667db94 100644
--- a/res/drawable/ic_star_24dp.xml
+++ b/res/drawable/ic_star_24dp.xml
@@ -22,5 +22,5 @@
         android:tint="?attr/colorControlNormal">
     <path
         android:fillColor="?androidprv:attr/materialColorOnPrimary"
-        android:pathData="M14.43,10l-2.43,-8l-2.43,8l-7.57,0l6.18,4.41l-2.35,7.59l6.17,-4.69l6.18,4.69l-2.35,-7.59l6.17,-4.41z"/>
+        android:pathData="M12,17.27L18.18,21l-1.64,-7.03L22,9.24l-7.19,-0.61L12,2 9.19,8.63 2,9.24l5.46,4.73L5.82,21 12,17.27z"/>
 </vector>
diff --git a/res/layout/accessibility_color_contrast_preview.xml b/res/layout/accessibility_color_contrast_preview.xml
index 2646709..44f7584 100644
--- a/res/layout/accessibility_color_contrast_preview.xml
+++ b/res/layout/accessibility_color_contrast_preview.xml
@@ -104,6 +104,7 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_marginLeft="10dp"
+        android:paddingHorizontal="4dp"
         android:textColor="?androidprv:attr/materialColorOnSurface"
         android:background="@drawable/color_contrast_preview_tag_background"
         android:textSize="11sp"
@@ -164,7 +165,9 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:src="@drawable/ic_article_filled_24dp"
-        android:padding="6dp"
+        android:paddingStart="8dp"
+        android:paddingEnd="6dp"
+        android:paddingVertical="6dp"
         app:layout_constraintStart_toStartOf="@+id/email_title"
         app:layout_constraintTop_toBottomOf="@+id/email_body" />
 
@@ -172,7 +175,7 @@
         android:id="@+id/email_attachment"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:paddingRight="8dp"
+        android:paddingEnd="10dp"
         android:textColor="?androidprv:attr/materialColorOnTertiaryContainer"
         android:textSize="12sp"
         app:layout_constraintStart_toEndOf="@+id/ic_article_filled"
diff --git a/res/layout/accessibility_color_contrast_selector.xml b/res/layout/accessibility_color_contrast_selector.xml
index f7ba28b..38bcf7a 100644
--- a/res/layout/accessibility_color_contrast_selector.xml
+++ b/res/layout/accessibility_color_contrast_selector.xml
@@ -20,8 +20,7 @@
     xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
     android:orientation="vertical"
     android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:paddingEnd="?android:attr/listPreferredItemPaddingEnd">
+    android:layout_height="wrap_content">
 
     <FrameLayout
         android:layout_width="match_parent"
@@ -36,6 +35,7 @@
     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
+        android:layout_marginBottom="16dp"
         android:orientation="horizontal">
 
         <Space
diff --git a/res/layout/bubble_preference.xml b/res/layout/bubble_preference.xml
index eb9a8f1..7c2dbbc 100644
--- a/res/layout/bubble_preference.xml
+++ b/res/layout/bubble_preference.xml
@@ -15,13 +15,12 @@
   ~ limitations under the License.
   -->
 
-<LinearLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:gravity="center"
-    android:padding="@dimen/notification_importance_toggle_marginTop"
-    android:orientation="vertical">
+    android:orientation="vertical"
+    android:padding="@dimen/notification_importance_toggle_marginTop">
 
     <!-- If bubbles is managed by the admin this is used to inform the user. -->
     <TextView
@@ -30,102 +29,45 @@
         android:layout_height="wrap_content"
         android:padding="@dimen/notification_importance_button_padding"
         android:textAppearance="@style/TextAppearance.Small"
-        android:visibility="gone"
-        />
+        android:visibility="gone" />
 
-    <com.android.settings.notification.NotificationButtonRelativeLayout
-        android:id="@+id/bubble_all"
+    <RadioGroup
+        android:id="@+id/radio_group"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
-        android:padding="@dimen/notification_importance_button_padding"
-        android:clickable="true"
-        android:focusable="true">
-        <ImageView
-            android:id="@+id/bubble_all_icon"
-            android:src="@drawable/ic_bubble_all"
-            android:background="@android:color/transparent"
-            android:layout_centerVertical="true"
+        android:checkedButton="@+id/redact_sensitive">
+
+        <RadioButton
+            android:id="@+id/bubble_all"
+            style="@style/SudRadioButton"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:clickable="false"
-            android:focusable="false"/>
-        <TextView
-            android:id="@+id/bubble_all_label"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_centerVertical="true"
-            android:ellipsize="end"
-            android:maxLines="3"
-            android:clickable="false"
-            android:focusable="false"
-            android:layout_toEndOf="@id/bubble_all_icon"
-            android:layout_marginStart="@dimen/notification_importance_drawable_padding"
-            android:textAppearance="@style/TextAppearance.NotificationImportanceButton.Unselected"
-            android:text="@string/bubble_app_setting_all"/>
-    </com.android.settings.notification.NotificationButtonRelativeLayout>
+            android:layout_marginVertical="0dp"
+            android:fontFamily="@*android:string/config_headlineFontFamily"
+            android:minHeight="56dp"
+            android:text="@string/bubble_app_setting_all"
+            android:textColor="?android:attr/textColorSecondary" />
 
-    <com.android.settings.notification.NotificationButtonRelativeLayout
-        android:id="@+id/bubble_selected"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:padding="@dimen/notification_importance_button_padding"
-        android:layout_marginTop="@dimen/notification_importance_button_separation"
-        android:clickable="true"
-        android:focusable="true">
-        <ImageView
-            android:id="@+id/bubble_selected_icon"
-            android:src="@drawable/ic_bubble_selected"
-            android:background="@android:color/transparent"
-            android:layout_centerVertical="true"
+        <RadioButton
+            android:id="@+id/bubble_selected"
+            style="@style/SudRadioButton"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:clickable="false"
-            android:focusable="false"/>
-        <TextView
-            android:id="@+id/bubble_selected_label"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_centerVertical="true"
-            android:ellipsize="end"
-            android:maxLines="3"
-            android:clickable="false"
-            android:focusable="false"
-            android:layout_toEndOf="@id/bubble_selected_icon"
-            android:layout_marginStart="@dimen/notification_importance_drawable_padding"
-            android:textAppearance="@style/TextAppearance.NotificationImportanceButton.Unselected"
-            android:text="@string/bubble_app_setting_selected"/>
-    </com.android.settings.notification.NotificationButtonRelativeLayout>
+            android:layout_marginVertical="0dp"
+            android:fontFamily="@*android:string/config_headlineFontFamily"
+            android:minHeight="56dp"
+            android:text="@string/bubble_app_setting_selected"
+            android:textColor="?android:attr/textColorSecondary" />
 
-    <com.android.settings.notification.NotificationButtonRelativeLayout
-        android:id="@+id/bubble_none"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:padding="@dimen/notification_importance_button_padding"
-        android:layout_marginTop="@dimen/notification_importance_button_separation"
-        android:clickable="true"
-        android:focusable="true">
-        <ImageView
-            android:id="@+id/bubble_none_icon"
-            android:src="@drawable/ic_bubble_none"
-            android:background="@android:color/transparent"
-            android:layout_centerVertical="true"
+        <RadioButton
+            android:id="@+id/bubble_none"
+            style="@style/SudRadioButton"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:clickable="false"
-            android:focusable="false"/>
-        <TextView
-            android:id="@+id/bubble_none_label"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_centerVertical="true"
-            android:ellipsize="end"
-            android:maxLines="3"
-            android:clickable="false"
-            android:focusable="false"
-            android:layout_toEndOf="@id/bubble_none_icon"
-            android:layout_marginStart="@dimen/notification_importance_drawable_padding"
-            android:textAppearance="@style/TextAppearance.NotificationImportanceButton.Unselected"
-            android:text="@string/bubble_app_setting_none"/>
-    </com.android.settings.notification.NotificationButtonRelativeLayout>
-
+            android:layout_marginVertical="0dp"
+            android:fontFamily="@*android:string/config_headlineFontFamily"
+            android:minHeight="56dp"
+            android:text="@string/bubble_app_setting_none"
+            android:textColor="?android:attr/textColorSecondary" />
+    </RadioGroup>
 </LinearLayout>
diff --git a/res/layout/homepage_preference.xml b/res/layout/homepage_preference.xml
index f0b1b71..38cb491 100644
--- a/res/layout/homepage_preference.xml
+++ b/res/layout/homepage_preference.xml
@@ -17,6 +17,7 @@
 
 <LinearLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:androidprv="http://schemas.android.com/apk/prv/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
@@ -77,7 +78,7 @@
             android:layout_gravity="start"
             android:textAlignment="viewStart"
             android:textAppearance="?android:attr/textAppearanceSmall"
-            android:textColor="?android:attr/textColorSecondary"
+            android:textColor="?androidprv:attr/materialColorOnSurfaceVariant"
             android:maxLines="4"
             android:hyphenationFrequency="normalFast"
             android:lineBreakWordStyle="phrase"
diff --git a/res/layout/wifi_network_config.xml b/res/layout/wifi_network_config.xml
index 3de1a38..dbd3e67 100644
--- a/res/layout/wifi_network_config.xml
+++ b/res/layout/wifi_network_config.xml
@@ -708,6 +708,13 @@
                      style="@style/wifi_item_spinner"
                      android:prompt="@string/wifi_privacy_settings"
                      android:entries="@array/wifi_privacy_entries"/>
+
+            <Spinner android:id="@+id/dhcp_settings"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                style="@style/wifi_item_spinner"
+                android:prompt="@string/wifi_privacy_device_name_settings"
+                android:entries="@array/wifi_dhcp_entries"/>
         </LinearLayout>
 
         <LinearLayout
diff --git a/res/values-af/arrays.xml b/res/values-af/arrays.xml
index 44a2d54..425a9ff0 100644
--- a/res/values-af/arrays.xml
+++ b/res/values-af/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Hanteer as beperk"</item>
     <item msgid="2047166446768045816">"Hanteer as onbeperk"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Gebruik ewekansige MAC (verstek)"</item>
-    <item msgid="741680937828608749">"Gebruik toestel-MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nee"</item>
     <item msgid="2163015208097377388">"Ja"</item>
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index b74089a..d3b9429 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Bind regteroor saam"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Bind linkeroor saam"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Vir alle beskikbare gehoortoestelle"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Meer gehoortoestelinstellings"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Verander kruistoestelinstellings soos kortpad- en teledraadkontroles"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Vir hierdie toestel"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Oudio-uitvoer"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Meer oor oudio-uitvoer"</string>
@@ -592,14 +590,13 @@
     <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Versteek of sluit privaat apps op ’n aparte plek. Gebruik ’n toegewyde Google-rekening vir ekstra sekuriteit."</string>
     <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Stel jou privaat ruimte op"</string>
     <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Kies ’n Google-rekening vir jou ruimte"</b>\n"As jy ’n toegewyde rekening gebruik, help dit om te keer dat gesinkroniseerde lêers, foto’s en e-posse buite jou ruimte verskyn"</string>
-    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Stel ’n slot"</b>\n"Sluit jou ruimte om te keer dat ander mense dit oopmaak"</string>
+    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Stel ’n slot op"</b>\n"Sluit jou ruimte om te keer dat ander mense dit oopmaak"</string>
     <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Installeer apps"</b>\n"Jou privaat ruimte het sy eie Play Winkel sodat jy apps maklik kan installeer."</string>
     <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Apps in jou privaat ruimte sal nie in toestemmingbestuurder, privaatheidkontroleskerm en ander instellings verskyn wanneer jou privaat ruimte gesluit is nie.\n\nJou privaat ruimte kan nie na ’n nuwe toestel geskuif word nie. Jy sal ’n ander privaat ruimte moet opstel as jy dit op ’n ander toestel wil gebruik.\n\nEnigiemand wat jou toestel aan ’n rekenaar koppel of skadelike apps op jou toestel installeer, sal moontlik toegang tot jou privaat ruimte kan kry."</string>
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Stel tans privaat ruimte op …"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Kennisgewings van privaat ruimte-apps word versteek as dit gesluit is"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Verken privaatruimte-instellings om privaat ruimte te versteek en outomatiese sluiting op te stel"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Vereiste apps is reeds in jou privaat ruimte geïnstalleer"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Kon nie privaat ruimte opstel nie"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Probeer weer"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Wil jy skermslot gebruik om privaat ruimte te ontsluit?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apps en kennisgewings"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Sensitiewe kennisgewings op sluitskerm"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Wys sensitiewe inhoud wanneer privaat ruimte ontsluit is"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Skep ’n Google-rekening om te help om jou data privaat te hou"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Jy kan op die volgende skerm by ’n rekening aanmeld om saam met jou privaat ruimte te gebruik"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Skep ’n toegewyde rekening om te help keer dat data buite privaat ruimte verskyn, soos:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Gesinkroniseerde foto’s, lêers, e-posse, kontakte, kalendergeleenthede en ander data"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Appaflaaigeskiedenis en -aanbevelings"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Blaaigeskiedenis, boekmerke en gestoorde wagwoorde"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Voorgestelde inhoud wat met jou aktiwiteit in privaatruimte-apps verband hou"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Het dit"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Jy kan tot <xliff:g id="COUNT">%d</xliff:g> vingerafdrukke byvoeg"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Jy het die maksimum aantal vingerafdrukke bygevoeg"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Kan nie nog vingerafdrukke byvoeg nie"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Jou diensverskaffer laat jou nie toe om aan hierdie netwerk te koppel nie, want dit gebruik \'n ouer sekuriteitsprotokol wat minder veilig is"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Laat BEP toe"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Maak toe"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Ontkoppel vanaf <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Jy is gekoppel aan \'n BEP-netwerk. Jy sal ontkoppel word as jy hierdie netwerke blokkeer."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Gevorderde opsies"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Gevorderde Opsies-aftreklys"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"vou uit"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Gebruik <xliff:g id="NEW_APP">%s</xliff:g> om jou netwerkverbindings te bestuur?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Onlangse liggingversoeke"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ligging vir werkprofiel"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Programliggingtoestemmings"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Ligging is af"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# van {total} apps het toegang tot ligging}other{# van {total} apps het toegang tot ligging}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Gebruik skermsleutelbord"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Hou dit op die skerm terwyl fisieke sleutelbord aktief is"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Hopsleutels"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Die sleutelbord ignoreer drukke van dieselfde sleutel wat binne <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms vinnig herhaal word"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Stadige sleutels"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Dit verstel die tyd wat dit neem vir ’n sleuteldruk om geaktiveer te word na <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms toe"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Taaisleutels"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Druk een sleutel op ’n slag vir kortpaaie pleks van om die sleutels saam in te hou"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Kortpadsleutels"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Wys lys met kortpaaie"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Werkprofielsleutelborde en -nutsgoed"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Stel terug"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Kies wysigersleutel"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Kies ’n nuwe sleutel vir <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Verstek"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Spraak"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Wyserspoed"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Speletjiekontroleerder"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Jy kan hierdie toestel pasmaak om by jou behoeftes te pas. Hierdie toeganklikheidkenmerke kan later in Instellings verander word."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Verander lettergrootte"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Skermleser"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opsies vir fisieke sleutelbord"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Onderskrifte"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Oudio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Algemeen"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Vertoon"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Kleur en beweging"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kleurkontras"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Hoër kontras laat teks, knoppies en ikone meer uitstaan. Kies die kontras wat vir jou die beste lyk."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Sommige apps steun dalk nie alle kleur- en tekskontrasinstellings nie"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Verstel hoe kleure en teks teen jou skerm se agtergrondkleur lyk"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Voorbeskou"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 dae gelede"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Volg op?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Sakereisverslag"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Kontak \nmy of Helen vir verdere hulp. Hierdie verslag sal"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Kliëntuitgawes"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Maak skerm donkerder"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaksiekontroles"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Tydkontroles"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Gaan in elk geval voort"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Kanselleer"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Vergrotinginstellings"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Vergroot met kortpad"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Vergroot met kortpad en trippeltik"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Meer oor <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ondeursigtig"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Hoëkontrasteks"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Verander tekskleur na swart of wit. Vergroot kontras met die agtergrond."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimeer tekskontras"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Verander tekskleur na swart of wit om kontras met die agtergrond te verskerp."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Dateer outomaties skermvergroting op"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Dateer skermvergroting op tydens programverwisseling"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Kragknoppie beëindig oproep"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hou volumesleutels in"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tripeltik op skerm"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Wysig toeganklikheidkortpaaie"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Kies jou kortpad vir %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Gaan voort"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Gehoortoestelle"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Stel ASHA- en LE-oudio-gehoortoestelle, kogleêre inplantings en ander klankversterkingtoestelle op en bestuur hulle"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Geen gehoortoestelle is gekoppel nie"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Voeg gehoortoestelle by"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Bind gehoortoestelle saam"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Gehoortoestelversoenbaarheid"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Verbeter versoenbaarheid met teleklosse en verminder ongewenste geraas"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Meer oor gehoortoestelle"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Tik op "<b>"Bind nuwe toestel saam"</b>" &gt; "<b>"Sien meer toestelle"</b>" om ander gehoortoestelle te kry wat nie deur ASHA of LE-oudio gesteun word nie"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Bind gehoortoestel saam"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Jy kan ASHA- en LE-oudio-gehoortoestelle op hierdie bladsy saambind. Maak seker dat jou gehoortoestel aangeskakel en gereed is om saam te bind."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Beskikbare gehoortoestelle"</string>
@@ -3437,7 +3418,7 @@
     <string name="notification_pulse_title" msgid="8013178454646671529">"Flikkerende lig"</string>
     <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privaatheid"</string>
     <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Slaan sluitskerm oor"</string>
-    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Gaan ná ontsluiting direk na skerm toe wat laas gebruik is. Kennisgewings sal nie op sluitskerm wys nie. Swiep van bo af na onder om hulle te sien."</string>
+    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Gaan ná ontsluiting direk na die skerm wat laas gebruik is. Kennisgewings sal nie op sluitskerm wys nie. Swiep van bo af na onder om hulle te sien."</string>
     <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Sluitskerm, sluit skerm, slaan oor, systap"</string>
     <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Wanneer werkprofiel gesluit is"</string>
     <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Wys net nuwe kennisgewings op sluitskerm"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS’e"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Outomatiese datawisseling"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Gebruik data vanaf enige SIM na gelang van dekking en beskikbaarheid"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Net data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Stel op"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Volgende"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Help om die relatiewe posisie te bepaal van toestelle in die omtrek wat UWB het"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Skakel vliegtuigmodus af om UWB te gebruik"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is nie in die huidige ligging beskikbaar nie"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Koppel met Thread aan versoenbare toestelle vir ’n moeitelose slimhuiservaring"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Skakel vliegtuigmodus af om Thread te gebruik"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kameratoegang"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofoontoegang"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Vir apps en dienste"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Kanselleer"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontras"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standaard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Verstek"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Medium"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Hoog"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Hierdie app kan net in 1 venster oopgemaak word"</string>
diff --git a/res/values-am/arrays.xml b/res/values-am/arrays.xml
index 54af56f..b4f3214 100644
--- a/res/values-am/arrays.xml
+++ b/res/values-am/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"እንደ ተለካ አስተናግድ"</item>
     <item msgid="2047166446768045816">"እንደ ያልተለካ አስተናግድ"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"የዘፈቀደ ማክ ይጠቀሙ (ነባሪ)"</item>
-    <item msgid="741680937828608749">"የመሣሪያ ማክ ይጠቀሙ"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"አይ"</item>
     <item msgid="2163015208097377388">"አዎ"</item>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index ffb44c7..353f17d 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"የቀኝ ጆሮን ያጣምሩ"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"የግራ ጆሮን ያጣምሩ"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"ለሁሉም ለሚገኙ የመስሚያ መሣሪያዎች"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"ተጨማሪ የመስማት ችሎታ መሣሪያ ቅንብሮች"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"እንደ አቋራጭ እና የቴሌኮይል ቁጥጥሮች ያሉ የመሣሪያ-ተሻጋሪ ቅንብሮችን ይቀይሩ"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"ለዚህ መሳሪያ"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"የኦዲዮ ውጽዓት"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ስለኦዲዮ ውፅዓት"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"የግል ቦታን በማዋቀር ላይ…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ከግል ቦታ መተግበሪያዎች የሚመጡ ማሳወቂያዎች ሲቆለፍ ይደበቃሉ"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"የግል ቦታን ለመደበቅ እና ራስ-ሰር መቆለፍን ለማዘጋጀት የግል ቦታ ቅንብሮችን ያስሱ"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"የሚያስፈልጉ መተግበሪያዎች አስቀድመው በግል ቦታዎ ላይ ተጭነዋል"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"የግል ቦታን ማዋቀር አልተቻለም"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"እንደገና ይሞክሩ"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"የግል ቦታን ለመክፈት ማያ ገጽ መቆለፊያን ይጠቀሙ?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"መተግበሪያዎች እና ማሳወቂያዎች"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"ምስጢራዊነት ያላቸው ማሳወቂያዎች በማያ ገጽ ቁልፍ ላይ"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"የግል ቦታ ሲከፈት ምስጢራዊነት ያለው ይዘት አሳይ"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"የእርስዎን ውሂብ የግል ለማድረግ እንዲያግዝ የGoogle መለያ ይፍጠሩ"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"በሚቀጥለው ማያ ገጽ ላይ በግል ቦታዎ ለመጠቀም ወደ መለያ መግባት ይችላሉ"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"ውሂብ ከግል ቦታ ውጭ እንዳይታይ ለማቆም ለማገዝ ለዚህ የተለየ መለያ ይፍጠሩ፣ ለምሳሌ፦"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"የሰመሩ ፎቶዎች፣ ፋይሎች፣ ኢሜይሎች፣ እውቂያዎች፣ የቀን መቁጠሪያ ክስተቶች እና ሌላ ውሂብ"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"የመተግበሪያ ማውረድ ታሪክ እና ምክሮች"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"የአሰሳ ታሪክ፣ እልባቶች እና የተቀመጡ የይለፍ ቃላት"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"በግል ቦታ መተግበሪያዎች ውስጥ ካለው እንቅስቃሴዎ ጋር የሚዛመድ የተጠቆመ ይዘት"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"ገባኝ"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"እስከ <xliff:g id="COUNT">%d</xliff:g> የሚደርሱ የጣት አሻራዎችን ማከል ይችላሉ"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"የሚፈቀደውን ከፍተኛ የጣት አሻራ ብዛት አክለዋል"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"ተጨማሪ የጣት አሻራዎችን ማከል አይቻልም"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"አገልግሎት አቅራቢዎ ከዚህ አውታረ መረብ ጋር እንዲገናኙ አይፈቅድልዎትም ምክንያቱም ደህንነቱ ያነሰ የቆየ የደህንነት ፕሮቶኮል ይጠቀማል"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEPን ፍቀድ"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"ዝጋ"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"ከ<xliff:g id="NAME">%1$s</xliff:g> ጋር ያለው ግንኙነት ይቋረጥ?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"ከWEP አውታረ መረብ ጋር ተገናኝተዋል። እነዚህን አውታረ መረቦች ካገዱ ግንኙነትዎ ይቋረጣል።"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"የላቁ አማራጮች"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"የተቆልቋይ ዝርዝር የላቁ አማራጮች"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ዘርጋ"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"የአውታረ መረብ ግንኙነቶችዎን ለማቀናበር <xliff:g id="NEW_APP">%s</xliff:g>ን ይጠቀሙ?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"የቅርብ ጊዜ የአካባቢ ጥያቄዎች"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"የስራ መገለጫ አካባቢ"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"የመተግበሪያ አካባቢ ፈቃዶች"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"መገኛ አካባቢ ጠፍቷል"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{ከ{total} መተግበሪያዎች # የአካባቢ መዳረሻ አለው}one{ከ{total} መተግበሪያዎች # የአካባቢ መዳረሻ አለው}other{ከ{total} መተግበሪያዎች # የአካባቢ መዳረሻ አላቸው}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"የማያ ገፅ የቁልፍ ሰሌዳ ይጠቀሙ"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"አካላዊ የቁልፍ ሰሌዳ ገቢር ሆኖ ሳለ በማያ ገፅ ላይ አቆየው"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"የመንጠሪያ ቁልፎች"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"ቁልፍ ሰሌዳው በ<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ሚሊሰከንድ ውስጥ ተመሳሳዩ ቁልፍ በፍጥነት መጫኑን ችላ ይላል"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ቀርፋፋ ቁልፎች"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"የቁልፍ መጫን ለማግበር የሚወስደውን ጊዜ ወደ <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ሚሊሰከንድ ያስተካክላል"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ተጣባቂ ቁልፎች"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"አቋራጮችን ለማግኘት ቁልፎችን በአንድ ላይ ከመያዝ ይልቅ ቁልፎችን አንድ በአንድ ይጫኑ"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"የቁልፍ ሰሌዳ አቋራጮች"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"የአቋራጭ ዝርዝርን አሳይ"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"የሥራ መገለጫ የቁልፍ ሰሌዳዎች እና መሣሪያዎች"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ዳግም አስጀምር"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"አሻሻይ ቁልፍ ይምረጡ"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"ለ<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> አዲስ ቁልፍ ይምረጡ፦"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ነባሪ"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"ንግግር"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"የጠቋሚ ፍጥነት"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"የጨዋታ መቆጣጠሪያ"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ይህን መሣሪያ ከእርስዎ ፍላጎቶች ጋር እንዲጣጣም ማበጀት ይችላሉ። እነዚህ የተደራሽነት ባህሪያት በኋላ ላይ በቅንብሮች ውስጥ ሊቀየሩ ይችላሉ።"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"የቅርጸ-ቁምፊ መጠን ይቀይሩ"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"ማያ ገፅ አንባቢ"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"የአካላዊ ቁልፍ ሰሌዳ አማራጮች"</string>
     <string name="captions_category_title" msgid="574490148949400274">"መግለጫ ጽሑፎች"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ኦዲዮ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"አጠቃላይ"</string>
     <string name="display_category_title" msgid="6638191682294461408">"አሳይ"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"ቀለም እና እንቅስቃሴ"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"የቀለም ንጽጽር"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"ከፍተኛ ንፅፅር ጽሑፍን፣ አዝራሮችን እና አዶዎችን የበለጠ ጎልቶ እንዲታዩ ያደርጋል። ለእርስዎ የሚስማማውን ንፅፅር ይምረጡ።"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"አንዳንድ መተግበሪያዎች ሁሉንም የቀለም እና የጽሑፍ ንፅፅር ቅንብሮችን ላይደግፉ ይችላሉ"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"ቀለሞች እና ጽሁፍ ከማያ ገጽዎ ጀርባ ቀለም አንጻር እንዴት እንደሚመስሉ ያስተካክሉ"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"ቅድመ-ዕይታ"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"ሄለን፣ አዳም"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"ከ2 ቀኖች በፊት"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ክትትል ያደርጉበታል?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"የንግድ ጉዞ ሪፖርት"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"ለተጨማሪ እርዳታ እባክዎ \nእኔን ወይም ሄለንን ያግኙ። ይህ ሪፖርት የሚሆነው"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"የደንበኛ ወጪዎች"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"ማያ ገጹን ወደ ጥቁር ይቀይሩ"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"የመስተጋብር መቆጣጠሪያዎች"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"የጊዜ መቆጣጠሪያዎች"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"ለማንኛውም ቀጥል"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"ይቅር"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"የማጉያ ቅንብሮች"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"በአቋራጭ ያጉሉ"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"በአቋራጭ እና ሦስቴ መታ በማድረግ ያጉሉ"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"ስለ<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"ግልፅ አይደልም"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ከፍተኛ ንጽጽር ጽሁፍ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"የጽሑፍ ቀለም ወደ ጥቁር ወይም ነጭ ይቀይሩ። ከዳራ ንፅፅርን ከፍ ያደርገዋል።"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"የጽሑፍ ንፅፅርን ያሳድጉ"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"ከበስተጀርባው ጋር ያለውን ንፅፅር ለመጨመር የጽሑፍ ቀለም ወደ ጥቁር ወይም ነጭ ይቀይሩ።"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"ማጉላትን በራስ-አዘምን"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"የመተግበሪያ ሽግግሮች ላይ ማጉላትን አዘምን"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"የኃይል አዘራር ጥሪውን ይዘገዋል"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"የድምጽ አዝራሮችን ይያዙ"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"ማያ ገጽን ሶስቴ መታ ያድራጉ"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"የተደራሽነት አቋራጮችን ያርትዑ"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"የ%1$s አቋራጭዎን ይምረጡ"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ቀጥል"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"የመስሚያ መሣሪያዎች"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"የASHA እና LE ኦዲዮ መስሚያ አጋዥ መሣሪያዎችን፣ የጆሮ ማዳመጫዎችን እና ሌሎች የማጉላት መሳሪያዎችን ያዋቅሩ እና ያስተዳድሩ"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"ምንም የማዳመጫ መሣሪያዎች አልተገናኙም"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"የአጋዥ መስሚያዎችን ያክሉ"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"መስሚያ አጋዥ መሣሪያዎችን ያጣምሩ"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"የመስሚያ ረዳት ተኳዃኝነት"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ከቴሌኮይሎች ጋር ተኳኋኝነትን ያሻሽላል እና ያልተፈለገ ድምፅ ይቀንሳል"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"ስለማዳመጫ መሣሪያዎች"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"በASHA ወይም LE ኦዲዮ የማይደገፉ ሌሎች የመስማት ችሎታ መሳሪያዎችን ለማግኘት "<b>"አዲስ መሳሪያ አጣምር"</b>" &gt; "<b>"ተጨማሪ መሣሪያዎችን ይመልከቱ"</b>" መታ ያድርጉ"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"የመስሚያ መሣሪያዎን ያጣምሩ"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"በዚህ ገጽ ላይ ASHA እና LE ኦዲዮ የመስማት ችሎታ መሣሪያዎችን ማጣመር ይችላሉ። የመስማት ችሎታ መሣሪያዎ መብራቱን እና ለማጣመር ዝግጁ መሆኑን ያረጋግጡ።"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"የሚገኙ የመስሚያ መሣሪያዎች"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ጽሑፎች"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ራስ-ሰር የውሂብ መቀየር"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"በሽፋን እና በተገኝነት ላይ በመመስረት ከሁለቱም የሲም ውሂብ ይጠቀሙ"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ውሂብ-ብቻ"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"ያዋቅሩ"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"ቀጣይ"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB ያላቸውን በአቅራቢያ ያሉ የመሣሪያዎች አንፃራዊ ቦታ አቀማመጥን ለመለየት ይረዳል"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWBን ለመጠቀም የአውሮፕላን ሁነታን ያጥፉ"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB በአሁኑ አካባቢ አይገኝም"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"ተከታታይ"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"እንከን ለሌለው የዘመናዊ ቤት ተሞክሮ ተከታታይን በመጠቀም ከተኳዃኝ መሣሪያዎች ጋር ይገናኙ"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"ተከታታይን ለመጠቀም የአውሮፕላን ሁነታን ያጥፉ"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"የካሜራ መዳረሻ"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"የማይክሮፎን መዳረሻ"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ለመተግበሪያዎች እና አገልግሎቶች"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"ይቅር"</string>
     <string name="contrast_title" msgid="6885768151336508075">"ንጽጽር"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"መደበኛ"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ነባሪ"</string>
     <string name="contrast_medium" msgid="384414510709285811">"መካከለኛ"</string>
     <string name="contrast_high" msgid="3988567609694797696">"ከፍተኛ"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"ይህ መተግበሪያ መከፈት የሚችለው በ1 መስኮት ብቻ ነው"</string>
diff --git a/res/values-ar/arrays.xml b/res/values-ar/arrays.xml
index 81a2d93..26e22ef 100644
--- a/res/values-ar/arrays.xml
+++ b/res/values-ar/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"معاملة الشبكة باعتبارها تفرض تكلفة استخدام"</item>
     <item msgid="2047166446768045816">"معاملة الشبكة باعتبارها لا تفرض تكلفة استخدام"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"‏استخدام عنوان MAC عشوائي (الإعداد التلقائي)"</item>
-    <item msgid="741680937828608749">"‏استخدام عنوان MAC للجهاز"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"لا"</item>
     <item msgid="2163015208097377388">"نعم"</item>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index c792b11..8c4305c 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"إقران السماعة اليمنى"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"إقران السماعة اليسرى"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"لجميع سماعات الأذن الطبية المتاحة"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"مزيد من إعدادات سماعات الأذن الطبية"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"يمكنك تغيير الإعدادات على أجهزة متعددة مثل عناصر التحكُّم في الملف المغناطيسي والاختصارات."</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"على هذا الجهاز"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"مصدر إخراج الصوت"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"لمحة عن إخراج الصوت"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"جارٍ إعداد المساحة الخاصة…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"يتم إخفاء الإشعارات الواردة من تطبيقات المساحة الخاصة إذا كانت المساحة مقفلة"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"استكشاف إعدادات المساحة الخاصة لإخفاء المساحة الخاصة وضبط إعدادات القفل التلقائي"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"التطبيقات المطلوبة سبَق أن تم تثبيتها في المساحة الخاصّة"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"تعذَّر إعداد مساحة خاصة"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"إعادة المحاولة"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"هل تريد استخدام قفل الشاشة لفتح قفل مساحتك الخاصة؟"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"التطبيقات والإشعارات"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"الإشعارات الحسّاسة على شاشة القفل"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"عرض المحتوى الحسّاس عند فتح قفل المساحة الخاصة"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"‏إنشاء حساب Google للمساعدة في الحفاظ على خصوصية بياناتك"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"في الشاشة التالية، يمكنك تسجيل الدخول إلى أحد الحسابات لاستخدامه في المساحة الخاصّة."</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"إنشاء حساب مخصّص للمساعدة في منع ظهور البيانات خارج المساحة الخاصّة، مثل:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"الصور والملفات والرسائل الإلكترونية وجهات الاتصال وأحداث التقويم والبيانات الأخرى التي تمت مزامنتها"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"الاقتراحات وسجلّ تنزيل التطبيقات"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"سجلّ التصفُّح والإشارات المرجعية وكلمات المرور المحفوظة"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"المحتوى المقترَح بناءً على نشاطك في تطبيقات المساحة الخاصّة"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"حسنًا"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"يمكنك إضافة ما يصل إلى <xliff:g id="COUNT">%d</xliff:g> بصمات إصبع"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"لقد أضفت الحد الأقصى لعدد بصمات الإصبع"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"يتعذر إضافة مزيد من بصمات الإصبع"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"لا يسمح مشغّل شبكة الجوّال بالاتصال بهذه الشبكة لأنّها تستخدِم بروتوكولاً أمنيًا قديمًا بمستوى أمان أقل."</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"السماح بالاتصال بشبكة الخصوصية المكافئة للشبكات السلكية"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"إغلاق"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"هل تريد قطع الاتصال بشبكة \"<xliff:g id="NAME">%1$s</xliff:g>\"؟"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"‏أنت متصل بشبكة WEP. إذا حظرت هذا النوع من الشبكات، سيتم قطع اتصالك."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"الخيارات المتقدمة"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"القائمة المنسدلة \"الخيارات المتقدمة\""</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"توسيع"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"هل تريد استخدام <xliff:g id="NEW_APP">%s</xliff:g> لإدارة اتصالات الشبكة لديك؟"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"طلبات الموقع الجغرافي الأخيرة"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"الموقع الجغرافي للملف الشخصي للعمل"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"أذونات التطبيقات لتحديد الموقع الجغرافي"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"خدمة الموقع الجغرافي غير مفعّلة"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{يملك تطبيق واحد من إجمالي {total} تطبيق إذن الوصول إلى بيانات الموقع الجغرافي.}zero{يملك # تطبيق من إجمالي {total} تطبيق إذن الوصول إلى بيانات الموقع الجغرافي.}two{يملك تطبيقان من إجمالي {total} تطبيق إذن الوصول إلى بيانات الموقع الجغرافي.}few{يملك # تطبيقات من إجمالي {total} تطبيق إذن الوصول إلى بيانات الموقع الجغرافي.}many{يملك # تطبيقًا من إجمالي {total} تطبيق إذن الوصول إلى بيانات الموقع الجغرافي.}other{يملك # تطبيق من إجمالي {total} تطبيق إذن الوصول إلى بيانات الموقع الجغرافي.}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"استخدام لوحة المفاتيح على الشاشة"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"استمرار عرضها على الشاشة عندما تكون لوحة المفاتيح الخارجية متصلة"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"تجاهُل النقرات المتكرّرة"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"تتجاهل لوحة المفاتيح الضغطات المتكررة بسرعة على المفتاح نفسه خلال <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ملي ثانية."</string>
     <string name="slow_keys" msgid="2891452895499690837">"المفاتيح البطيئة"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"لضبط الوقت المُستغرق لتنشيط المفتاح عند الضغط عليه على <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ملي ثانية"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"تثبيت المفاتيح"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"اضغط على مفتاح واحد في كل مرة للحصول على الاختصارات بدلاً من الضغط باستمرار على المفاتيح معًا"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"اختصارات لوحة المفاتيح"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"إظهار قائمة الاختصارات"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"لوحات مفاتيح وأدوات الملف الشخصي للعمل"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"إعادة الضبط"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"اختيار مفتاح التعديل"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"اختيار مفتاح جديد لـ \"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>\":"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"تلقائي"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"الكلام"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"سرعة المؤشر"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"وحدة التحكم في الألعاب"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"يمكنك تخصيص هذا الجهاز ليتوافق مع احتياجاتك. ويمكن تغيير ميزات \"تسهيل الاستخدام\" هذه لاحقًا من خلال الإعدادات."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"تغيير حجم الخط"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"قارئ الشاشة"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"لوحة المفاتيح الخارجية"</string>
     <string name="captions_category_title" msgid="574490148949400274">"الشرح"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"الصوت"</string>
     <string name="general_category_title" msgid="6298579528716834157">"الإعدادات العامة"</string>
     <string name="display_category_title" msgid="6638191682294461408">"العرض"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"اللون والصور المتحركة"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"تباين الألوان"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"يعمل التباين العالي على زيادة بروز النص والأزرار والرموز. يمكنك اختيار مستوى التباين الأنسب لك."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"قد لا تتوافق بعض التطبيقات مع كل إعدادات التباين في اللون والنص."</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"يمكنك تعديل مظهر الألوان والنص بما يتوافق مع لون خلفية الشاشة."</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"معاينة"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"شروق، وآدم"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"قبل يومَين"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"أتريد المتابعة؟"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"تقرير رحلة العمل"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"للحصول على مساعدة إضافية، يرجى الرجوع \nإلىّ أو إلى شروق. سيكون هذا التقرير"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"نفقات العملاء"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"جعل الشاشة أقل سطوعًا"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"عناصر التحكم في التفاعل"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"عناصر التحكّم في التوقيت"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"المتابعة على أيّ حال"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"إلغاء"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"إعدادات التكبير"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"التكبير باستخدام الاختصار"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"التكبير باستخدام الزر والنقر الثلاثي"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"لمحة عن <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"غير شفاف"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"نص بدرجة تباين عالية"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"يمكنك تغيير لون النص إلى الأبيض أو الأسود. سيؤدي ذلك إلى زيادة التباين مع الخلفية."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"زيادة تباين النص إلى أقصى حد"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"يمكنك تغيير لون النص إلى الأسود أو الأبيض لزيادة درجة التباين عن الخلفية."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"التحديث التلقائي لتكبير الشاشة"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"تحديث تكبير الشاشة أثناء تنقلات التطبيق"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"إنهاء الاتصال عبر زر التشغيل"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"الضغط مع الاستمرار على مفتاحَي التحكّم بمستوى الصوت"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"النقر ثلاث مرات على الشاشة"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"تعديل اختصارات تسهيل الاستخدام"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"‏اختيار الاختصار المؤدي إلى %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"متابعة"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"سماعات الأذن الطبية"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"‏إعداد وإدارة سماعات الأذن الطبية المتوافقة مع بروتوكول ASHA وLE Audio والقواقع المزروعة وغيرها من أجهزة تضخيم الصوت"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"لم يتم توصيل سماعات أذن طبية."</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"إضافة سمّاعات الأذن الطبية"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"إقران سماعتَي الأذن الطبيتين"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"التوافق مع السماعات الطبية"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"تحسين التوافق مع الملفات المغناطيسية وتقليل الضوضاء غير المرغوب فيها"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"لمحة عن سماعات الأذن الطبية"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"‏للعثور على سماعات أذن طبية أخرى غير متوافقة مع بروتوكول ASHA أو LE Audio، انقر على "<b>"إقران جهاز جديد"</b>" &gt; "<b>"عرض المزيد من الأجهزة"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"إقران سماعة الأذن الطبية"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"‏يمكنك إقران سماعات الأذن الطبية المزودة بتكنولوجيا ASHA وتطبيق LE Audio على هذه الصفحة. تأكَّد من تشغيل سماعة الأذن الطبية وجاهزيتها للإقران."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"سماعات الأذن الطبية المتاحة"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"الرسائل النصية"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"‏التبديل التلقائي لبيانات SIM"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"‏استخدِم البيانات المستمدة من شريحة SIM اعتمادًا على مدى التغطية أو التوفّر."</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"البيانات فقط"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"إعداد"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"التالي"</string>
@@ -4945,12 +4932,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"يساعد هذا الإعداد في التعرّف على الموضع النسبي للأجهزة القريبة التي تستخدم النطاق الواسع جدًا."</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"يجب إيقاف وضع الطيران لاستخدام النطاق الواسع جدًا."</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"‏النطاق الفائق العرض (UWB) غير متاح في الموقع الجغرافي الحالي."</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"‏اتّصل بالأجهزة المتوافقة باستخدام Thread للحصول على تجربة سلسة في المنزل المزوَّد بأجهزة ذكية"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"‏يجب إيقاف وضع الطيران لاستخدام Thread."</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"الوصول إلى الكاميرا"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"الوصول إلى الميكروفون"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"للتطبيقات والخدمات"</string>
@@ -5127,8 +5111,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"إلغاء"</string>
     <string name="contrast_title" msgid="6885768151336508075">"التباين"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"عادي"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"تلقائي"</string>
     <string name="contrast_medium" msgid="384414510709285811">"متوسط"</string>
     <string name="contrast_high" msgid="3988567609694797696">"مرتفع"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"لا يمكن فتح هذا التطبيق إلا في نافذة واحدة."</string>
diff --git a/res/values-as/arrays.xml b/res/values-as/arrays.xml
index 40eb7d7..432af5e 100644
--- a/res/values-as/arrays.xml
+++ b/res/values-as/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"নিৰিখ-নিৰ্দিষ্ট হিচাপে ব্যৱহাৰ কৰক"</item>
     <item msgid="2047166446768045816">"নিৰিখ অনিৰ্দিষ্ট বুলি গণ্য কৰক"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"যাদৃচ্ছিক MAC ব্যৱহাৰ কৰক (ডিফ’ল্ট)"</item>
-    <item msgid="741680937828608749">"ডিভাইচৰ MAC ব্যৱহাৰ কৰক"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"নহয়"</item>
     <item msgid="2163015208097377388">"হয়"</item>
diff --git a/res/values-as/strings.xml b/res/values-as/strings.xml
index 6ec76c3..eea204a 100644
--- a/res/values-as/strings.xml
+++ b/res/values-as/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"সোঁ কাণখন পেয়াৰ কৰক"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"বাওঁ কাণখন পেয়াৰ কৰক"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"আটাইবোৰ উপলব্ধ শুনাৰ ডিভাইচৰ বাবে"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"শুনাৰ ডিভাইচৰ অধিক ছেটিং"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"শ্বৰ্টকাট আৰু টেলিকইল নিয়ন্ত্ৰণৰ দৰে ক্ৰছ-ডিভাইচৰ ছেটিংসমূহ সলনি কৰক"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"এই ডিভাইচটোৰ কাৰণে"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"অডিঅ’ আউটপুট"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"অডিঅ’ আউটপুটৰ বিষয়ে"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"ব্যক্তিগত স্পে’চ ছেট আপ কৰি থকা হৈছে…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ব্যক্তিগত স্পে’চ লক হৈ থাকিলে তাত থকা এপৰ জাননী লুকুওৱা হয়"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"প্ৰাইভেট স্পেচ লুকুৱাই ৰাখিবলৈ আৰু স্বয়ংক্ৰিয়ভাৱে লক কৰাটো ছেট আপ কৰিবলৈ প্ৰাইভেট স্পেচৰ ছেটিঙত অন্বেষণ কৰক"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"প্ৰয়োজনীয় এপ্‌সমূহ ইতিমধ্যে আপোনাৰ প্ৰাইভেট স্পেচত ইনষ্টল কৰা হৈছে"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"কোনো ব্যক্তিগত স্পে’চ ছেট আপ কৰিব পৰা নগ’ল"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"পুনৰ চেষ্টা কৰক"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"ব্যক্তিগত স্পে’চ আনলক কৰিবলৈ স্ক্ৰীন লক ব্যৱহাৰ কৰিবনে?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"এপ্ আৰু জাননী"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"লক স্ক্ৰীনত সংবেদনশীল জাননী"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"প্ৰাইভেট স্পেচ আনলক হৈ থকাৰ সময়ত সংবেদনশীল সমল দেখুওৱা"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"আপোনাৰ ডেটা ব্যক্তিগত কৰি ৰখাত সহায় কৰিবলৈ এটা Google একাউণ্ট সৃষ্টি কৰক"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"পৰৱৰ্তী স্ক্ৰীনত আপুনি আপোনাৰ প্ৰাইভেট স্পেচৰ সৈতে ব্যৱহাৰ কৰিবলৈ এটা একাউণ্টত ছাইন ইন কৰিব পাৰিব"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"প্ৰাইভেট স্পেচৰ বাহিৰত তথ্য প্ৰদৰ্শিত হোৱাটো বন্ধ কৰাত সহায় কৰিবলৈ এটা সমৰ্পিত একাউণ্ট সৃষ্টি কৰক, যেনে:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"ছিংক কৰা ফট’, ফাইল, ইমেইল, সম্পৰ্ক, কেলেণ্ডাৰৰ অনুষ্ঠান আৰু আন ডেটা"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"এপ্‌ ডাউনল’ডৰ ইতিহাস আৰু চুপাৰিছসমূহ"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ব্ৰাউজিঙৰ ইতিহাস, বুকমাৰ্ক আৰু ছেভ কৰা পাছৱৰ্ডসমূহ"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"প্ৰাইভেট স্পেচৰ এপ্‌সমূহত আপোনাৰ কাৰ্যকলাপৰ সৈতে সম্পৰ্কিত পৰামৰ্শিত সমল"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"বুজি পালোঁ"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"আপুনি <xliff:g id="COUNT">%d</xliff:g> টালৈকে ফিংগাৰপ্ৰিণ্ট যোগ কৰিব পাৰে"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"আপুনি সৰ্বাধিক সংখ্যক ফিংগাৰপ্ৰিণ্টবোৰ যোগ কৰিছে"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"আৰু অধিক ফিংগাৰপ্ৰিণ্ট যোগ কৰিব নোৱাৰি"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"আপোনাৰ বাহকে আপোনাক এই নেটৱৰ্কটোৰ সৈতে সংযোগ কৰিবলৈ নিদিয়ে কাৰণ ই এটা কম সুৰক্ষিত অধিক পুৰণি সুৰক্ষাৰ প্ৰট’কল ব্যৱহাৰ কৰে"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP অনুমতি দিয়ক"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"বন্ধ কৰক"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g>ৰ পৰা সংযোগ বিচ্ছিন্ন কৰিবনে?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"আপুনি এটা WEP নেটৱৰ্কৰ সৈতে সংযুক্ত হৈ আছে। যদি আপুনি এই নেটৱৰ্কসমূহ অৱৰোধ কৰে, আপোনাক সংযোগ বিচ্ছিন্ন কৰা হ’ব।"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"উচ্চখাপৰ বিকল্প"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ড্ৰ’প ডাউন তালিকাৰ উন্নত বিকল্পসমূহ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"বিস্তাৰিত কৰক"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"আপোনাৰ নেটৱৰ্কৰ সংযোগসমূহ পৰিচালনা কৰিবলৈ <xliff:g id="NEW_APP">%s</xliff:g>ক ব্যৱহাৰ কৰিবনে?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"শেহতীয়া অৱস্থানৰ অনুৰোধ"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"কৰ্মস্থানৰ প্ৰ’ফাইলৰ বাবে অৱস্থান"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"এপৰ অৱস্থানৰ অনুমতি"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"অৱস্থান সুবিধা অফ আছে"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} টাৰ ভিতৰত # টা এপে অৱস্থান এক্সেছ কৰিব পাৰে}one{{total} টাৰ ভিতৰত # টা এপে অৱস্থান এক্সেছ কৰিব পাৰে}other{{total} টাৰ ভিতৰত # টা এপে অৱস্থান এক্সেছ কৰিব পাৰে}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"অন-স্ক্ৰীন কীব’ৰ্ড ব্যৱহাৰ কৰক"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"কায়িক কীব’ৰ্ড সক্ৰিয় হৈ থাকিলে ইয়াক স্ক্ৰীনত ৰাখিব"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"বাউন্স কী"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"কীব’ৰ্ডে <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> msৰ ভিতৰত একেটা কী ক্ষিপ্ৰতাৰে বাৰে বাৰে টিপাটো উপেক্ষা কৰে।"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ধীৰ গতিৰ কী"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> এমএছ সক্ৰিয় কৰিবলৈ এটা কী টিপাৰ বাবে লগা সময় মিলাওক"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ষ্টিকী কী"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"একেলগে কীসমূহ টিপি ধৰি থকাৰ সলনি শ্বৰ্টকাটৰ বাবে এবাৰত এটা কী টিপক"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"কীব’ৰ্ডৰ শ্বৰ্টকাটসমূহ"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"শ্বৰ্টকাটৰ সূচী দেখুৱাওক"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"কৰ্মস্থানৰ প্ৰ’ফাইল আৰু সঁজুলি"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ৰিছেট কৰক"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"সংশোধক চাবি বাছনি কৰক"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>ৰ বাবে এটা নতুন চাবি বাছনি কৰক:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ডিফ\'ল্ট"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"কথন"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"পইণ্টাৰৰ বেগ"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"গেইম নিয়ন্ত্ৰক"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"আপুনি আপোনাৰ প্ৰয়োজনীতাসমূহৰ সৈতে মিলাকৈ এই ডিভাইচটো কাষ্টমাইজ কৰিব পাৰে। এই সাধ্য সুবিধাসমূহ পাছত ছেটিঙলৈ গৈ সলনি কৰিব পাৰি।"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ফণ্টৰ আকাৰ সলনি কৰক"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"স্ক্ৰীন ৰীডাৰ"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"কায়িক কীব’ৰ্ডৰ বিকল্প"</string>
     <string name="captions_category_title" msgid="574490148949400274">"কেপশ্বন"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"অডিঅ’"</string>
     <string name="general_category_title" msgid="6298579528716834157">"সাধাৰণ"</string>
     <string name="display_category_title" msgid="6638191682294461408">"ডিছপ্লে’"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"ৰং আৰু ম’শ্বন"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"ৰঙৰ কনট্ৰাষ্ট"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"উচ্চ কনট্ৰাষ্টে পাঠ, বুটাম আৰু চিহ্নসমূহক অধিক জিলিকাই ৰাখে। আপোনাৰ বাবে যিটো কনট্ৰাষ্ট আটাইতকৈ ভাল লাগে সেইটো বাছনি কৰক।"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"কিছুমান এপে আটাইবোৰ ৰং আৰু পাঠৰ কনট্ৰাষ্টৰ ছেটিং সমৰ্থন নকৰিবও পাৰে"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"আপোনাৰ স্ক্ৰীনৰ পটভূমিৰ ৰঙৰ বিপৰীতে ৰং আৰু পাঠ কেনেকুৱা দেখা যায় সেইটো মিলাওক"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"পূৰ্বদৰ্শন কৰক"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"হেলেন, এডাম"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"২ দিন পূৰ্বে"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ফ’ল’ আপ কৰিবনে?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"ব্যৱসায়িক ভ্ৰমণৰ ৰিপ’ৰ্ট"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"অধিক সহায়ৰ বাবে মোৰ বা হেলেনৰ \nসৈতে যোগাযোগ কৰক। এই ৰিপ’ৰ্টটো"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"ক্লায়েণ্টৰ সৈতে সম্পৰ্কিত ব্যয়"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"স্ক্ৰীনখন গাঢ় কৰক"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ভাব-বিনিময় নিয়ন্ত্ৰণ"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"সময়ৰ নিয়ন্ত্ৰণ"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"যি হ’লেও অব্যাহত ৰাখক"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"বাতিল কৰক"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"বিবৰ্ধন কৰাৰ ছেটিং"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"শ্বৰ্টকাটৰ দ্বাৰা বিৱৰ্ধিত কৰক"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"শ্বৰ্টকাটৰ দ্বাৰা আৰু তিনিবাৰ টিপি বিৱৰ্ধিত কৰক"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>ৰ বিষয়ে"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"স্বচ্ছ নহয়"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ৰঙৰ উচ্চ প্ৰভেদযুক্ত পাঠ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"পাঠৰ ৰং ক’লা অথবা বগালৈ সলনি কৰক। পটভূমিৰ সৈতে কনট্ৰাষ্ট বৃদ্ধি কৰে।"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"পাঠৰ কনট্ৰাষ্ট সৰ্বাধিক কৰক"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"পটভূমিৰ সৈতে কনট্ৰাষ্ট বৃদ্ধি কৰিবলৈ পাঠৰ ৰং ক’লা বা বগালৈ সলনি কৰক।"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"স্ক্ৰীনৰ বিবৰ্ধন স্বয়ংক্ৰিয়ভাৱে আপডে’ট কৰক"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"এপ্ সঞ্চৰণৰ সময়ত স্ক্ৰীনৰ বিবৰ্ধন আপডে’ট কৰক"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"পাৱাৰ বুটাম টিপিলে কল সমাপ্ত হ\'ব"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"ভলিউম কীসমূহ ধৰি ৰখা"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"স্ক্রীনত তিনিবাৰ টিপা"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"সাধ্য সুবিধাৰ শ্বৰ্টকাটসমূহ সম্পাদনা কৰক"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$sৰ বাবে আপোনাৰ শ্বৰ্টকাটটো বাছনি কৰক"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"অব্যাহত ৰাখক"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"শুনাৰ ডিভাইচ"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA আৰু LE অডিঅ’ শ্ৰৱণ যন্ত্ৰ, ক’ক্লিয়াৰ ইমপ্লাণ্ট, আৰু অন্য ধ্বনি পৰিৱৰ্ধক ডিভাইচসমূহ ছেট আপ আৰু পৰিচালনা কৰক"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"কোনো শুনাৰ ডিভাইচ সংযোগ হৈ থকা নাই"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"শ্ৰৱণ যন্ত্ৰ যোগ কৰক"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"শ্ৰৱণ যন্ত্ৰ পেয়াৰ কৰক"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"শ্ৰৱণ যন্ত্ৰৰ সুসংগতা"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"টেলিকইলৰ সৈতে সুসংগতা উন্নত কৰে আৰু অবাঞ্ছিত কোলাহল হ্ৰাস কৰে"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"শুনাৰ ডিভাইচৰ বিষয়ে"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA বা LE অডিঅ’ই সমৰ্থন নকৰা অন্য শুনাৰ ডিভাইচ বিচাৰিবলৈ, tap "<b>"নতুন ডিভাইচ পেয়াৰ কৰক"</b>" &gt; "<b>"অধিক ডিভাইচ চাওক"</b>"ত টিপক"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"শুনাৰ ডিভাইচত পেয়াৰ কৰক"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"আপুনি এই পৃষ্ঠাখনত ASHA আৰু LE অডিঅ’ৰ শুনাৰ ডিভাইচ পেয়াৰ কৰিব পাৰে। আপোনাৰ শুনাৰ ডিভাইচটো অন হৈ থকাৰ লগতে পেয়াৰ কৰিবলৈ সাজু হৈ থকাটো নিশ্চিত কৰক।"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"উপলব্ধ শুনাৰ ডিভাইচ"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"পাঠ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"স্বয়ংক্ৰিয় ডেটা সলনি কৰা"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"ক’ভাৰেজ আৰু উপলব্ধতাৰ ওপৰত নিৰ্ভৰ কৰি যিকোনো এখন ছিমৰ পৰা ডেটা ব্যৱহাৰ কৰক"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"কেৱল ডেটা"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"ছেট আপ কৰক"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"পৰৱৰ্তী"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB থকা নিকটৱৰ্তী ডিভাইচৰ আপেক্ষিক স্থান চিনাক্ত কৰাত সহায় কৰে"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB ব্যৱহাৰ কৰিবলৈ এয়াৰপ্লেন ম’ডটো অফ কৰক"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"বৰ্তমানৰ অৱস্থানত UWB উপলব্ধ নহয়"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"থ্ৰেড"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"স্মাৰ্ট হ’মৰ বাধাহীন অভিজ্ঞতা লাভ কৰিবলৈ থ্ৰেড ব্যৱহাৰ কৰি সমিল ডিভাইচসমূহৰ সৈতে সংযোগ কৰক"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"থ্ৰেড ব্যৱহাৰ কৰিবলৈ এয়াৰপ্লেন ম’ডটো অফ কৰক"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"কেমেৰাৰ এক্সেছ"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"মাইক্ৰ’ফ’নৰ এক্সেছ"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"এপ্‌ আৰু সেৱাৰ বাবে"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"বাতিল কৰক"</string>
     <string name="contrast_title" msgid="6885768151336508075">"কনট্ৰাষ্ট"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"মানক"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ডিফ’ল্ট"</string>
     <string name="contrast_medium" msgid="384414510709285811">"মধ্যমীয়া"</string>
     <string name="contrast_high" msgid="3988567609694797696">"উচ্চ"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"এই এপ্‌টো কেৱল ১ খন ৱিণ্ড’ত খুলিব পাৰি"</string>
diff --git a/res/values-az/arrays.xml b/res/values-az/arrays.xml
index c7c30cc..dde911d 100644
--- a/res/values-az/arrays.xml
+++ b/res/values-az/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tarifikasiya ilə işlədin"</item>
     <item msgid="2047166446768045816">"Tarifikasiyasız işlədin"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"İxtiyari MAC (defolt) istifadə edin"</item>
-    <item msgid="741680937828608749">"Cihazın MAC-ünvanını istifadə edin"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Xeyr"</item>
     <item msgid="2163015208097377388">"Bəli"</item>
diff --git a/res/values-az/strings.xml b/res/values-az/strings.xml
index c5fb8d4..d010e8f 100644
--- a/res/values-az/strings.xml
+++ b/res/values-az/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Sağ qulaqlığı birləşdirin"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Sol qulaqlığı birləşdirin"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Bütün əlçatan eşitmə cihazları üçün"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Digər eşitmə cihazı ayarları"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Qısayol və tele-induktor nizamlayıcıları kimi cihazlararası ayarları dəyişin"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Bu cihaz üçün"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio çıxışı"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Audio çıxışı haqqında"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Məxfi yer ayarlanır…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Kilidli olduqda şəxsi sahə tətbiqlərinin bildirişləri gizlədilir"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Şəxsi sahəni gizlətmək və avtomatik kilidləməni qurmaq üçün şəxsi sahə ayarlarını araşdırın"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Lazımi tətbiqlər şəxsi sahəyə quraşdırılıb"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Şəxsi sahə ayarlanmadı"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Yenidən cəhd edin"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Məxfi yer ekran kilidi ilə açılsın?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Tətbiq və bildirişlər"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Kilid ekranında həssas bildirişlər"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Şəxsi sahə kiliddən çıxarıldıqda həssas kontent göstərilsin"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Datanı məxfi saxlamaq üçün Google Hesabı yaradın"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Növbəti ekranda şəxsi sahədən istifadə üçün hesaba daxil ola bilərsiniz"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Datanın şəxsi məkandan kənarda görünməməsi üçün xüsusi hesab yaradın, məsələn:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinxronlaşdırılmış foto, fayl, e-poçt, kontakt, təqvim hadisələri və digər data"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Tətbiq endirmə tarixçəsi və tövsiyələr"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Baxış tarixçəsi, əlfəcinlər və saxlanan parollar"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Şəxsi sahə tətbiqlərindəki fəaliyyətlə bağlı təklif olunan məzmun"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Anladım"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"<xliff:g id="COUNT">%d</xliff:g> ədədə qədər barmaq izi əlavə edə bilərsiniz"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Maksimum sayda barmaq izi əlavə etmisiniz"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Daha artıq barmaq izi əlavə edilə bilməz"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Güvənliyi az olan köhnə təhlükəsizlik protokolundan istifadə etdiyi üçün operator bu şəbəkəyə qoşulmağa icazə vermir"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP-ə icazə verin"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Bağlayın"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> ilə bağlantı kəsilsin?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP şəbəkəsinə qoşulmusunuz. Bu şəbəkələr bloklansa, bağlantı kəsiləcək."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Qabaqcıl seçimlər"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Aşağıya açılan siyahı Qabaqcıl Seçimləri"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"genişləndirin"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Şəbəkə bağlantılarını idarə edilmək üçün <xliff:g id="NEW_APP">%s</xliff:g> istifadə edilsin?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Son məkan sorğuları"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"İş profili üçün yer"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Tətbiq məkanı icazələri"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Məkan deaktivdir"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{#/{total} tətbiqin məkana giriş icazəsi var}other{#/{total} tətbiqin məkana giriş icazəsi var}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Ekran klaviaturası istifadə edin"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Fiziki klaviatura aktiv olanda görünsün"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Sıçrama düymələri"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Klaviatura <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms ərzində eyni düymənin tez-tez basılmasını nəzərə almır"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Asta düymələr"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Düymənin aktivləşdirilməsi vaxtını <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms-ə tənzimləyir"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Əvəzedici düymələr"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Qısayollar üçün düymələri birlikdə basıb saxlamaq əvəzinə hər dəfə bir düyməyə basın"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klaviatura qısayolları"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Qısayolların siyahısını göstərin"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"İş profili klaviaturaları və alətlər"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Sıfırlayın"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Dəyişdirici açarı seçin"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> üçün yeni açar seçin:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Defolt"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Nitq"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Kursor sürəti"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Oyun Kontrolleri"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Cihazı rahat işlətmək üçün fərdiləşdirin. Xüsusi imkanları ayarlarda dəyişmək olur."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Şriftin ölçüsünü dəyişin"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekran oxuyucusu"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Fiziki klaviatura seçimləri"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtitrlər"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Ümumi"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Ekran"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Rəng və hərəkət"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Rəng kontrastı"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Yüksək kontrast mətn, düymələr və ikonaları fərqləndirir. Ən yaxşı görünən kontrastı seçin."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Bəzi tətbiqlər bütün rəng və mətn kontrastı ayarlarını dəstəkləməyə bilər"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Rənglər və mətni ekranda fərqləndirin"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Önizləyin"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 gün əvvəl"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Davam edilsin?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Biznes səfəri hesabatı"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Əlavə yardım üçün \nmənimlə və ya Helen ilə əlaqə saxlayın. Bu hesabat:"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Klient xərcləri"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekranı qaraldın"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Qarşılıqlı əlaqə nəzarəti"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Zamanlama üzrə idarə elementləri"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Yenə də davam edin"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Ləğv edin"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Böyütmə ayarları"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Qısayol ilə böyüdün"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Qısayol &amp; üç toxunuşla böyüdün"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> haqqında"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Qeyri-şəffaf"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Yüksək kontrastlı mətn"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mətnin rəngini qara və ya ağ edin. Arxa fonla kontrastı maksimum dərəcədə artırır."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Mətn kontrastını artırın"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Arxa fonda kontrastı artırmaq üçün mətn rəngini qara və ya ağa dəyişin."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ekran böyüdücünü avtomatik güncəlləyin"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Tətbiq keçidlərində ekran böyüdücünü güncəlləyin"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Qidalanma düyməsi zəngi sonlandırır"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Səs düymələrinə basıb saxlayın"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Ekrana üç dəfə toxunun"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Xüsusi imkanlar qısayollarını redaktə edin"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s üçün qısayol seçin"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Davam edin"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Eşitmə cihazları"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA və LE Audio eşitmə aparatları, koxlear implantları və digər səs gücləndirici cihazları idarə edin"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Eşitmə cihazı qoşulmayıb"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Eşitmə aparatları əlavə edin"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Eşitmə cihazlarını birləşdirin"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Eşitmə cihazının uyğunluğu"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Tele-induktor ilə uyğunluğu yaxşılaşdırır və arzuolunmaz səs-küyü azaldır"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Eşitmə cihazları haqqında"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA və ya LE Audio tərəfindən dəstəklənməyən digər eşitmə cihazlarını tapmaq üçün "<b>"Yeni cihaz birləşdirin"</b>" &gt; "<b>"Digər cihazlara baxın"</b>" üzərinə toxunun"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Eşitmə cihazını birləşdir"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Bu səhifədə ASHA və LE Audio eşitmə cihazlarını birləşdirə bilərsiniz. Eşitmə cihazı aktiv edilməli və birləşdirməyə hazır olmalıdır."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Əlçatan eşitmə cihazları"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mətn mesajları"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Avtomatik data keçirmə"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Əhatə dairəsi və əlçatanlıqdan asılı olaraq istənilən SIM-in datasından istifadə edin"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Yalnız data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Ayarlayın"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Növbəti"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB olan yaxınlıqdakı cihazların nisbi mövqeyini müəyyənləşdirməyə kömək edir"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB istifadə etmək üçün təyyarə rejimini deaktiv edin"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB cari məkanda əlçatan deyil"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Qüsursuz smart ev təcrübəsi üçün Thread ilə uyğun cihazlara qoşulun"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread istifadəsi üçün təyyarə rejimini deaktiv edin"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kameraya giriş"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofona giriş"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Tətbiqlər və xidmətlər üçün"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Ləğv edin"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standart"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Defolt"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Orta"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Yüksək"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Bu tətbiq yalnız 1 pəncərədə açıla bilər"</string>
diff --git a/res/values-b+sr+Latn/arrays.xml b/res/values-b+sr+Latn/arrays.xml
index a5fe9e7..81d4c3d 100644
--- a/res/values-b+sr+Latn/arrays.xml
+++ b/res/values-b+sr+Latn/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tretiraj kao mrežu sa ograničenjem"</item>
     <item msgid="2047166446768045816">"Tretiraj kao mrežu bez ograničenja"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Koristi nasumičnu MAC adresu (podrazumevano)"</item>
-    <item msgid="741680937828608749">"Koristi MAC adresu uređaja"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ne"</item>
     <item msgid="2163015208097377388">"Da"</item>
diff --git a/res/values-b+sr+Latn/strings.xml b/res/values-b+sr+Latn/strings.xml
index c5e980c..79ae8fd 100644
--- a/res/values-b+sr+Latn/strings.xml
+++ b/res/values-b+sr+Latn/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Upari desno uvo"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Upari levo uvo"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Za sve dostupne slušne aparate"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Još podešavanja slušnog aparata"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Promenite podešavanja na više uređaja, na primer kontrole prečica i telekoila"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Za ovaj uređaj"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio izlaz"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"O audio izlazu"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Podešava se privatni prostor…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Obaveštenja iz aplikacija u privatnom prostoru su skrivena kad je on zaključan"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Istražite podešavanja privatnog prostora da biste ga sakrili i podesili automatsko zaključavanje"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Obavezne aplikacije su već instalirane u privatnom prostoru"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Podešavanje privatnog prostora nije uspelo"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Probaj ponovo"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Otključati privatni prostor otključavanjem ekrana?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikacije i obaveštenja"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Osetljiva obaveštenja na zaključanom ekranu"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Prikazujte osetljiv sadržaj kada je privatni prostor otključan"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Otvorite namenski Google nalog da biste zaštitili privatnost podataka"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na sledećem ekranu možete da se prijavite na nalog koji ćete koristiti sa privatnim prostorom"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Otvorite namenski nalog kako biste sprečili da se izvan privatnog prostora prikazuju podaci, na primer:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinhronizovane slike, fajlovi, imejlovi, kontakti, događaji u kalendaru i drugi podaci"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Istorija preuzimanja aplikacije i preporuke"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Istorija pregledanja, obeleživači i sačuvane lozinke"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Predložen sadržaj povezan sa aktivnostima u aplikacijama iz privatnog prostora"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Važi"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Možete da ih dodate do <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodali ste maksimalan broj otisaka prstiju"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Ne možete da dodate još otisaka prstiju"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Mobilni operater ne dozvoljava da se povežete sa ovom mrežom jer ona koristi stariji bezbednosni protokol koji je manje siguran"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Dozvoli WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Zatvori"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Želite da prekinete vezu sa: <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Povezani ste na WEP mrežu. Ako blokirate ove mreže, nećete biti povezani."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Napredne opcije"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Padajuća lista sa naprednim opcijama"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"proširite"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Želite li da koristite aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje mrežnim vezama?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavni zahtevi za lokaciju"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za poslovni profil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Dozvole za lokaciju aplikacije"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokacija je isključena"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Pristup lokaciji ima # aplikacija od {total}}one{Pristup lokaciji ima # aplikacija od {total}}few{Pristup lokaciji imaju # aplikacije od {total}}other{Pristup lokaciji ima # aplikacija od {total}}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Koristi tastaturu na ekranu"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Zadržava se na ekranu dok je fizička tastatura aktivna"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Duži odziv tastera"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tastatura zanemaruje brze pritiske istog tastera koji se ponavljaju u roku od <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Spori tasteri"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Priladite vreme potrebno da se taster aktivira posle pritiska na <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Lepljivi tasteri"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Pritiskajte jedan po jedan taster da biste koristili prečice umesto da istovremeno držite tastere"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tasterske prečice"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Prikazuje listu prečica"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastature i alatke za poslovni profil"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Resetuj"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Odaberite modifikujući taster"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Odaberite novi taster za <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Raspored <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Podrazumevano"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatski: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Izabrao je korisnik: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Govor"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Brzina pokazivača"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Kontroler za igre"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Možete da prilagodite ovaj uređaj prema potrebama. Te funkcije pristupačnosti možete kasnije da promenite u Podešavanjima."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Promenite veličinu fonta"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Čitač ekrana"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opcije fizičke tastature"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Titl"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Zvuk"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Opšte"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Prikaz"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Boja i pokret"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kontrast boja"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Veći kontrast ističe tekst, dugmad i ikone. Izaberite kontrast koji vam izgleda najbolje."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Neke aplikacije možda ne podržavaju sva podešavanja za kontrast boja i teksta"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Prilagodite izgled boja i teksta u odnosu na boju pozadine ekrana"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Pregled"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helena, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Pre 2 dana"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Dodatni upit?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Izveštaj o poslovnom putu"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Da biste dobili dodatnu pomoć, obratite se \nmeni ili Heleni. Ovaj izveštaj će biti"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Troškovi klijenta"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Zatamnjuje ekran"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrole interakcije"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrole vremenskih odrednica"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Ipak nastavi"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Otkaži"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Podešavanja uvećanja"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Uvećavajte pomoću prečice"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Uvećavajte pomoću prečice i trostrukog dodira"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"O usluzi <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Nije prozirno"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst visokog kontrasta"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Promenite boju teksta u crnu ili belu. Maksimalno uvećava kontrast sa pozadinom."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimalno uvećajte kontrast teksta"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Promenite boju teksta u crnu ili belu da biste povećali kontrast sa pozadinom."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automatski ažuriraj uvelič. ekrana"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ažurira uveličavanje ekrana pri prelazu aplikacija"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Dugme za uključivanje prekida poziv"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Zadržite tastere za jačinu zvuka"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Dodirnite ekran triput"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Izmenite prečice za pristupačnost"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Izaberite prečicu za %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Nastavi"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Slušni aparati"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Podesite slušne aparate koji imaju ASHA i LE Audio, kohlearne implante i uređaje za pojačavanje zvuka i upravljajte njima"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nema povezanih slušnih aparata"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Dodajte slušne aparate"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Uparite slušne aparate"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilnost sa slušnim aparatima"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Poboljšava kompatibilnost sa telekoilovima i smanjuje neželjenu buku"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"O slušnim aparatima"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Da biste pronašli druge slušne aparate koji nemaju ASHA ni LE Audio, dodirnite "<b>"Upari novi uređaj"</b>" &gt; "<b>"Prikaži još uređaja"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Uparite slušni aparat"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Na ovoj stranici možete da uparite slušne aparate koji imaju ASHA i LE Audio. Proverite da li je slušni aparat uključen i spreman za uparivanje."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostupni slušni aparati"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS poruke"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Auto. zamena prenosa podataka"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Koristi prenos podataka sa bilo kog SIM-a u zavisnosti od pokrivenosti i dostupnosti"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Samo prenos podataka"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Podesi"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Dalje"</string>
@@ -4942,12 +4926,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomaže u identifikaciji relativnog položaja uređaja u blizini koji imaju UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Isključuje režim rada u avionu radi korišćenja UWB-a"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Ultra-široki pojas je nedostupan na aktuelnoj lokaciji"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Povežite se sa kompatibilnim uređajima pomoću Thread-a da biste imali besprekoran doživljaj pametne kuće"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Isključite režim rada u avionu da biste koristili Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Pristup kameri"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Pristup mikrofonu"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Za aplikacije i usluge"</string>
@@ -5124,8 +5105,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Otkaži"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standardno"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Podrazumevano"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Srednje"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Visoko"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ova aplikacija može da se otvori samo u jednom prozoru"</string>
diff --git a/res/values-be/arrays.xml b/res/values-be/arrays.xml
index bb2c26f..5f7fa0f 100644
--- a/res/values-be/arrays.xml
+++ b/res/values-be/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"З падлікам трафіка"</item>
     <item msgid="2047166446768045816">"Без падліку трафіка"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Выпадковы MAC-адрас (стандартна)"</item>
-    <item msgid="741680937828608749">"Выкарыстоўваць MAC-адрас прылады"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Не"</item>
     <item msgid="2163015208097377388">"Так"</item>
diff --git a/res/values-be/strings.xml b/res/values-be/strings.xml
index e9abf0d..0d6e154 100644
--- a/res/values-be/strings.xml
+++ b/res/values-be/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Спалучыць для правага вуха"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Спалучыць для левага вуха"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Для ўсіх даступных слыхавых апаратаў"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Іншыя налады слыхавога апарата"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Змяніце налады для некалькіх прылад (напрыклад, налады індукцыйнай шпулі і хуткага доступу)"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Для гэтай прылады"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аўдыявыхад"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Пра аўдыявыхад"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Ідзе наладжванне прыватнай прасторы…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Калі доступ да прыватнай прасторы заблакіраваны, апавяшчэнні з дададзеных у яе праграм не паказваюцца"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"У наладах прыватнай прасторы яе можна схаваць і задаць аўтаматычную блакіроўку"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Абавязковыя праграмы ўжо ўсталяваны ў прыватнай прасторы"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Не ўдалося наладзіць прыватную прастору"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Паўтарыць спробу"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Выкарыстоўваць спосаб, выбраны для экрана?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Праграмы і апавяшчэнні"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Апавяшчэнні з канфідэнцыяльнай інфармацыяй на экране блакіроўкі"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Паказваць канфідэнцыяльнае змесціва, калі прыватная прастора разблакіравана"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Стварыце Уліковы запіс Google, каб абараніць свае даныя"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"На наступным экране вы зможаце ўвайсці ва ўліковы запіс, каб выкарыстоўваць яго ў прыватнай прасторы"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Стварыце асобны ўліковы запіс, каб даныя не пападалі за межы вашай прыватнай прасторы. Напрыклад:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Сінхранізаваныя фота, файлы, электронныя лісты, кантакты, падзеі ў календары і іншыя даныя"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Рэкамендацыі і гісторыя спампоўвання праграм"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Гісторыя прагляду сайтаў, закладкі і захаваныя паролі"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Змесціва, прапанаванае з улікам вашых дзеянняў у праграмах з прыватнай прасторы"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Вы можаце дадаць да <xliff:g id="COUNT">%d</xliff:g> адбіткаў пальца"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Вы дадалі максімальную колькасць адбіткаў пальцаў"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Немагчыма дадаць больш адбіткаў пальцаў"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Ваш аператар забараніў вам падключацца да гэтай сеткі, бо яна выкарыстоўвае ўстарэлы пратакол бяспекі з нізкім узроўнем абароны"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Дазволіць падключэнне да сетак WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Закрыць"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Адключыцца ад сеткі \"<xliff:g id="NAME">%1$s</xliff:g>\"?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Вы падключаны да сеткі WEP. Калі гэтыя сеткі заблакіраваць, падключэнне будзе страчана."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Дадатковыя параметры"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Выпадны спіс \"Дадатковыя параметры\""</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"разгарнуць"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Выкарыстоўваць <xliff:g id="NEW_APP">%s</xliff:g> для кіравання вашымі падлучэннямі да сеткі?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Апошнія запыты геаданых"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Месца для рабочага профілю"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Дазволы на доступ да геаданых"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Вызначэнне месцазнаходжання адключана"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{З {total} праграм # мае доступ да даных месцазнаходжання}one{З {total} праграм # мае доступ да даных месцазнаходжання}few{З {total} праграм # маюць доступ да даных месцазнаходжання}many{З {total} праграм # маюць доступ да даных месцазнаходжання}other{З {total} праграм # маюць доступ да даных месцазнаходжання}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Выкарыстоўваць экранную клавіятуру"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Захоўваць яе на экране ў той час, калі фізічная клавіятура актыўная"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Ігнараванне паўторнага націскання"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Паўторныя націсканні адной і той жа клавішы, ажыццёўленыя на працягу <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> мс, ігнаруюцца"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Запавольванне рэакцыі на націсканне"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Рэгістрацыя націскання клавішы ажыццяўляецца пасля заканчэння зададзенага часу: <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> мс"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Заліпанне клавіш"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Замест таго каб утрымліваць усе клавішы са спалучэння, націскайце іх па адной"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Гарачыя клавішы"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Паказаць спіс спалучэнняў клавіш"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Клавіятуры і інструменты працоўнага профілю"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Скінуць"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Выберыце клавішу-мадыфікатар"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Выберыце новы ключ для \"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>\":"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Стандартная"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Маўленне"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Хуткасць указальніка"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Прылада кiравання гульнёй"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Вы можаце наладзіць гэту прыладу так, каб яна адпавядала вашым патрэбам. Гэтыя спецыяльныя функцыі можна змяніць у Наладах."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Змяніць памер шрыфту"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Праграма чытання з экрана"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Параметры фізічнай клавіятуры"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Субцітры"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Аўдыя"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Агульныя налады"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Дысплэй"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Колер і рух"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Кантраснасць колераў"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Чым вышэйшы кантраст, тым больш прыметнымі з\'яўляюцца тэкст, кнопкі і значкі. Падбярыце такі кантраст, які найбольш падыходзіць вам."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Некаторыя праграмы могуць пакуль што не падтрымліваць усе налады кантрасту колераў і тэксту"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Зрабіце колеры і тэкст больш прыметнымі на фоне экрана"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Перадпрагляд"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Алена, Адам"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 дні таму"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Ёсць пытанні?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Справаздача аб камандзіроўцы"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Калі вы хочаце яшчэ нешта спытаць, \nзвярніцеся да мяне або Алены. Гэта справаздача будзе"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Выдаткі кліента"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Зацямніць экран"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Элементы кіравання ўзаемадзеяннем"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Элементы кіравання меткамі часу"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Усё роўна працягнуць"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Скасаваць"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Налады павелічэння"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Павялічваць спалучэннем клавіш"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Павялічваць спалучэннем клавіш і трайным дотыкам"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Інфармацыя пра службу \"<xliff:g id="SERVICE">%1$s</xliff:g>\""</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Непразрыстая"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Высокая кантраснасць тэксту"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Змяняйце колер тэксту на чорны ці белы, каб павысіць яго кантраст з фонам."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Максімальная кантраснасць тэксту"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Змяніце колер тэксту на чорны або белы, каб зрабіць яго больш прыметным."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Аўтаматычнае абнаўленне павелiчэння экрана"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Абнаўленне павелiчэння экрану падчас перахода з прыкладання"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Завяршыць выклік кнопкай сілкавання"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Утрымліваць клавішы гучнасці націснутымі"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Тройчы націснуць на экран"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Налады хуткага ўключэння спецыяльных магчымасцей"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Выберыце спосаб хуткага ўключэння наступнай функцыі: %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Далей"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Слыхавыя апараты"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Наладжвайце кахлеарныя імпланты, слыхавыя апараты ASHA і LE Audio і іншыя прылады для ўзмацнення гуку і кіруйце імі"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Няма падключаных слыхавых апаратаў"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Дадаць слыхавыя апараты"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Спалучыце слыхавы апарат"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Сумяшчальнасць са слыхавымі апаратамі"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Паляпшае сумяшчальнасць са слыхавымі апаратамі і зніжае нежаданы шум"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Пра слыхавыя апараты"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Каб знайсці іншыя слыхавыя апараты, якія не падтрымліваюць тэхналогію ASHA або LE Audio, націсніце "<b>"Спалучыць новую прыладу"</b>" &gt; "<b>"Іншыя прылады"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Спалучэнне слыхавога апарата"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"На гэтай старонцы можна спалучыць слыхавыя апараты ASHA і LE Audio. Упэўніцеся, што слыхавы апарат уключаны і гатовы да спалучэння."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Даступныя слыхавыя апараты"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Тэкставыя паведамленні"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Аўтапераключэнне SIM-карт"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Выкарыстоўвайце для перадачы даных любую з SIM-карт у залежнасці ад пакрыцця і даступнасці"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Толькі перадача даных"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Наладзіць"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Далей"</string>
@@ -4943,12 +4930,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Дапамагае вызначаць месцазнаходжанне прылад з UWB паблізу"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Каб выкарыстоўваць UWB, выключыце рэжым палёту"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Звышшырокапалосная сувязь недаступная ў гэтым месцы"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Для эфектыўнай работы разумнага дома выкарыстоўвайце падключэнне да сумяшчальных прылад па пратаколе Thread"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Каб выкарыстоўваць пратакол Thread, выключыце рэжым палёту"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Доступ да камеры"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Доступ да мікрафона"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Для праграм і сэрвісаў"</string>
@@ -5125,8 +5109,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Скасаваць"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Кантрастнасць"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Стандартная"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Стандартнае значэнне"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Сярэдняя"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Высокая"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Гэту праграму можна адкрыць толькі ў адным акне"</string>
diff --git a/res/values-bg/arrays.xml b/res/values-bg/arrays.xml
index 9ea9033..c13bc49 100644
--- a/res/values-bg/arrays.xml
+++ b/res/values-bg/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Третиране като мрежа с отчитане"</item>
     <item msgid="2047166446768045816">"Третиране като мрежа без отчитане"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Рандомиз. MAC адрес (станд.)"</item>
-    <item msgid="741680937828608749">"Използване на MAC адреса на устройството"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Не"</item>
     <item msgid="2163015208097377388">"Да"</item>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index cdabf13..326b5fc 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Дясно ухо: Сдвояване"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Ляво ухо: Сдвояване"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"За всички налични слухови апарати"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Още настройки за слухови апарати"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Променете настройките за различни устройства, като например контролите за преки пътища и телебобини"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"За това устройство"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аудиоизход"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Всичко за аудиоизхода"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Частното пространство се настройва…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Известията от приложенията в частното пространство са скрити, когато то е заключено"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Разгледайте настройките за частно пространство, за да скриете такова или да настроите автоматично заключване"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Задължителните приложения вече са инсталирани в частното ви пространство"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Не бе настроено частно пространство"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Нов опит"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Да се отключва ли частното простр. по същия начин?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Приложения и известия"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Поверителни известия на заключения екран"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Показване на деликатно съдържание, когато частното пространство е отключено"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Създайте си профил в Google, за да запазите поверителността на данните си"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"На следващия екран можете да влезете в профил, за да използвате частното си пространство"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Създайте си специален профил, така че данните да не се показват извън частното пространство, като например:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Синхронизирани снимки, файлове, имейли, контакти, събития от календара и други данни"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"История на изтеглянията и препоръки за приложения"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"История на сърфиране, отметки и запазени пароли"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Предложено съдържание, свързано с активността ви в приложенията в частното пространство"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Разбрах"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Можете да добавите до <xliff:g id="COUNT">%d</xliff:g> отпечатъка"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Добавихте максималния брой отпечатъци"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Не могат да се добавят още отпечатъци"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Операторът ви не разрешава да се свържете с тази мрежа, защото тя използва по-стар протокол за сигурност, който не е толкова надежден"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Разрешаване на WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Затваряне"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Да се прекрати ли връзката към <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Имате връзка с мрежа, защитена с WEP. Ако блокирате този тип мрежи, връзката ви ще бъде прекратена."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Разширени опции"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Падащ списък за разширени опции"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"разгъване"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Да се използва ли <xliff:g id="NEW_APP">%s</xliff:g> за управление на мрежовите ви връзки?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Скорошни заявки за местопол."</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Местоп. за служ. потр. профил"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Разрешения на приложенията за достъп до местоп."</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Функцията за местоположението е изключена"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# от {total} приложения има достъп до местоположението}other{# от {total} приложения имат достъп до местоположението}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Използване на екранната клавиатура"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Показва се на екрана, докато физическата клавиатура е активна"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Игнориране на многократ. натискане"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Клавиатурата пренебрегва бързите натискания на един и същ клавиш, повтарящи се в рамките на <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> мсек"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Забавяне на сигнала от клавишите"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Коригира времето, необходимо за активиране след натискане на даден клавиш, на <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> мсек"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Фиксирани клавиши"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Натискайте клавишите от съответните комбинации един по един, вместо да ги задържате заедно"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Клавишни комбинации"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Показване на списък с клавишните комбинации"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Клавиатури и инструменти за служебния потр. профил"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Нулиране"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Избиране на модифициращ клавиш"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Изберете нов ключ за <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Подредба: <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"По подразбиране"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Автоматично: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Избрано от потребителя: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Говор"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Скорост на курсора"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Контролер за игри"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Можете да персонализирате устройството така, че да отговаря на нуждите ви. Тези функции за достъпност могат да бъдат променени по-късно от „Настройки“."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Промяна на размера на шрифта"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Екранен четец"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Опции за физическата клавиатура"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Надписи"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Аудио"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Общи"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Дисплей"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Цвят и движение"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Контраст на цветовете"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"При по-висок контраст текстът, бутоните и иконите се открояват повече. Изберете най-подходящия според вас контраст."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Възможно е някои приложения да не поддържат всички настройки за контраст на текста и цветовете"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Коригирайте как цветовете и текстът да изпъкват спрямо цвета на фона на екрана ви"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Визуализация"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Хелън, Адам"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Преди 2 дни"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Посл. действ.?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Отчет за командировка"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"За допълнителна помощ, моля, свържете се с \nмен или Хелън. Този отчет ще бъде"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Разходи на клиента"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Затъмняване на екрана"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Контроли за взаимодействие"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Контроли за времевия интервал при докосване"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Напред въпреки това"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Отказ"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Настройки за увеличението"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Увеличаване на мащаба с пряк път"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Увелич. на мащаба с пряк път и трикратно докосване"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Всичко за „<xliff:g id="SERVICE">%1$s</xliff:g>“"</string>
@@ -2120,7 +2103,7 @@
     <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"За да използвате функцията за достъпност, прекарайте три пръста нагоре от долната част на екрана.\n\nЗа превключване между функциите прекарайте три пръста нагоре и задръжте."</string>
     <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Разбрах"</string>
     <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Настройки за бутона"</string>
-    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Пряк път за <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
+    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Пряк път за: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
     <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Бутон за достъпност"</string>
     <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Жест за достъпност"</string>
     <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Бързо плъзгане нагоре с 2 пръста"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Непрозрачен"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Текст с висок контраст"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Променете цвета на текста на черен или бял. Така контрастът с фона се увеличава максимално."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Увеличаване на контраста на текста"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Променете цвета на текста на черен или бял, за да увеличите контраста спрямо фона."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Авт. актуал. на увеличението на екрана"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Актуал. на увеличението на екрана при преходи на прилож."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Край на обажд. с бутона за вкл./изкл."</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Задържане на бутоните за силата на звука"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Трикратно докосване на екрана"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Редактиране на преките пътища за достъпност"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Изберете клавишна комбинация за „%1$s“"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Напред"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Слухови апарати"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Настройване и управление на слухови апарати, кохлеарни импланти и други устройства за усилване на звука с протоколите ASHA и LE Audio"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Няма свързани слухови апарати"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Добавяне на слухови апарати"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Сдвояване на слухов апарат"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Съвместимост със слухови апарати"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Подобрява съвместимостта със слуховите апарати с телебобина и намалява нежелания шум"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Всичко за слуховите апарати"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"За да намерите други слухови апарати, които не се поддържат от протокола ASHA или LE Audio, докоснете "<b>"Сдвояване на ново устройство"</b>" &gt; "<b>"Вижте още устройства"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Слухов апарат: Сдвояване"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"На тази страница можете да сдвоите слухови апарати с ASHA и LE Audio. Уверете се, че слуховият ви апарат е включен и готов за сдвояване."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Налични слухови апарати"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Текстови съобщения"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Авт. превключване на данните"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Използване на данни от която и да е от двете SIM карти в зависимост от покритието и наличността"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Само за данни"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Настройване"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Напред"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Помага за определянето на относителната позиция на устройства в близост, които използват ултрашироколентови сигнали"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Изключете самолетния режим, за да използвате UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB не е налице в текущото местоположение"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"За безпроблемна практическа работа с интелигентния дом свързвайте съвместимите устройства посредством Thread"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Изключете самолетния режим, за да използвате Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Достъп до камерата"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Достъп до микрофона"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"За приложения и услуги"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Отказ"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Контраст"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Стандартен"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"По подразбиране"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Среден"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Висок"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Това приложение може да се отвори само в 1 прозорец"</string>
diff --git a/res/values-bn/arrays.xml b/res/values-bn/arrays.xml
index 5e50ea8..82e3651 100644
--- a/res/values-bn/arrays.xml
+++ b/res/values-bn/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"সীমিত ইন্টারনেট ডেটা"</item>
     <item msgid="2047166446768045816">"অসীমিত ইন্টারনেট ডেটা"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"র‍্যান্ডমাইজ করা MAC ব্যবহার করুন (ডিফল্ট)"</item>
-    <item msgid="741680937828608749">"ডিভাইসের MAC ব্যবহার করুন"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"না"</item>
     <item msgid="2163015208097377388">"হ্যাঁ"</item>
diff --git a/res/values-bn/strings.xml b/res/values-bn/strings.xml
index 59bfa28..8c253d6 100644
--- a/res/values-bn/strings.xml
+++ b/res/values-bn/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"ডানদিকেরটি পেয়ার করুন"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"বাঁদিকেরটি পেয়ার করুন"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"উপলভ্য সব হিয়ারিং ডিভাইসের জন্য"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"হিয়ারিং ডিভাইস সংক্রান্ত আরও বেশি সেটিংস"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"শর্টকাট ও টেলিকয়েল কন্ট্রোলের মতো ক্রস-ডিভাইস সেটিংস পরিবর্তন করুন"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"এই ডিভাইসের জন্য"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"অডিও আউটপুট"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"অডিও আউটপুট সম্পর্কে"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"প্রাইভেট স্পেস সেট-আপ করা হচ্ছে…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"এটি লক করা থাকলে প্রাইভেট স্পেস অ্যাপ থেকে বিজ্ঞপ্তি লুকানো থাকে"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"প্রাইভেট স্পেস লুকাতে ও অটোমেটিক লক সেট-আপ করতে প্রাইভেট স্পেসের সেটিংস ঘুরে দেখুন"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"প্রয়োজনীয় অ্যাপ আগেই আপনার প্রাইভেট স্পেসে ইনস্টল করা আছে"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"কোনও প্রাইভেট স্পেস সেট-আপ করা যায়নি"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"আবার চেষ্টা করুন"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"প্রাইভেট স্পেস আনলক করতে স্ক্রিন লক ব্যবহার করবেন?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"অ্যাপ ও বিজ্ঞপ্তি"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"লক স্ক্রিনে সংবেদনশীল বিজ্ঞপ্তি"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"প্রাইভেট স্পেস আনলক করা থাকলে সংবেদনশীল কন্টেন্ট দেখুন"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"আপনার ডেটা ব্যক্তিগত রাখতে Google অ্যাকাউন্ট তৈরি করুন"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"পরবর্তী স্ক্রিনে আপনার প্রাইভেট স্পেসের সাথে ব্যবহার করতে কোনও অ্যাকাউন্টে সাইন-ইন করতে পারবেন"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"প্রাইভেট স্পেসের বাইরে ডেটা দেখতে পাওয়া বন্ধ করতে একটি ডেডিকেটেড অ্যাকাউন্ট তৈরি করুন, যেমন:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"সিঙ্ক করা ফটো, ফাইল, ইমেল, পরিচিতি, ক্যালেন্ডারের ইভেন্ট ও অন্যান্য ডেটা"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"অ্যাপ ডাউনলোড করার ইতিহাস ও সাজেশন"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ব্রাউজিং ইতিহাস, বুকমার্ক ও সেভ করা বুকমার্ক"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"প্রাইভেট স্পেস অ্যাপে আপনার অ্যাক্টিভিটি সম্পর্কিত সাজেস্ট করা কন্টেন্ট"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"বুঝেছি"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"আপনি সর্বাধিক <xliff:g id="COUNT">%d</xliff:g>টি ফিঙ্গারপ্রিন্ট যোগ করতে পারবেন"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"আপনি অনুমোদিত সর্বোচ্চ সংখ্যক আঙ্গুলের ছাপ যোগ করেছেন"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"এর বেশি আঙ্গুলের ছাপ যোগ করা যাবে না"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"আপনার পরিষেবা প্রদানকারী এই নেটওয়ার্কের সাথে কানেক্ট করার অনুমতি আপনাকে দেয় না, কারণ এটি এমন এক পুরনো সুরক্ষা প্রোটোকল ব্যবহার করে যেটি কম সুরক্ষিত"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP-কে অনুমতি দিন"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"বন্ধ করুন"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> নেটওয়ার্ক থেকে ডিসকানেক্ট করবেন?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"আপনি WEP নেটওয়ার্কে কানেক্ট করে আছেন। এইসব নেটওয়ার্ক ব্লক করলে, আপনি ডিসকানেক্ট হয়ে যাবেন।"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"উন্নত বিকল্প"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ড্রপ-ডাউন তালিকায় থাকা উন্নত বিকল্প"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"বড় করুন"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"আপনার নেটওয়ার্ক কানেকশন পরিচালনা করার জন্য <xliff:g id="NEW_APP">%s</xliff:g> ব্যবহার করবেন?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"সাম্প্রতিক লোকেশন অনুরোধগুলি"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"অফিস প্রোফাইলের জন্য লোকেশন"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"অ্যাপের ক্ষেত্রে লোকেশনের অনুমতি"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"লোকেশন বন্ধ করা আছে"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total}টি অ্যাপের মধ্যে #টি লোকেশন অ্যাক্সেস করতে পারবে}one{{total}টি অ্যাপের মধ্যে #টি লোকেশন অ্যাক্সেস করতে পারবে}other{{total}টি অ্যাপের মধ্যে #টি লোকেশন অ্যাক্সেস করতে পারবে}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"অন-স্ক্রিন কীবোর্ড ব্যবহার করুন"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"ফিজিক্যাল কীবোর্ড সক্রিয় থাকার সময় এটিকে স্ক্রীনে রাখুন"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"বাউন্স \'কী\'"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> মিলি সেকেন্ডের মধ্যে একই কী বারবার প্রেস করলে তা কীবোর্ড উপেক্ষা করে"</string>
     <string name="slow_keys" msgid="2891452895499690837">"স্লো কী"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"কোনও কী প্রেস করলে সেটি অ্যাক্টিভেট হতে যে সময় লাগে তা <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> মিলি সেকেন্ডে অ্যাডজাস্ট হয়"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"স্টিকি \'কী\'"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"শর্টকাটের জন্য কীগুলি একসাথে ধরে রাখার পরিবর্তে একবারে একটি কী প্রেস করুন"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"কীবোর্ড শর্টকাট"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"শর্টকাটের তালিকা দেখান"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"অফিসের প্রোফাইলের কীবোর্ড ও টুল"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"রিসেট করুন"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"\'মডিফায়ার কী\' বেছে নেওয়া"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>-এর জন্য নতুন \'কী\' বেছে নিন:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ডিফল্ট"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"স্পিচ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"পয়েন্টারের গতি"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"গেম নিয়ন্ত্রক"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"আপনি ডিভাইসটি নিজের পছন্দমতো সেট করতে পারেন৷ এই অ্যাক্সেসিবিলিটি ফিচারগুলি পরে সেটিংসে গিয়ে পরিবর্তন করা যাবে৷"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"হরফের মাপ পরিবর্তন করুন"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"স্ক্রিন রিডার"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ফিজিক্যাল কীবোর্ড সংক্রান্ত বিকল্প"</string>
     <string name="captions_category_title" msgid="574490148949400274">"ক্যাপশন"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"অডিও"</string>
     <string name="general_category_title" msgid="6298579528716834157">"সাধারণ"</string>
     <string name="display_category_title" msgid="6638191682294461408">"ডিসপ্লে"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"রঙ এবং মোশন"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"কালার কনট্রাস্ট"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"চড়া কনট্রাস্ট টেক্সট, বোতাম ও আইকনকে আরও বেশি আলাদা করে তোলে। আপনার কাছে যে কনট্রাস্ট সেরা মনে হবে সেটি বেছে নিন।"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"কিছু অ্যাপ সব রঙ ও টেক্সট কন্ট্রাস্ট সেটিংসে কাজ নাও করতে পারে"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"আপনার স্ক্রিনের ব্যাকগ্রাউন্ডের রঙ হিসেবে রঙ ও টেক্সট কেমন দেখাবে তা অ্যাডজাস্ট করুন"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"প্রিভিউ করুন"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"হেলেন, অ্যাডাম"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"২ দিন আগে"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ফলো-আপ করবেন?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"ব্যবসা ট্রিপ সম্পর্কিত রিপোর্ট"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"আরও বেশি সহায়তার জন্য, আমার\nবা হেলেনের সাথে যোগাযোগ করুন। এই রিপোর্ট হবে"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"ক্লায়েন্ট সম্পর্কিত খরচ"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"স্ক্রিনের উজ্জ্বলতা কমান"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ইন্টারঅ্যাকশন নিয়ন্ত্রণগুলি"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"সময় সংক্রান্ত কন্ট্রোল"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"তা সত্ত্বেও চালিয়ে যান"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"বাতিল করুন"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"বড় করে দেখার সেটিংস"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"শর্টকাটের সাহায্যে বড় করে দেখা"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"শর্টকাটের মাধ্যমে ও তিনবার ট্যাপ করে বড় করুন"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"\'<xliff:g id="SERVICE">%1$s</xliff:g>\' সম্পর্কে"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"নন-ট্রান্সপারেন্ট"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"উচ্চ কনট্রাস্ট যুক্ত পাঠ্য"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"কালো অথবা সাদাতে টেক্সটের রঙ পরিবর্তন করুন। এটির জন্য ব্যাকগ্রাউন্ডের হিসেবে কনট্রাস্ট বেড়ে যায়।"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"টেক্সটের কনট্রাস্ট বাড়িয়ে নিন"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"ব্যাকগ্রাউন্ডের মাধ্যমে কনট্রাস্ট বাড়াতে টেক্সটের রঙ কালো বা সাদাতে পরিবর্তন করুন।"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"স্ক্রিন বৃহত্তরীকরণ স্বতঃ আপডেট"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"অ্যাপ্লিকেশান ট্রানজিশনের উপর স্ক্রিন বৃহত্তরীকরণ আপডেট"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"পাওয়ার বোতামে কল শেষ হয়"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"ভলিউম কী ধরে থাকুন"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"ট্রিপল ট্যাপ স্ক্রিন"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"অ্যাক্সেসিবিলিটি শর্টকাট এডিট করুন"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s-এর জন্য আপনার শর্টকাট বেছে নিন"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"এগিয়ে যান"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"হিয়ারিং ডিভাইস"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA এবং LE অডিও হিয়ারিং এড, কক্লিয়ার ইমপ্ল্যান্ট এবং আওয়াজ বাড়ানোর অন্যান্য ডিভাইস সেট-আপ ও ম্যানেজ করুন"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"কোনও হিয়ারিং ডিভাইস কানেক্ট করা নেই"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"হিয়ারিং এড যোগ করুন"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"হিয়ারিং এড পেয়ার করুন"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"হিয়ারিং এইড কম্প্যাটিবিলিটি"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"টেলিকয়েলের সাহায্যে কম্প্যাটিবিলিটি উন্নত করে এবং অপ্রয়োজনীয় শব্দ কমিয়ে দেয়"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"হিয়ারিং ডিভাইস সম্পর্কে"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA বা LE অডিও কাজ করে না এমন অন্যান্য হিয়ারিং ডিভাইস খুঁজে পেতে, "<b>"নতুন ডিভাইস পেয়ার করুন"</b>" &gt; "<b>"আরও ডিভাইস দেখুন"</b>" বিকল্পে ট্যাপ করুন"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"হিয়ারিং ডিভাইস পেয়ার করা"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"আপনি এই পৃষ্ঠায় ASHA এবং LE Audio হিয়ারিং ডিভাইসের সাথে পেয়ার করতে পারেন। আপনার হিয়ারিং ডিভাইস চালু আছে কিনা এবং পেয়ার করার জন্য রেডি কিনা তা ভালোভাবে দেখে নিন।"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"উপলভ্য হিয়ারিং ডিভাইস"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"টেক্সট"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"অটোমেটিক ডেটা পরিবর্তন করা"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"কভারেজ ও উপলভ্যতার উপর নির্ভর করে কোনও একটি সিমের ডেটা ব্যবহার করুন"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"শুধু ডেটা"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"সেট-আপ করুন"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"পরবর্তী"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"কাছাকাছি UWB ডিভাইসের আপেক্ষিক অবস্থান শনাক্ত করতে সহায়তা করে"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"ইউডব্লুউবি ব্যবহার করতে \'বিমান মোড\' বন্ধ করুন"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"বর্তমান লোকেশনে UWB উপলভ্য নেই"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"থ্রেড"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"নির্বিঘ্নে স্মার্ট হোম অভিজ্ঞতা পেতে থ্রেড ব্যবহার করে মানানসই ডিভাইসের সাথে কানেক্ট করুন"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"থ্রেড ব্যবহার করতে \'বিমান মোড\' বন্ধ করুন"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"ক্যামেরার অ্যাক্সেস"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"মাইক্রোফোনের অ্যাক্সেস"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"অ্যাপ ও পরিষেবার জন্য"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"বাতিল করুন"</string>
     <string name="contrast_title" msgid="6885768151336508075">"কনট্রাস্ট"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"স্ট্যান্ডার্ড"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ডিফল্ট"</string>
     <string name="contrast_medium" msgid="384414510709285811">"মিডিয়াম"</string>
     <string name="contrast_high" msgid="3988567609694797696">"হাই"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"এই অ্যাপটি শুধুমাত্র ১টি উইন্ডোতে খোলা যেতে পারে"</string>
diff --git a/res/values-bs/arrays.xml b/res/values-bs/arrays.xml
index a774197..d2ebf45 100644
--- a/res/values-bs/arrays.xml
+++ b/res/values-bs/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tretiraj kao vezu s naplatom"</item>
     <item msgid="2047166446768045816">"Tretiraj kao vezu bez naplate"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Koristi nasumičnu MAC adresu (zadano)"</item>
-    <item msgid="741680937828608749">"Koristi MAC adresu uređaja"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ne"</item>
     <item msgid="2163015208097377388">"Da"</item>
diff --git a/res/values-bs/strings.xml b/res/values-bs/strings.xml
index 8f3586f..79a28cc 100644
--- a/res/values-bs/strings.xml
+++ b/res/values-bs/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Upari desno uho"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Upari lijevo uho"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Za sve dostupne slušne aparate"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Više postavki slušnog aparata"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Promijenite postavke na više uređaja kao što su prečica i kontrole telezavojnica"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Za ovaj uređaj"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Izlaz zvuka"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Informacije o izlazu zvuka"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Postavljanje privatnog prostora…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Obavještenja iz aplikacija u privatnom prostoru su sakrivena kada je prostor zaključan"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Istražite postavke privatnog prostora da sakrijete privatni prostor i postavite automatsko zaključavanje"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Potrebne aplikacije su već instalirane u privatnom prostoru"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Postavljanje privatnog prostora nije uspjelo"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Pokušaj ponovo"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Koristiti zaklj. ekrana za otklj. priv. prostora?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikacije i obavještenja"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Osjetljiva obavještenja na zaključanom ekranu"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Prikaz osjetljivog sadržaja kada je privatni prostor otključan"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Kreirajte Google račun da zaštitite privatnost podataka"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na sljedećem ekranu se možete prijaviti na račun da ga koristite s privatnim prostorom"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Kreirajte namjenski račun da spriječite pojavljivanje podataka izvan privatnog prostora, npr.:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinhronizirajte slike, fajlove, e-poruke, kontakte, događaje u kalendaru i druge podatke"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historija preuzimanja aplikacija i preporuke"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historija pregledanja, oznake i sačuvane lozinke"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Predloženi sadržaj povezan s aktivnošću u aplikacijama u privatnom prostoru"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Razumijem"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Broj otisaka prstiju koje možete dodati: <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodali ste maksimalan broj otisaka prstiju"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nije moguće dodati još otisaka prstiju"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operater vam ne dozvoljava da se povežete s ovom mrežom jer koristi stariji sigurnosni protokol koji je manje siguran"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Dozvoli WEP protokol"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Zatvori"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Prekinuti vezu s mrežom <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Povezani ste s WEP mrežom. Ako blokirate ove mreže, veza će se prekinuti."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Napredne opcije"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Padajuća lista Naprednih opcija"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"proširivanje"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Koristiti <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje vašim mrežnim vezama?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavni zahtjevi za lokaciju"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za radni profil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Odobrenja lokacije za aplikacije"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokacija je isključena"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# od {total} aplik. ima pristup lokaciji}one{# od {total} aplik. imaju pristup lokaciji}few{# od {total} aplik. imaju pristup lokaciji}other{# od {total} aplik. imaju pristup lokaciji}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Koristi tastaturu na ekranu"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Zadržava se na ekranu dok je fizička tastatura aktivna"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Zanemari slučajne pritiske tipki"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tastatura zanemaruje brzo ponavljana pritiskanja iste tipke u rasponu od <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Sporo reagiranje tipki"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Prilagođava vrijeme potrebno za aktiviranje pritiskanja tipke na <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Ljepljive tipke"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Za prečice pritišćite jednu po jednu tipku umjesto da ih istovremeno zadržavate"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Prečice tastature"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Prikaz liste prečica"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatura i alati radnog profila"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Poništi"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Odaberite modifikacijsku tipku"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Odaberite novu tipku za \"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>\":"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Izgled: <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Zadano"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatski: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Izgled koji je odabrao korisnik: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Govor"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Brzina pokazivača"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Kontroler za igre"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Ovaj uređaj možete prilagoditi svojim potrebama. Funkcije pristupačnosti se mogu kasnije promijeniti u Postavkama."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Promijenite veličinu fonta"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Čitač ekrana"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opcije fizičke tastature"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Titlovi"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Zvuk"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Opće"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Prikaz"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Boja i pokret"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kontrast boja"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Viši kontrast omogućava veću istaknutost teksta, dugmadi i ikona. Odaberite kontrast koji vam izgleda najbolje."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Određene aplikacije možda neće podržavati sve postavke kontrasta boja i teksta"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Podesite način na koji boje i tekst izgledaju u odnosu na boju pozadine ekrana"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Pregledajte"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Prije 2 dana"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Dodatni upit?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Izvještaj o poslovnom putovanju"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Za dodatnu pomoć kontaktirajte \nmene ili Helenu. Izvještaj će biti"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Troškovi klijenta"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Zatamnjivanje ekrana"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrole za interakciju"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrole za vrijeme"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Ipak nastavi"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Otkaži"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Postavke uvećavanja"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Uvećavanje pomoću prečice"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Uvećajte pomoću prečice i trostrukog dodira"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"O usluzi <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Nije providno"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst visokog kontrasta"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Promjena boje teksta u crnu ili bijelu. Maksimalno se povećava kontrast s pozadinom."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimiziraj kontrast teksta"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Promijenite boju teksta u crnu ili bijelu da povećate kontrast s pozadinom."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automatsko ažurir. uvećav. ekrana"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ažurira uvećavanje ekrana kod prelaza aplikacija"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Dugme uklj./isklj. prekida poziv"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Držite tipke za jačinu zvuka"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trostruki dodir ekrana"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Uredite prečice za pristupačnost"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Odaberite prečicu za %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Nastavi"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Slušni aparati"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Postavite ASHA i LE Audio slušne aparate, kohlearne implantate i druge uređaje za pojačavanje zvuka te upravljajte njima"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nije povezan nijedan slušni aparat"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Dodaj slušne aparate"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Uparite slušne aparate"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilnost sa slušnim aparatom"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Poboljšava kompatibilnost s telezavojnicama i smanjuje neželjeni šum"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Informacije o slušnim aparatima"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Da pronađete druge slušne aparate koje ne podržava ASHA ni LE Audio, dodirnite opciju "<b>"Uparivanje novog uređaja"</b>" &gt; "<b>"Pogledajte više uređaja"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Uparite slušni aparat"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Na ovoj stranici možete upariti slušne aparate s prijenosom zvuka za slušne aparate i LE Audijem. Provjerite je li slušni aparat uključen i spreman za uparivanje."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostupni slušni aparati"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Poruke"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Autom. prebac. na prij. podataka"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Koristite prijenos podataka s bilo kojeg SIM-a ovisno o pokrivenosti i dostupnosti"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Samo prijenos podataka"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Postavi"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Naprijed"</string>
@@ -4942,12 +4926,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomoć pri određivanju relativnog položaja uređaja u blizini koji imaju ultra široki opseg"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Isključite način rada u avionu da koristite UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Ultra široki opseg nije dostupan na trenutnoj lokaciji"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Nit"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Povežite se s kompatibilnim uređajima putem Niti da dobijete besprijekorno iskustvo pametnog doma"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Isključite način rada u avionu da koristite Nit"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Pristup kameri"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Pristup mikrofonu"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Za aplikacije i usluge"</string>
@@ -5124,8 +5105,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Otkaži"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standardno"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Zadano"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Srednje"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Visoko"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ova aplikacija se može otvoriti samo u 1 prozoru"</string>
diff --git a/res/values-ca/arrays.xml b/res/values-ca/arrays.xml
index 15671a2..0f4e2ac 100644
--- a/res/values-ca/arrays.xml
+++ b/res/values-ca/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tracta com a xarxa d\'ús mesurat"</item>
     <item msgid="2047166446768045816">"Tracta com a xarxa d\'ús no mesurat"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Utilitza adreça MAC aleatòria (predeterminat)"</item>
-    <item msgid="741680937828608749">"Utilitza adreça MAC del dispositiu"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"No"</item>
     <item msgid="2163015208097377388">"Sí"</item>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index de7883d..73fd3dc 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Vincula la dreta"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Vincula l\'esquerra"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Per a tots els audiòfons disponibles"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Més opcions de configuració de l\'audiòfon"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Canvia la configuració multidispositiu, com ara els controls de drecera i telebobina"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Per a aquest dispositiu"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Sortida d\'àudio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Sobre la sortida d\'àudio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"S\'està configurant l\'espai privat…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Quan està bloquejat, les notificacions de les aplicacions de l\'espai privat s\'amaguen"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Explora la configuració de l\'espai privat per amagar-lo i configurar el bloqueig automàtic"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Les aplicacions requerides ja estan instal·lades a l\'espai privat"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"No s\'ha pogut configurar un espai privat"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Torna-ho a provar"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Vols utilitzar el bloqueig de pantalla per desbloquejar l\'espai privat?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplicacions i notificacions"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notificacions sensibles a la pantalla de bloqueig"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Mostra contingut sensible quan l\'espai privat està desbloquejat"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Crea un Compte de Google per ajudar a mantenir la privacitat de les teves dades"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"A la pantalla següent pots iniciar la sessió a un compte per utilitzar-lo a l\'espai privat"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Crea un compte dedicat per fer que les dades deixin d\'aparèixer fora de l\'espai privat, com ara:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Fotos, fitxers, correus, contactes, esdeveniments del calendari i altres dades sincronitzats"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historial de baixades d\'aplicacions i recomanacions"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historial de naveg., adreces d\'interès i contrasenyes desades"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Contingut suggerit relacionat amb la teva activitat en aplicacions de l\'espai privat"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Entesos"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Pots afegir un màxim de <xliff:g id="COUNT">%d</xliff:g> empremtes digitals"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Has afegit el nombre màxim d\'empremtes digitals"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"No es poden afegir més empremtes digitals"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"El teu operador no et permet connectar-te a aquesta xarxa perquè utilitza un protocol de seguretat més antic que és menys segur"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permet les xarxes WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Tanca"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Vols desconnectar-te de <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"T\'has connectat a una xarxa WEP. Si bloqueges aquestes xarxes, perdràs la connexió."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opcions avançades"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Llista desplegable Opcions avançades"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"desplega"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Vols fer servir <xliff:g id="NEW_APP">%s</xliff:g> per gestionar les connexions de la xarxa?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Sol·licituds d\'ubicació recents"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ubicació per al perfil de treball"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Permisos d\'ubicació d\'aplicacions"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"La ubicació està desactivada"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# de {total} aplicacions té accés a la ubicació}other{# de {total} aplicacions tenen accés a la ubicació}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Utilitza el teclat en pantalla"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Mantén-lo en pantalla mentre el teclat físic està actiu"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Tecles de rebot"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"El teclat ignora les pulsacions repetides ràpidament de la mateixa tecla en un interval de <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Tecles lentes"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajusta el temps que tarda la pulsació d\'una tecla en activar-se a <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Tecles permanents"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Prem una tecla cada vegada per a les dreceres en lloc de mantenir premudes les tecles alhora"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tecles de drecera"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostra la llista de dreceres"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclats i eines del perfil de treball"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Restableix"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Tria la tecla modificadora"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Tria una tecla nova per a <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Predeterminat"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Parla"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Velocitat del punter"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Controlador de joc"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Pots personalitzar el dispositiu per adaptar-lo a les teves necessitats. Aquestes funcions d\'accessibilitat es poden canviar més endavant des de Configuració."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Canvia el cos de font"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Lector de pantalla"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opcions del teclat físic"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtítols"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Àudio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"General"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Visualització"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Color i moviment"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contrast de color"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Un contrast més alt fa que el text, els botons i les icones destaquin més. Tria el contrast que més t\'agradi."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Pot ser que algunes aplicacions encara no admetin totes les opcions de configuració de contrast de color i text"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ajusta com es veuen els colors i el text sobre el color del fons de pantalla"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Previsualitza"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Fa 2 dies"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Vols seguir?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Informe de viatge de negocis"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Per obtenir més assistència, contacta amb \nmi o la Helen. L\'informe serà"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Despeses del client"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Enfosqueix la pantalla"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Controls d\'interacció"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Controls de temps"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continua igualment"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancel·la"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Configuració de l\'ampliació"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Amplia amb una drecera"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Amplia amb una drecera i tres tocs"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"No transparent"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text d\'alt contrast"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Canvia el color del text a blanc o negre. Maximitza el contrast amb el fons."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximitza el contrast del text"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Canvia el color del text a negre o blanc per augmentar el contrast amb el fons."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Actualitza ampliació automàticament"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Actualitza augment pantalla a transicions aplic."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"El botó d\'engegada penja"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mantén premudes les tecles de volum"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tres tocs a la pantalla"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edita les dreceres d\'accessibilitat"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Tria la drecera per a %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continua"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Audiòfons"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configura i gestiona els audiòfons compatibles amb ASHA o LE Audio, els implants coclears i altres dispositius d\'amplificació"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"No hi ha cap audiòfon connectat"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Afegeix uns audiòfons"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Vinculació d\'audiòfons"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilitat amb audiòfons"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Millora la compatibilitat amb telebobines i redueix els sorolls no desitjats"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Sobre els audiòfons"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Per cercar altres audiòfons que no siguin compatibles amb ASHA o LE Audio, toca "<b>"Vincula un dispositiu nou"</b>" &gt; "<b>"Mostra més dispositius"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Vincula l\'audiòfon"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Pots vincular els audiòfons ASHA i LE Audio en aquesta pàgina. Comprova que l\'audiòfon estigui encès i a punt per vincular-se."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Audiòfons disponibles"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Missatges de text"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Canvi de dades automàtic"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Utilitza dades de qualsevol de les SIM en funció de la cobertura i la disponibilitat"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Només dades"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configura"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Següent"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Ajuda a identificar la posició relativa dels dispositius propers que tenen banda ultraampla"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desactiva el mode d\'avió per utilitzar la banda ultraampla"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"La banda ultraampla no està disponible a la ubicació actual"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Connecta\'t a dispositius compatibles mitjançant Thread per gaudir d\'una experiència domèstica intel·ligent fluida"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desactiva el mode d\'avió per utilitzar Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Accés a la càmera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Accés al micròfon"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Per a aplicacions i serveis"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Cancel·la"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Estàndard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Predeterminat"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Mitjà"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Alt"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Aquesta aplicació només pot obrir-se en 1 finestra"</string>
diff --git a/res/values-cs/arrays.xml b/res/values-cs/arrays.xml
index 1625064..b17387d 100644
--- a/res/values-cs/arrays.xml
+++ b/res/values-cs/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Považovat za měřenou síť"</item>
     <item msgid="2047166446768045816">"Považovat za neměřenou síť"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Používat náhodnou adresu MAC (výchozí nastavení)"</item>
-    <item msgid="741680937828608749">"Používat adresu MAC zařízení"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ne"</item>
     <item msgid="2163015208097377388">"Ano"</item>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index c78b7e3..6ca420b 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Spárovat pravé ucho"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Spárovat levé ucho"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Pro všechna dostupná naslouchátka"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Další nastavení naslouchátek"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Změnit nastavení pro více zařízení, jako jsou ovládací prvky zkratek nebo naslouchátek"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Pro toto zařízení"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Zvukový výstup"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Informace o zvukovém výstupu"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Nastavování soukromého prostoru…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Když je soukromý prostor uzamčen, jsou oznámení aplikací v soukromém prostoru skryta"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Pokud chcete skrýt soukromý prostor a nastavit automatické uzamknutí, přejděte do nastavení soukromého prostoru"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Povinné aplikace už jsou v soukromém prostoru nainstalované"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Soukromý prostor se nepodařilo nastavit"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Zkusit znovu"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Používat zámek obrazovky k odemknutí s. prostoru?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikace a oznámení"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Citlivá oznámení na obrazovce uzamčení"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Zobrazovat citlivý obsah, když je soukromý prostor odemčen"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Vytvořte si účet Google za účelem zabezpečení dat"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na další obrazovce se můžete přihlásit k účtu, který chcete používat se soukromým prostorem"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Vytvořte si speciální účet, aby se mimo soukromý prostor nezobrazovala vaše data, jako například:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Synchronizované fotky, soubory, e-maily, kontakty, události v kalendáři a další data"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historie a doporučení stahování aplikací"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Procházení historie, záložek a uložených hesel"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Navrhovaný obsah související s vaší aktivitou v aplikacích v soukromém prostoru"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Rozumím"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Maximální počet otisků prstů, které lze přidat: <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Přidali jste maximální počet otisků prstů"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Další otisky prstů nelze přidat"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Váš operátor připojení k této síti nepovoluje, protože používá starší bezpečnostní protokol, který je méně bezpečný"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Povolit WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Zavřít"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Odpojit od sítě <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Jste připojeni k síti WEP. Pokud tyto sítě zablokujete, budete odpojeni."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Rozšířené možnosti"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rozbalovací seznam Pokročilé možnosti"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"rozbalit"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Chcete spravovat síťová připojení pomocí aplikace <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedávné žádosti o určení polohy"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Umístění pracovního profilu"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Oprávnění aplikací pro přístup k poloze"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Určování polohy je vypnuto"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Přístup k poloze má # z {total} aplikací}few{Přístup k poloze mají # z {total} aplikací}many{Přístup k poloze má # z {total} aplikací}other{Přístup k poloze má # z {total} aplikací}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Použít softwarovou klávesnici"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Ponechat na obrazovce, když je aktivní fyzická klávesnice"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Ignorovat opakovaná stisknutí"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Klávesnice ignoruje opakovaná stisknutí jedné klávesy do <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Zpomalení kláves"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Upraví čas aktivace po stisknutí klávesy na <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Jedním prstem"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Místo držení více tlačítek aktivujte zkratky postupným tisknutím jednotlivých kláves"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klávesové zkratky"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Zobrazit seznam zkratek"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Klávesnice a nástroje v pracovním profilu"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Resetovat"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Vyberte modifikační klávesu"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Vyberte novou klávesu pro <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Rozvržení <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Výchozí"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatické: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Vybrané uživatelem: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Řeč"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Rychlost kurzoru"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Herní ovladače"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Toto zařízení můžete přizpůsobit svým potřebám. Funkce přístupnosti lze později změnit v Nastavení."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Změňte velikost písma"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Čtečka obrazovky"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Možnosti fyzické klávesnice"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Titulky"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Zvuk"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Obecné"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Zobrazení"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Barvy a pohyb"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Barevný kontrast"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Text, tlačítka a ikony při vyšším kontrastu více vyniknou. Vyberte kontrast, který vám nejvíc vyhovuje."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Některé aplikace nemusí podporovat všechna nastavení kontrastu barev a textu"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Upravit vzhled barev a textu vůči barvě pozadí obrazovky"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Náhled"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"před 2 dny"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Sledovat?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Hlášení o služební cestě"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Pokud potřebujete pomoct, obraťte se na \nmě nebo na Helen. Toto hlášení bude"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Klientské výdaje"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ztmavit obrazovku"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktivní ovládací prvky"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Ovládací prvky časování"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Přesto pokračovat"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Zrušit"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Nastavení zvětšení"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Zvětšení zkratkou"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Zvětšení zkratkou a trojitým klepnutím"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Neprůhledné"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text s vysokým kontrastem"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Změnit barvu textu na černou nebo bílou, čímž se maximalizuje kontrast vůči pozadí."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximalizovat kontrast textu"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Změnit barvu textu na černou nebo bílou a zvýšit tak kontrast vůči pozadí"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automaticky aktualizovat přiblížení"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Aktual. přiblížení obrazovky při přepnutí aplikací"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Vypínač ukončí hovor"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Podržení tlačítek hlasitosti"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Přiblížení trojitým klepnutím"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Upravit zkratky přístupnosti"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Vyberte zkratku pro %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Pokračovat"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Naslouchátka"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Nastavte a spravuje naslouchátka ASHA a LE Audio, kochleární implantáty a další zesilovací zařízení"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nejsou připojena žádná naslouchátka"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Přidat naslouchátka"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Spárování naslouchátek"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilita s naslouchátky"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Zlepšuje kompatibilitu s indukčními cívkami a snižuje nežádoucí šum"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Informace o naslouchátkách"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Pokud chcete najít další naslouchátka, která nejsou podporována protokolem ASHA nebo LE Audio, klepněte na "<b>"Spárovat nové zařízení"</b>" &gt; "<b>"Zobrazit další zařízení"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Spárování naslouchátek"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Na této stránce můžete spárovat naslouchátka ASHA a LE Audio. Ujistěte se, že je naslouchátko zapnuté a připravené ke spárování."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostupná naslouchátka"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatické přepínání dat"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Používat data z obou SIM karet v závislosti na pokrytí a dostupnosti"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Pouze data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Nastavit"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Další"</string>
@@ -4943,12 +4927,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomáhá zjistit relativní pozici okolních zařízení, která podporují UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Pokud chcete používat technologii UWB, vypněte režim Letadlo"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB v aktuální lokalitě není k dispozici"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Pomocí protokolu Thread se připojte ke kompatibilním zařízením a získejte sjednocené prostředí chytré domácnosti"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Pokud chcete používat protokol Thread, vypněte režim Letadlo"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Přístup k fotoaparátu"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Přístup k mikrofonu"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Aplikace a služby"</string>
@@ -5125,8 +5106,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Zrušit"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standardní"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Výchozí"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Střední"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Vysoká"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Tuto aplikaci lze otevřít jen v jednom okně"</string>
diff --git a/res/values-da/arrays.xml b/res/values-da/arrays.xml
index 0a7b4aa..d86bd08 100644
--- a/res/values-da/arrays.xml
+++ b/res/values-da/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Håndter som forbrugsafregnet netværk"</item>
     <item msgid="2047166446768045816">"Håndter som ubegrænset netværk"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Anvend tilfældig MAC (standard)"</item>
-    <item msgid="741680937828608749">"Anvend enhedens MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nej"</item>
     <item msgid="2163015208097377388">"Ja"</item>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 5940836..9f3d20b 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Par højre apparat"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Par venstre apparat"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"For alle tilgængelige høreapparater"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Flere indstillinger for høreapparater"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Skift indstillinger på alle enheder, f.eks. indstillinger for genveje og teleslynger"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"For denne enhed"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Lydudgang"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Om lydudgang"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Konfigurerer et privat område…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Notifikationer fra apps i dit private område er skjult, når området er låst"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"I indstillingerne for private områder kan du skjule et privat område og konfigurere automatisk låsning"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Påkrævede apps er allerede installeret i dit private område"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Et privat område kunne ikke konfigureres"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Prøv igen"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Brug skærmlås til at låse dit private område op?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apps og notifikationer"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Følsomme notifikationer på låseskærmen"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Vis følsomt indhold, når det private område er låst op"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Opret en Google-konto for at hjælpe med at beskytte dine data"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"På den næste skærm kan du logge på en konto, du vil bruge med dit private område"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Opret en dedikeret konto for at hjælpe med at undgå, at data vises uden for det private område, f.eks.:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Synkroniserede billeder, filer, mails, kontakter, kalenderbegivenheder og andre data"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historik for appdownload og anbefalinger"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Browserhistorik, bogmærker og gemte adgangskoder"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Foreslået indhold, der er relateret til din aktivitet i apps i det private område"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Du kan tilføje op til <xliff:g id="COUNT">%d</xliff:g> fingeraftryk"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Du har tilføjet det maksimale antal fingeraftryk"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Du kan ikke tilføje flere fingeraftryk"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Dit mobilselskab tillader ikke, at du opretter forbindelse til dette netværk, da det bruger en ældre og mindre sikker sikkerhedsprotokol"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Tillad WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Luk"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Vil du afbryde forbindelsen til <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Du har forbindelse til et WEP-netværk. Hvis du blokerer disse netværk, afbrydes din forbindelse."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Avancerede valgmuligheder"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rulleliste med avancerede valgmuligheder"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"udvid"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Vil du bruge <xliff:g id="NEW_APP">%s</xliff:g> til at administrere dine netværksforbindelser?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Seneste lokationsanmodninger"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokation for arbejdsprofil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Lokationstilladelse for apps"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokation er slået fra"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# ud af {total} apps har adgang til din lokation}one{# ud af {total} apps har adgang til din lokation}other{# ud af {total} apps har adgang til din lokation}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Brug skærmtastaturet"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Behold det på skærmen, mens det fysiske tastatur er aktivt"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Elastiktaster"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tastaturet ignorerer gentagende, hurtige tryk på den samme tast inden for <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Træge taster"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Juster tiden det tager, inden et tryk på en tast aktiveres, til <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Træge taster"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Tryk på én tast ad gangen for at bruge genveje i stedet for at holde flere taster nede på samme tid"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tastaturgenveje"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Vis liste over genveje"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatur og værktøjer for arbejdsprofil"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Nulstil"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Vælg ændringstast"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Vælg en ny ændringstast til <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Standard"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Tale"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Markørens hastighed"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Spillekontroller"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Du kan tilpasse denne enhed, så den passer til dine behov. Disse hjælpefunktioner kan ændres senere under Indstillinger."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Skift skriftstørrelse"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Skærmlæser"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Valgmuligheder for det fysiske tastatur"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Undertekster"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Lyd"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Generelt"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Visning"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Farve og bevægelse"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Farvekontrast"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Højere kontrast gør tekst, knapper og ikoner tydeligere. Vælg den kontrast, du foretrækker."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Visse apps understøtter ikke alle indstillinger for farve- og tekstkontrast"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Juster, hvordan farver og tekst ser ud mod baggrundsfarven på din skærm"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Se forhåndsvisning"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 dage siden"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Vil du følge op?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Forretningsrejserapport"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Kontakt mig eller Helen, hvis du har brug \nfor mere hjælp. Denne rapport er"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Kundeudgifter"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Gør skærmen mørkere"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktionsstyring"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Tidsrelaterede styringselementer"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Fortsæt alligevel"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Annuller"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Indstillinger for forstørrelse"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Brug en genvej til forstørrelse"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Brug en genvej til forstørrelse med tre tryk"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Om <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ikke-gennemsigtig"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst med høj kontrast"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Skift tekstfarven til sort eller hvid. Dette maksimerer kontrasten med baggrunden."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimér tekstkontrast"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Skift tekstfarven til sort eller hvid for at øge kontrasten mod baggrunden."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Opdater skærmforstørrelse automatisk"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Opdater skærmforstørrelsen på appovergange"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Afbryderknap afslutter opkald"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold lydstyrketasterne inde"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tryk tre gange på skærmen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Rediger genveje til hjælpefunktioner"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Vælg din genvej til %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Fortsæt"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Høreapparater"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Konfigurer og administrer høreapparater, der understøtter ASHA og LE-lyd, cochlear-implantater og andre enheder til lydforstærkning"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ingen høreapparater er tilsluttet"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Tilføj høreapparater"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Par høreapparater"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Høreapparatskompatibilitet"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Forbedrer kompatibiliteten med teleslynge og reducerer uønsket støj"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Om høreapparater"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Hvis du vil finde andre høreapparater, der ikke understøttes af ASHA eller LE-lyd, skal du trykke på "<b>"Par ny enhed"</b>" &gt; "<b>"Se flere enheder"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Par høreapparat"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Du kan parre høreapparater med ASHA og LE-lyd på denne side. Sørg for, at dit høreapparat er tændt og klar til at blive parret."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Tilgængelige høreapparater"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Beskeder"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatisk dataskift"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Brug data fra begge SIM-kort afhængigt af dækning og tilgængelighed"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Kun data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Konfigurer"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Næste"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Hjælper med at identificere den relative position af enheder i nærheden, som har UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Deaktiver flytilstand for at bruge UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB er ikke tilgængelig på den nuværende lokation"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Opret forbindelse til kompatible enheder via Thread for at få en ensartet brugeroplevelse i dit smarthjem"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Deaktiver flytilstand for at bruge Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kameraadgang"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofonadgang"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"For apps og tjenester"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Annuller"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Standard"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Middel"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Høj"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Denne app kan kun åbnes i 1 vindue"</string>
diff --git a/res/values-de/arrays.xml b/res/values-de/arrays.xml
index 8e9bdc4..7b0c5cc 100644
--- a/res/values-de/arrays.xml
+++ b/res/values-de/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Wie „kostenpflichtig“ behandeln"</item>
     <item msgid="2047166446768045816">"Wie „ohne Datenlimit“ behandeln"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Zufällige MAC-Adresse verwenden (Standard)"</item>
-    <item msgid="741680937828608749">"MAC-Adresse des Geräts verwenden"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nein"</item>
     <item msgid="2163015208097377388">"Ja"</item>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 65593bf..7c7730a 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Rechtes Ohr koppeln"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Linkes Ohr koppeln"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Für alle verfügbaren Hörgeräte"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Mehr Hörgeräteeinstellungen"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Du kannst die geräteübergreifenden Einstellungen wie Tastenkombinations- und Hörspuleneinstellungen ändern."</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Für dieses Gerät"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audioausgabe"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Informationen zur Audioausgabe"</string>
@@ -310,7 +308,7 @@
     <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
     <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
     <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Abbrechen"</string>
-    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nein danke"</string>
+    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nein, danke"</string>
     <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Ich stimme zu"</string>
     <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Mehr"</string>
     <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Per Gesicht entsperren"</string>
@@ -493,7 +491,7 @@
     <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Zu <xliff:g id="PERCENTAGE">%d</xliff:g> %% eingerichtet"</string>
     <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Fingerabdruck zu <xliff:g id="PERCENTAGE">%d</xliff:g> %% eingerichtet"</string>
     <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Fingerabdruck hinzugefügt"</string>
-    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Jederzeit durch Berühren entsperren"</string>
+    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Fingerabdruck entsperrt auch bei ausgeschaltetem Display"</string>
     <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Du kannst dein Gerät auch bei ausgeschaltetem Display per Fingerabdruck entsperren. Das erhöht allerdings die Gefahr eines versehentlichen Entsperrens."</string>
     <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Display, entsperren"</string>
     <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Später"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Der private Bereich wird eingerichtet…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Benachrichtigungen von Apps im privaten Bereich werden nicht angezeigt, wenn dieser gesperrt ist"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Du kannst die Einstellungen konfigurieren, um den privaten Bereich auszublenden und automatisch sperren zu lassen"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Notwendige Apps sind bereits in deinem privaten Bereich installiert"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Der private Bereich konnte nicht eingerichtet werden"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Noch einmal versuchen"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Privaten Bereich mit Displaysperre entsperren?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apps und Benachrichtigungen"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Sensible Benachrichtigungen auf dem Sperrbildschirm"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Sensible Inhalte werden angezeigt, wenn der private Bereich entsperrt ist"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Ein Google-Konto zum Schutz deiner Daten erstellen"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Auf dem nächsten Bildschirm kannst du dich in einem Konto anmelden, das du für deinen privaten Bereich nutzen möchtest."</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Erstelle ein eigenes Konto, um das Risiko zu minimieren, dass Daten außerhalb des privaten Bereichs erscheinen, wie:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Synchronisierte Fotos, Dateien, E-Mails, Kontakte, Kalendertermine und andere Daten"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Verlauf der App-Downloads und Empfehlungen"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Browserverlauf, Lesezeichen und gespeicherte Passwörter"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Vorgeschlagene Inhalte in Bezug auf deine Aktivitäten in Apps im privaten Bereich"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Ok"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Du kannst bis zu <xliff:g id="COUNT">%d</xliff:g> Fingerabdrücke hinzufügen."</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Du hast die maximale Anzahl an Fingerabdrücken hinzugefügt"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Es können keine Fingerabdrücke mehr hinzugefügt werden"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Dein Mobilfunkanbieter lässt nicht zu, dass du dich mit diesem Netzwerk verbindest, da es ein älteres Sicherheitsprotokoll verwendet, das weniger sicher ist"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP zulassen"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Schließen"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Verbindung mit <xliff:g id="NAME">%1$s</xliff:g> trennen?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Du bist mit einem WEP-Netzwerk verbunden. Wenn du diese Netzwerke blockierst, wirst du getrennt."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Erweiterte Optionen"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Drop-down-Liste \"Erweiterte Optionen\""</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"maximieren"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"<xliff:g id="NEW_APP">%s</xliff:g> zur Verwaltung von Netzwerkverbindungen nutzen?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Letzte Standortanfragen"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Standort für Arbeitsprofil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Berechtigungen zur Standortermittlung"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Standortermittlung ist deaktiviert"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# von {total} Apps hat Zugriff auf den Standort}other{# von {total} Apps haben Zugriff auf den Standort}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Bildschirmtastatur verwenden"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Bildschirmtastatur auch dann anzeigen, wenn physische Tastatur aktiv ist"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Bounce-Tasten"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Schnell aufeinanderfolgende Betätigungen derselben Taste innerhalb von <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms werden auf der Tastatur ignoriert"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Anschlagverzögerung"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Zeit zum Aktivieren eines Tastendrucks wird auf <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms festgelegt"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Einfingerbedienung"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Bei Tastenkombinationen Tasten einzeln drücken, statt sie zusammen gedrückt zu halten"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tastenkürzel"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Liste der Tastenkombinationen anzeigen"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastaturen und Tools für das Arbeitsprofil"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Zurücksetzen"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Modifikatortaste wählen"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Wähle eine neue Taste für <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Standard"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Spracheingabe, -erkennung und -ausgabe"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Zeigergeschwindigkeit"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Gamecontroller"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Du kannst dieses Gerät an deine Bedürfnisse anpassen. Die Bedienungshilfen kannst du später in den Einstellungen ändern."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Schriftgröße ändern"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Screenreader"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Optionen für physische Tastaturen"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Untertitel"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Allgemein"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Display"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Farbe und Bewegung"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Farbkontrast"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Durch einen stärkeren Kontrast stechen Texte, Schaltflächen und Symbole mehr hervor. Wähle den Kontrast, der für dich am besten aussieht."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Einige Apps unterstützen eventuell noch nicht alle Farb- und Textkontrasteinstellungen."</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Du kannst anpassen, wie Farben und Text vor der Hintergrundfarbe deines Bildschirms dargestellt werden."</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Vorschau"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Vor 2 Tagen"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Abklären?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Bericht zur Geschäftsreise"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Falls du weitere Unterstützung benötigst, kontaktiere bitte \nmich oder Helen. Dieser Bericht wird"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Kundenausgaben"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Bildschirm dunkler machen"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktionssteuerung"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Einstellungen für Zeitvorgaben"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Trotzdem fortfahren"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Abbrechen"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Vergrößerungseinstellungen"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Mit Tastenkombination vergrößern"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Mit Tastenkombination und 3-mal Tippen vergrößern"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Die Bedienungshilfe „<xliff:g id="SERVICE">%1$s</xliff:g>“"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Nicht transparent"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text mit hohem Kontrast"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Textfarbe in Schwarz oder Weiß ändern. Maximiert den Kontrast zum Hintergrund."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Textkontrast maximieren"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Du kannst die Textfarbe in Schwarz oder Weiß ändern, um einen stärkeren Kontrast zum Hintergrund zu schaffen."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Vergrößerung automatisch aktualisieren"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Vergrößerung bei App-Übergängen aktualisieren"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Ein/Aus-Taste beendet Anruf"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Lautstärketasten gedrückt halten"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Dreimal auf den Bildschirm tippen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Kurzbefehl für Bedienungshilfen bearbeiten"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Tastenkombination für %1$s auswählen"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Weiter"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hörgeräte"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Du kannst Hörgeräte, Cochlea-Implantate und andere Verstärker, die mit ASHA und LE Audio kompatibel sind, einrichten und verwalten"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Keine Hörgeräte verbunden"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Hörgeräte hinzufügen"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Hörgeräte koppeln"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilität mit Hörgeräten"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Bessere Kompatibilität mit Telefonspulen und Reduzierung unerwünschter Geräusche"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Informationen zu Hörgeräten"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Tippe zum Suchen nach anderen Hörgeräten, die nicht mit ASHA oder LE Audio kompatibel sind, auf "<b>"Neues Gerät koppeln"</b>" &gt; "<b>"Mehr Geräte ansehen"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Hörgerät koppeln"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Auf dieser Seite kannst du ASHA- und LE Audio-Hörgeräte koppeln. Dein Hörgerät muss eingeschaltet und bereit zum Koppeln sein."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Verfügbare Hörgeräte"</string>
@@ -3437,7 +3418,7 @@
     <string name="notification_pulse_title" msgid="8013178454646671529">"Benachrichtigungslicht blinkt"</string>
     <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Datenschutz"</string>
     <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Sperrbildschirm überspringen"</string>
-    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Nach Entsperrung wird direkt der letzte Bildschirm angezeigt. Sperrbildschirm zeigt keine Benachrichtigungen. Um diese zu sehen, von oben wischen."</string>
+    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Nach dem Entsperren wird direkt der zuletzt genutzte Bildschirm angezeigt. Um Benachrichtigungen auf dem Sperrbildschirm zu sehen, von oben wischen."</string>
     <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Sperrbildschirm, überspringen, umgehen"</string>
     <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Wenn das Arbeitsprofil gesperrt ist"</string>
     <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Nur neue Benachrichtigungen auf dem Sperrbildschirm anzeigen"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Daten automatisch wechseln"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Du kannst je nach Abdeckung und Verfügbarkeit Daten von beiden SIM-Karten verwenden"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Nur für Daten"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Einrichten"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Weiter"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Zur Ermittlung der relativen Position von Geräten mit UWB in der Nähe"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Flugmodus deaktivieren, um UWB zu verwenden"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB ist an deinem derzeitigen Standort nicht verfügbar"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Verbindung mit kompatiblen Geräten für eine nahtlose Smart-Home-Nutzung mit Thread herstellen"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Flugmodus deaktivieren, um Thread zu verwenden"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kamerazugriff"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofonzugriff"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Für Apps und Dienste"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Abbrechen"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Standard"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Mittel"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Hoch"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Diese App kann nur in einem einzigen Fenster geöffnet werden"</string>
diff --git a/res/values-el/arrays.xml b/res/values-el/arrays.xml
index 68c9e3b..422deff 100644
--- a/res/values-el/arrays.xml
+++ b/res/values-el/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Δίκτυο με περιορισμούς"</item>
     <item msgid="2047166446768045816">"Δίκτυο χωρίς περιορισμούς"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Χρήση τυχαίου MAC (προεπιλογή)"</item>
-    <item msgid="741680937828608749">"Χρήση MAC συσκευής"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Όχι"</item>
     <item msgid="2163015208097377388">"Ναι"</item>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index 33c949a..8183a3c 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Σύζευξη δεξιού"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Σύζευξη αριστερού"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Για όλες τις διαθέσιμες συσκευές ακοής"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Περισσότερες ρυθμίσεις συσκευής ακοής"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Αλλάξτε τις ρυθμίσεις πολλών συσκευών, όπως στοιχεία ελέγχου συντομεύσεων και telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Για αυτήν τη συσκευή"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Έξοδος ήχου"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Σχετικά με την έξοδο ήχου"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Ρύθμιση ιδιωτικού χώρου…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Οι ειδοποιήσεις από εφαρμογές του απόρρητου χώρου είναι κρυφές όταν είναι κλειδωμένος"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Εξερευνήστε τις ρυθμίσεις απόρρητου χώρου για απόκρυψη του απόρρητου χώρου και ρύθμιση του αυτόματου κλειδώματος"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Οι απαιτούμενες εφαρμογές έχουν ήδη εγκατασταθεί στον απόρρητο χώρο σας"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Δεν ήταν δυνατή η ρύθμιση ενός απόρρητου χώρου"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Επανάληψη"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Χρήση κλειδώματος οθόνης για τον ιδιωτικό χώρο;"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Εφαρμογές και ειδοποιήσεις"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Ευαίσθητες ειδοποιήσεις στην οθόνη κλειδώματος"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Εμφάνιση ευαίσθητου περιεχομένου όταν ο απόρρητος χώρος είναι ξεκλειδωμένος"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Δημιουργήστε έναν Λογαριασμό Google για να διατηρήσετε ιδιωτικά τα δεδομένα σας"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Στην επόμενη οθόνη μπορείτε να συνδεθείτε σε έναν λογαριασμό για χρήση με τον απόρρητο χώρο σας"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Δημιουργήστε έναν αποκλειστικό λογαριασμό ώστε τα δεδομένα να μην εμφανίζονται εκτός του απόρρητου χώρου, όπως:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Συγχρονισμένες φωτογρ., αρχεία, μηνύμ .ηλ. ταχυδρ., επαφές, συμβ. ημερολ. και άλλα δεδομ."</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Ιστορικό λήψης εφαρμογών και προτάσεις"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Ιστορ. περιήγ., σελιδοδείκτες και αποθηκ. κωδικοί πρόσβασης"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Προτεινόμενο περιεχόμενο σχετικά με τη δραστηριότητά σας σε εφαρμογές του απόρρητου χώρου"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Το κατάλαβα"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Μπορείτε να προσθέσετε έως <xliff:g id="COUNT">%d</xliff:g> δακτυλικά αποτυπώματα"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Έχετε προσθέσει τον μέγιστο αριθμό δακτυλικών αποτυπωμάτων"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Δεν είναι δυνατή η προσθήκη περισσότερων δακτυλικών αποτυπωμάτων"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Επειδή αυτό το δίκτυο χρησιμοποιεί παλαιότερο πρωτόκολλο ασφαλείας που είναι λιγότερο ασφαλές, η εταιρεία κινητής τηλεφωνίας σας δεν επιτρέπει τη σύνδεση σε αυτό"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Να επιτρέπεται το WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Κλείσιμο"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Αποσύνδεση από <xliff:g id="NAME">%1$s</xliff:g>;"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Έχετε συνδεθεί σε ένα δίκτυο WEP. Αν αποκλείσετε αυτά τα δίκτυα, θα αποσυνδεθείτε."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Σύνθετες επιλογές"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Σύνθετες επιλογές αναπτυσσόμενης λίστας"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ανάπτυξη"</string>
@@ -1379,7 +1366,7 @@
     <string name="storage_menu_migrate" msgid="2196088149560070193">"Μετεγκατάσταση δεδομένων"</string>
     <string name="storage_menu_forget" msgid="5154017890033638936">"Διαγραφή"</string>
     <string name="storage_menu_set_up" msgid="4401074025612064744">"Ρύθμιση"</string>
-    <string name="storage_menu_free" msgid="616100170298501673">"Απελευθερώστε χώρο"</string>
+    <string name="storage_menu_free" msgid="616100170298501673">"Αποδεσμεύστε χώρο"</string>
     <string name="storage_menu_manage" msgid="7465522758801346408">"Διαχείριση αποθηκευτικού χώρου"</string>
     <string name="storage_free_up_space_title" msgid="281047807372131975">"Αποδεσμεύστε χώρο"</string>
     <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Μεταβείτε στην εφαρμογή Files για να διαχειριστείτε και να αποδεσμεύσετε αποθηκευτικό χώρο"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Χρήση της εφαρμογής <xliff:g id="NEW_APP">%s</xliff:g> για τη διαχείριση των συνδέσεων δικτύου σας;"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Πρόσφατα αιτήματα τοποθεσίας"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Τοποθεσία για προφίλ εργασίας"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Άδειες τοποθεσίας εφαρμογών"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Η τοποθεσία είναι ανενεργή"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# από {total} εφαρμογές έχει πρόσβαση στην τοποθεσία σας.}other{# από {total} εφαρμογές έχουν πρόσβαση στην τοποθεσία σας.}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Χρήση πληκτρολογίου οθόνης"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Να παραμένει στην οθόνη όταν είναι ενεργό το φυσικό πληκτρολόγιο"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Ελαστικά πλήκτρα"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Το πληκτρολόγιο αγνοεί τα γρήγορα, επαναλαμβανόμενα πατήματα του ίδιου πλήκτρου εντός <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Αργά πλήκτρα"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Προσαρμόζει τον χρόνο που απαιτείται για την ενεργοποίηση ενός πατήματος πλήκτρου στα <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Ασύγχρονα πλήκτρα"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Για τις συντομεύσεις, αντί να πατάτε παρατεταμένα όλα τα κουμπιά μαζί, φροντίστε να πατάτε ένα πλήκτρο κάθε φορά"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Συντομεύσεις πληκτρολογίου"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Εμφάνιση λίστας συντομεύσεων"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Πληκτρολόγιο και εργαλεία προφίλ εργασίας"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Επαναφορά"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Επιλέξτε πλήκτρο τροποποίησης"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Επιλέξτε ένα νέο κλειδί για <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Προεπιλογή"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Ομιλία"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Ταχύτητα δείκτη"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Χειριστήριο παιχνιδιού"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Μπορείτε να προσαρμόσετε αυτήν τη συσκευή σύμφωνα με τις ανάγκες σας. Οι λειτουργίες προσβασιμότητας μπορούν να τροποποιηθούν αργότερα από τις ρυθμίσεις."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Αλλαγή μεγέθους γραμματοσειράς"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Αναγνώστης οθόνης"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Επιλογές φυσικού πληκτρολογίου"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Υπότιτλοι"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Ήχος"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Γενικά"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Οθόνη"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Χρώμα και κίνηση"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Χρωματική αντίθεση"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Η υψηλότερη αντίθεση επιτρέπει στο κείμενο, τα κουμπιά και τα εικονίδια να ξεχωρίζουν περισσότερο. Επιλέξτε την αντίθεση που προτιμάτε."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Ορισμένες εφαρμογές μπορεί να μην υποστηρίζουν όλες τις ρυθμίσεις χρώματος και αντίθεσης κειμένου"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Προσαρμόστε την εμφάνιση των χρωμάτων και του κειμένου σε σχέση με το χρώμα φόντου της οθόνης σας"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Προεπισκόπηση"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 ημέρες πριν"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Συνέχεια;"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Αναφορά επαγγελμ. ταξιδιού"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Για περισσότερη βοήθεια, επικοινωνήστε \nμαζί μου ή με τη Helen. Αυτή η αναφορά θα είναι"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Έξοδα πελάτη"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Κάντε την οθόνη πιο σκοτεινή"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Στοιχεία ελέγχου αλληλεπίδρασης"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Στοιχεία ελέγχου χρονισμού"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Συνέχεια ούτως ή άλλως"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Ακύρωση"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Ρυθμίσεις μεγέθυνσης"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Συντόμ. μεγέθυνσης"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Μεγέθυνση με συντόμευση και τριπλό πάτημα"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Σχετικά με <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Μη διαφανές"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Κείμενο υψηλής αντίθεσης"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Αλλαγή χρώματος του κειμένου σε μαύρο ή λευκό. Μεγιστοποιεί την αντίθεση με το φόντο."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Μεγιστοποίηση αντίθεσης κειμένου"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Αλλάξτε το χρώμα του κειμένου σε μαύρο ή λευκό για να αυξήσετε την αντίθεση σε σχέση με το φόντο."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Αυτόματη ενημέρωση μεγέθυνσης οθόν."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ενημέρωση μεγέθυνσης οθόνης στις μεταβάσεις εφαρμ."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Τερματ. κλήσης με κουμπί λειτουργίας"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Πατήστε παρατεταμένα τα πλήκτρα έντασης"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Τριπλό πάτημα οθόνης"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Επεξεργασία συντομεύσεων προσβασιμότητας"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Επιλέξτε τη συντόμευση για το %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Συνέχεια"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Συσκευές ακοής"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Ρύθμιση και διαχείριση βοηθημάτων ακοής ASHA και LE Audio, κοχλιακών εμφυτευμάτων και άλλων συσκευών ενίσχυσης ήχου"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Δεν έχουν συνδεθεί συσκευές ακοής"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Προσθήκη βοηθημάτων ακοής"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Σύζευξη βοηθημάτων ακοής"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Συμβατότητα βοηθημάτων ακοής"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Βελτιώνει τη συμβατότητα με telecoil και μειώνει τον ανεπιθύμητο θόρυβο"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Σχετικά με τις συσκευές ακοής"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Για να βρείτε άλλες συσκευές ακοής που δεν υποστηρίζονται από το ASHA ή το LE Audio, πατήστε "<b>"Σύζευξη νέας συσκευής"</b>" &gt; "<b>"Εμφάνιση περισσότερων συσκευών"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Σύζευξη συσκευής ακοής"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Σε αυτή τη σελίδα, μπορείτε να κάνετε σύζευξη των συσκευών ακοής ASHA και LE Audio. Βεβαιωθείτε ότι η συσκευή ακοής είναι ενεργοποιημένη και έτοιμη για σύζευξη."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Διαθέσιμες συσκευές ακοής"</string>
@@ -4201,7 +4182,7 @@
     <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Εμφάνιση συμβάντων εργασίας στο προσωπικό ημερολόγιο"</string>
     <string name="managed_profile_settings_footer" msgid="996500759305118103">"Όταν οι εφαρμογές εργασίας είναι απενεργοποιημένες, τίθενται σε παύση, δεν μπορούν να σας στείλουν ειδοποιήσεις και δεν μπορείτε να αποκτήσετε πρόσβαση σε αυτές."</string>
     <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Διαχείριση αποθηκευτικού χώρου"</string>
-    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Η Διαχείριση αποθηκευτικού χώρου βοηθά στην απελευθέρωση αποθηκευτικού χώρου καταργώντας από τη συσκευή σας φωτογραφίες και βίντεο για τα οποία έχουν δημιουργηθεί αντίγραφα ασφαλείας."</string>
+    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Η Διαχείριση αποθηκευτικού χώρου βοηθά στην αποδέσμευση αποθηκευτικού χώρου καταργώντας από τη συσκευή σας φωτογραφίες και βίντεο για τα οποία έχουν δημιουργηθεί αντίγραφα ασφαλείας."</string>
     <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Κατάργηση φωτογραφιών και βίντεο"</string>
     <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Διαχείριση αποθηκευτικού χώρου"</string>
     <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Χρήση Διαχειριστή αποθηκευτικού χώρου."</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Μηνύματα"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Αυτόματη εναλλαγή δεδομένων"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Χρήση είτε της μίας είτε της άλλης SIM, ανάλογα με την κάλυψη και τη διαθεσιμότητα"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Μόνο δεδομένα"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Ρύθμιση"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Επόμενο"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Συμβάλλει στον προσδιορισμό της σχετικής θέσης των κοντινών συσκευών με UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Απενεργοποιήστε τη λειτουργία πτήσης για να χρησιμοποιήσετε το UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Το UWB δεν είναι διαθέσιμο στην τρέχουσα τοποθεσία"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Συνδεθείτε σε συμβατές συσκευές χρησιμοποιώντας το Thread για μια απρόσκοπτη εμπειρία έξυπνου σπιτιού"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Απενεργοποιήστε τη λειτουργία πτήσης για να χρησιμοποιήσετε το Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Πρόσβαση κάμερας"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Πρόσβαση μικροφώνου"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Για εφαρμογές και υπηρεσίες"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Ακύρωση"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Αντίθεση"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Τυπική"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Προεπιλογή"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Μέτρια"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Υψηλή"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Αυτή η εφαρμογή μπορεί να ανοίξει μόνο σε ένα παράθυρο"</string>
diff --git a/res/values-en-rAU/arrays.xml b/res/values-en-rAU/arrays.xml
index 8eb51ad..77db6a7 100644
--- a/res/values-en-rAU/arrays.xml
+++ b/res/values-en-rAU/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Treat as metered"</item>
     <item msgid="2047166446768045816">"Treat as unmetered"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Use randomised MAC (default)"</item>
-    <item msgid="741680937828608749">"Use device MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"No"</item>
     <item msgid="2163015208097377388">"Yes"</item>
diff --git a/res/values-en-rAU/strings.xml b/res/values-en-rAU/strings.xml
index ceb4aec..372ef9d 100644
--- a/res/values-en-rAU/strings.xml
+++ b/res/values-en-rAU/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Your operator doesn\'t allow you to connect to this network because it uses an older security protocol that’s less secure"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Allow WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Close"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Disconnect from <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"You\'re connected to a WEP network. If you block these networks, you\'ll be disconnected."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Advanced options"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Drop-down list Advanced Options"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expand"</string>
@@ -1542,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Use <xliff:g id="NEW_APP">%s</xliff:g> to manage your network connections?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Recent location requests"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Location for work profile"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"App location permissions"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Location is off"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# of {total} apps has access to location}other{# of {total} apps have access to location}}"</string>
@@ -1875,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Use on-screen keyboard"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Keep it on screen while physical keyboard is active"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Bounce keys"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"The keyboard ignores quickly repeated presses of the same key within <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Slow keys"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Adjusts the time that it takes for a key press to activate to <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Sticky keys"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Press one key at a time for shortcuts instead of holding keys down together"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Keyboard shortcuts"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Show list of shortcuts"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Work profile keyboards &amp; tools"</string>
@@ -1936,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Reset"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Choose modifier key"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Choose a new key for <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> layout"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Default"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatic: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"User selected: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Speech"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Pointer speed"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Game Controller"</string>
@@ -1992,8 +1992,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"You can customise this device to fit your needs. These accessibility features can be changed later in Settings."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Change font size"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Screen reader"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Physical keyboard options"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Captions"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"General"</string>
@@ -2059,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continue anyway"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancel"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Magnification settings"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Magnify with shortcut"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Magnify with shortcut &amp; triple-tap"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"About <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2243,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold volume keys"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triple-tap screen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edit accessibility shortcuts"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Choose your shortcut for %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continue"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hearing devices"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Set up and manage ASHA and LE Audio hearing aids, cochlear implants and other amplification devices"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"No hearing devices connected"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Add hearing aids"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Pair hearing aids"</string>
@@ -2266,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Hearing aid compatibility"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Improves compatibility with telecoils and reduces unwanted noise"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"About hearing devices"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"To find other hearing devices that aren\'t supported by ASHA or LE Audio, tap "<b>"Pair new device"</b>" &gt; "<b>"See more devices"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Pair hearing device"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"You can pair ASHA and LE Audio hearing devices on this page. Make sure that your hearing device is turned on and ready to pair."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Available hearing devices"</string>
@@ -4639,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Texts"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatic data switching"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Use data from either SIM depending on coverage and availability"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data only"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Set up"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Next"</string>
@@ -4917,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Helps identify the relative position of nearby devices that have UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Turn off aeroplane mode to use UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is unavailable in the current location"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Connect to compatible devices using Thread for a seamless smart home experience"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Turn off aeroplane mode to use Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Camera access"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Microphone access"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"For apps and services"</string>
diff --git a/res/values-en-rCA/arrays.xml b/res/values-en-rCA/arrays.xml
index a69d633..be0db1f 100644
--- a/res/values-en-rCA/arrays.xml
+++ b/res/values-en-rCA/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Treat as metered"</item>
     <item msgid="2047166446768045816">"Treat as unmetered"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Use randomized MAC (default)"</item>
-    <item msgid="741680937828608749">"Use device MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"No"</item>
     <item msgid="2163015208097377388">"Yes"</item>
diff --git a/res/values-en-rCA/strings.xml b/res/values-en-rCA/strings.xml
index 9ac89f5..7e2ca45 100644
--- a/res/values-en-rCA/strings.xml
+++ b/res/values-en-rCA/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Your carrier doesn\'t allow you to connect to this network because it uses an older security protocol that’s less secure"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Allow WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Close"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Disconnect from <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"You\'re connected to a WEP network. If you block these networks, you\'ll be disconnected."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Advanced options"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Drop down list Advanced Options"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expand"</string>
@@ -1542,6 +1540,7 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Use <xliff:g id="NEW_APP">%s</xliff:g> to manage your network connections?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Recent location requests"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Location for work profile"</string>
+    <string name="private_profile_location_switch_title" msgid="4127119143109855789">"Location for private space"</string>
     <string name="location_app_level_permissions" msgid="907206607664629759">"App location permissions"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Location is off"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# of {total} apps has access to location}other{# of {total} apps have access to location}}"</string>
@@ -1875,14 +1874,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Use on-screen keyboard"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Keep it on screen while physical keyboard is active"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Bounce keys"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"The keyboard ignores quickly repeated presses of the same key within <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Slow keys"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Adjusts the time it takes for a key press to activate to <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Sticky keys"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Press one key at a time for shortcuts instead of holding keys down together"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Keyboard shortcuts"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Show list of shortcuts"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Work profile keyboards &amp; tools"</string>
@@ -1936,7 +1932,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Reset"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Choose modifier key"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Choose a new key for <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> layout"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Default"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatic: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"User selected: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Speech"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Pointer speed"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Game Controller"</string>
@@ -1992,8 +1991,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"You can customize this device to fit your needs. These accessibility features can be changed later in Settings."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Change font size"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Screen reader"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Physical keyboard options"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Captions"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"General"</string>
@@ -2059,6 +2057,9 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continue anyway"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancel"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Magnification settings"</string>
+    <string name="accessibility_magnification_one_finger_panning_title" msgid="4503949739883092989">"One-finger panning"</string>
+    <string name="accessibility_magnification_one_finger_panning_summary_on" msgid="9133125894310777539">"Move the magnification area by dragging one finger."</string>
+    <string name="accessibility_magnification_one_finger_panning_summary_off" msgid="8979146350396559805">"Move the magnification area by dragging two fingers."</string>
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Magnify with shortcut"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Magnify with shortcut &amp; triple-tap"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"About <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2243,12 +2244,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold volume keys"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triple tap screen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edit accessibility shortcuts"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Choose your shortcut for %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continue"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hearing devices"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Set up and manage ASHA and LE Audio hearing aids, cochlear implants, and other amplification devices"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"No hearing devices connected"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Add hearing aids"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Pair hearing aids"</string>
@@ -2266,8 +2265,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Hearing aid compatibility"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Improves compatibility with telecoils and reduces unwanted noise"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"About hearing devices"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"To find other hearing devices that aren’t supported by ASHA or LE Audio, tap "<b>"Pair new device"</b>" &gt; "<b>"See more devices"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Pair hearing device"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"You can pair ASHA and LE Audio hearing devices on this page. Make sure your hearing device is turned on and ready to pair."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Available hearing devices"</string>
@@ -4639,6 +4637,9 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Texts"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatic data switching"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Use data from either SIM depending on coverage and availability"</string>
+    <string name="sim_action_restart_dialog_title" msgid="3507413479633430120">"Restart to use 2 SIMs"</string>
+    <string name="sim_action_restart_dialog_msg" msgid="4737611046767629774">"To use 2 SIMs at once, restart your device, then turn on both SIMs"</string>
+    <string name="sim_action_restart_dialog_cancel" msgid="665560106686565624">"Use <xliff:g id="CARRIER_NAME">%1$s</xliff:g> only"</string>
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data only"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Set up"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Next"</string>
@@ -4917,12 +4918,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Helps identify the relative position of nearby devices that have UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Turn off Airplane mode to use UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is unavailable in the current location"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Connect to compatible devices using Thread for a seamless smart home experience"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Turn off airplane mode to use Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Camera access"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Microphone access"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"For apps and services"</string>
diff --git a/res/values-en-rGB/arrays.xml b/res/values-en-rGB/arrays.xml
index 8eb51ad..77db6a7 100644
--- a/res/values-en-rGB/arrays.xml
+++ b/res/values-en-rGB/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Treat as metered"</item>
     <item msgid="2047166446768045816">"Treat as unmetered"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Use randomised MAC (default)"</item>
-    <item msgid="741680937828608749">"Use device MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"No"</item>
     <item msgid="2163015208097377388">"Yes"</item>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 4144ee0..a1538a9 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Your operator doesn\'t allow you to connect to this network because it uses an older security protocol that’s less secure"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Allow WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Close"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Disconnect from <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"You\'re connected to a WEP network. If you block these networks, you\'ll be disconnected."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Advanced options"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Drop-down list Advanced Options"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expand"</string>
@@ -1542,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Use <xliff:g id="NEW_APP">%s</xliff:g> to manage your network connections?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Recent location requests"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Location for work profile"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"App location permissions"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Location is off"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# of {total} apps has access to location}other{# of {total} apps have access to location}}"</string>
@@ -1875,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Use on-screen keyboard"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Keep it on screen while physical keyboard is active"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Bounce keys"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"The keyboard ignores quickly repeated presses of the same key within <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Slow keys"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Adjusts the time that it takes for a key press to activate to <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Sticky keys"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Press one key at a time for shortcuts instead of holding keys down together"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Keyboard shortcuts"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Show list of shortcuts"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Work profile keyboards &amp; tools"</string>
@@ -1936,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Reset"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Choose modifier key"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Choose a new key for <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> layout"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Default"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatic: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"User selected: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Speech"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Pointer speed"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Game Controller"</string>
@@ -1992,8 +1992,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"You can customise this device to fit your needs. These accessibility features can be changed later in Settings."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Change font size"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Screen reader"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Physical keyboard options"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Captions"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"General"</string>
@@ -2059,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continue anyway"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancel"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Magnification settings"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Magnify with shortcut"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Magnify with shortcut &amp; triple-tap"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"About <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2243,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold volume keys"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triple-tap screen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edit accessibility shortcuts"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Choose your shortcut for %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continue"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hearing devices"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Set up and manage ASHA and LE Audio hearing aids, cochlear implants and other amplification devices"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"No hearing devices connected"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Add hearing aids"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Pair hearing aids"</string>
@@ -2266,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Hearing aid compatibility"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Improves compatibility with telecoils and reduces unwanted noise"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"About hearing devices"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"To find other hearing devices that aren\'t supported by ASHA or LE Audio, tap "<b>"Pair new device"</b>" &gt; "<b>"See more devices"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Pair hearing device"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"You can pair ASHA and LE Audio hearing devices on this page. Make sure that your hearing device is turned on and ready to pair."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Available hearing devices"</string>
@@ -4639,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Texts"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatic data switching"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Use data from either SIM depending on coverage and availability"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data only"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Set up"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Next"</string>
@@ -4917,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Helps identify the relative position of nearby devices that have UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Turn off aeroplane mode to use UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is unavailable in the current location"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Connect to compatible devices using Thread for a seamless smart home experience"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Turn off aeroplane mode to use Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Camera access"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Microphone access"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"For apps and services"</string>
diff --git a/res/values-en-rIN/arrays.xml b/res/values-en-rIN/arrays.xml
index 8eb51ad..77db6a7 100644
--- a/res/values-en-rIN/arrays.xml
+++ b/res/values-en-rIN/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Treat as metered"</item>
     <item msgid="2047166446768045816">"Treat as unmetered"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Use randomised MAC (default)"</item>
-    <item msgid="741680937828608749">"Use device MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"No"</item>
     <item msgid="2163015208097377388">"Yes"</item>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index 3b9e025..3d4a648 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Your operator doesn\'t allow you to connect to this network because it uses an older security protocol that’s less secure"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Allow WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Close"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Disconnect from <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"You\'re connected to a WEP network. If you block these networks, you\'ll be disconnected."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Advanced options"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Drop-down list Advanced Options"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expand"</string>
@@ -1542,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Use <xliff:g id="NEW_APP">%s</xliff:g> to manage your network connections?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Recent location requests"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Location for work profile"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"App location permissions"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Location is off"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# of {total} apps has access to location}other{# of {total} apps have access to location}}"</string>
@@ -1875,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Use on-screen keyboard"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Keep it on screen while physical keyboard is active"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Bounce keys"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"The keyboard ignores quickly repeated presses of the same key within <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Slow keys"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Adjusts the time that it takes for a key press to activate to <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Sticky keys"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Press one key at a time for shortcuts instead of holding keys down together"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Keyboard shortcuts"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Show list of shortcuts"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Work profile keyboards &amp; tools"</string>
@@ -1936,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Reset"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Choose modifier key"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Choose a new key for <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> layout"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Default"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatic: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"User selected: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Speech"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Pointer speed"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Game Controller"</string>
@@ -1992,8 +1992,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"You can customise this device to fit your needs. These accessibility features can be changed later in Settings."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Change font size"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Screen reader"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Physical keyboard options"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Captions"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"General"</string>
@@ -2059,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continue anyway"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancel"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Magnification settings"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Magnify with shortcut"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Magnify with shortcut &amp; triple-tap"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"About <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2243,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold volume keys"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triple-tap screen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edit accessibility shortcuts"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Choose your shortcut for %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continue"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hearing devices"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Set up and manage ASHA and LE Audio hearing aids, cochlear implants and other amplification devices"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"No hearing devices connected"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Add hearing aids"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Pair hearing aids"</string>
@@ -2266,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Hearing aid compatibility"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Improves compatibility with telecoils and reduces unwanted noise"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"About hearing devices"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"To find other hearing devices that aren\'t supported by ASHA or LE Audio, tap "<b>"Pair new device"</b>" &gt; "<b>"See more devices"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Pair hearing device"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"You can pair ASHA and LE Audio hearing devices on this page. Make sure that your hearing device is turned on and ready to pair."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Available hearing devices"</string>
@@ -4639,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Texts"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatic data switching"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Use data from either SIM depending on coverage and availability"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data only"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Set up"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Next"</string>
@@ -4917,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Helps identify the relative position of nearby devices that have UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Turn off aeroplane mode to use UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is unavailable in the current location"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Connect to compatible devices using Thread for a seamless smart home experience"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Turn off aeroplane mode to use Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Camera access"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Microphone access"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"For apps and services"</string>
diff --git a/res/values-en-rXC/arrays.xml b/res/values-en-rXC/arrays.xml
index 62da2df..46aa965 100644
--- a/res/values-en-rXC/arrays.xml
+++ b/res/values-en-rXC/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‎‏‎‎‎‏‏‏‎‎‏‎‎‎‎‎‏‎‎‎‎‏‎‎‏‎‎‎‏‎‏‎‎‎‏‏‏‎‎‎‎‏‎‎‏‎‏‏‏‏‎‏‎‎‏‏‎‏‏‏‎Treat as metered‎‏‎‎‏‎"</item>
     <item msgid="2047166446768045816">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‎‎‎‏‏‎‏‎‎‎‏‏‏‏‏‏‏‏‎‎‎‎‏‎‎‏‎‏‏‏‎‏‏‏‏‎‏‏‎‏‎‏‎‎‏‏‏‏‏‎‏‏‏‏‏‎‎‎‎Treat as unmetered‎‏‎‎‏‎"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‎‎‎‎‎‏‏‎‎‎‎‎‏‎‎‏‎‎‎‏‎‎‎‎‏‏‏‎‏‏‏‎‏‏‏‏‏‎‎‎‏‏‎‎‎‏‏‏‎‎‏‎‎‏‎‎‏‎‎‏‎Use randomized MAC (default)‎‏‎‎‏‎"</item>
-    <item msgid="741680937828608749">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‏‎‏‎‎‏‎‎‏‎‏‎‏‏‏‏‏‎‏‎‏‏‏‎‎‎‏‎‎‎‏‎‎‎‏‏‏‏‏‏‎‎‏‏‏‏‏‎‏‎‏‎‏‏‏‎‏‏‎‏‎Use device MAC‎‏‎‎‏‎"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‏‏‎‎‏‎‏‏‏‏‏‏‏‏‎‏‏‎‏‎‎‏‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‎‎‎‏‎‎‎‎‏‏‎‏‏‏‏‎‏‏‎‎‏‏‎‎No‎‏‎‎‏‎"</item>
     <item msgid="2163015208097377388">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‏‎‎‏‎‏‏‎‏‏‏‏‏‎‎‏‎‎‎‏‎‎‏‏‎‏‎‎‏‎‏‏‎‏‏‎‎‎‏‏‎‏‏‎‎‎Yes‎‏‎‎‏‎"</item>
diff --git a/res/values-en-rXC/strings.xml b/res/values-en-rXC/strings.xml
index 64063d0..6a5bca2 100644
--- a/res/values-en-rXC/strings.xml
+++ b/res/values-en-rXC/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‏‎‎‎‏‏‏‎‏‎‎‏‎‏‎‏‎‎‎‎‎‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‎‎‏‎‏‏‎‏‎‎‏‏‏‏‎‎‎‏‏‏‎‏‏‎Your carrier doesn\'t allow you to connect to this network because it uses an older security protocol that’s less secure‎‏‎‎‏‎"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‎‏‏‎‏‏‏‏‎‏‏‏‏‏‎‎‎‎‏‎‎‎‎‏‏‏‏‎‏‎‎‎‎‏‎‎‏‎‏‏‎‎‏‎‎‎‏‏‏‎‎‏‏‎‏‎‏‎‏‎‎Allow WEP‎‏‎‎‏‎"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‎‎‏‏‏‎‏‎‎‏‏‎‏‏‏‏‎‏‎‎‎‏‎‏‎‎‏‏‏‎‎‏‏‎‎‎‎‎‏‎‎‎‏‏‎‏‎‎‏‎‎‏‎‎‏‎‏‎‎‎Close‎‏‎‎‏‎"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‎‏‏‏‏‏‎‎‏‏‎‎‎‎‎‎‎‏‏‎‎‏‏‎‎‏‏‎‎‎‎‏‎‎‏‎‏‏‏‏‎‏‏‎‏‎‏‏‎‏‏‎‏‎‏‎‎‎‎Disconnect from ‎‏‎‎‏‏‎<xliff:g id="NAME">%1$s</xliff:g>‎‏‎‎‏‏‏‎?‎‏‎‎‏‎"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‏‎‎‎‏‏‏‎‏‏‎‎‏‏‎‏‏‏‎‏‎‏‏‏‎‏‏‏‏‎‎‎‎‎‎‏‏‎‎‏‏‏‏‏‎‏‎‎‏‎‏‏‏‏‏‎‎‎‏‎‎You\'re connected to a WEP network. If you block these networks, you\'ll be disconnected.‎‏‎‎‏‎"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‎‎‏‎‎‏‏‎‏‎‏‎‏‎‏‏‎‎‏‏‎‏‎‏‎‎‎‏‎‎‏‎‏‏‎‏‏‏‎‏‎‏‏‎‎‎‎‎‎‎‏‏‎‏‏‏‏‎‏‎Advanced options‎‏‎‎‏‎"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‎‏‎‏‎‎‏‎‏‏‏‏‏‎‎‏‎‏‎‏‎‏‏‎‏‎‎‎‏‏‎‏‏‏‏‎‏‎‏‏‎‏‎‎‏‎‏‏‏‏‏‎‏‎‎‏‎‏‎Drop down list Advanced Options‎‏‎‎‏‎"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‎‎‏‎‎‎‏‎‏‎‏‏‏‎‎‎‏‏‏‏‎‏‎‎‏‏‏‏‏‏‏‎‎‎‎‎‏‎‏‏‎‎‏‎‎‏‎‏‏‏‎‎‏‏‎‏‎‎‎‏‎expand‎‏‎‎‏‎"</string>
@@ -1542,6 +1540,7 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‏‎‎‏‎‏‏‏‎‎‏‎‎‏‎‎‏‎‎‎‎‎‎‏‏‎‏‎‏‏‎‎‎‎‏‎‎‏‏‏‎‎‏‏‏‎‎‏‏‏‎‎‎‏‎‎‎‎‎‏‎Use ‎‏‎‎‏‏‎<xliff:g id="NEW_APP">%s</xliff:g>‎‏‎‎‏‏‏‎ to manage your network connections?‎‏‎‎‏‎"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‏‎‏‎‎‏‏‏‎‎‏‏‏‎‏‏‏‎‏‏‎‎‏‏‏‎‏‎‏‎‎‎‏‏‏‏‎‎‎‎‏‎‏‏‏‎‎‎‎‏‏‏‎‏‎‎‏‎‎Recent location requests‎‏‎‎‏‎"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‎‎‎‏‏‎‎‎‏‏‏‎‎‎‏‏‎‏‎‏‏‎‎‏‏‏‏‏‏‏‏‏‎‎‎‎‎‏‎‎‏‏‏‎‏‏‎‏‏‎‏‏‎‏‏‎‎‎‏‎‎Location for work profile‎‏‎‎‏‎"</string>
+    <string name="private_profile_location_switch_title" msgid="4127119143109855789">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‎‎‏‎‏‎‎‎‏‏‎‎‏‏‏‏‎‎‎‏‏‏‏‏‏‏‎‏‎‎‎‎‏‏‎‏‏‎‎‎‏‏‏‎‎‎‎‏‎‏‎‎‎‏‎‏‏‎‏‎Location for private space‎‏‎‎‏‎"</string>
     <string name="location_app_level_permissions" msgid="907206607664629759">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‏‏‎‎‏‎‎‏‎‏‏‏‎‎‎‎‏‎‏‏‏‎‎‏‏‎‏‎‎‏‏‎‎‎‏‏‏‎‏‏‏‏‎‎‏‏‎‎‎‏‏‏‏‏‏‏‏‏‏‏‎App location permissions‎‏‎‎‏‎"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‎‏‎‏‏‎‏‎‎‎‏‎‎‏‎‏‎‏‎‎‏‎‎‏‎‏‏‏‏‏‎‏‏‏‎‎‏‏‏‎‏‎‎‎‏‏‎‏‎‎‎‏‏‎‏‎‏‏‏‏‎Location is off‎‏‎‎‏‎"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‎‎‎‏‏‎‎‏‏‏‎‎‏‏‎‏‏‏‎‏‏‎‎‏‏‎‎‏‏‏‏‎‏‏‎‎‏‎‏‎‎‏‏‎‏‏‏‎‏‎‏‏‎‏‏‏‎‎‎‎# of ‎‏‎‎‏‏‎{total}‎‏‎‎‏‏‏‎ apps has access to location‎‏‎‎‏‎}other{‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‎‎‎‏‏‎‎‏‏‏‎‎‏‏‎‏‏‏‎‏‏‎‎‏‏‎‎‏‏‏‏‎‏‏‎‎‏‎‏‎‎‏‏‎‏‏‏‎‏‎‏‏‎‏‏‏‎‎‎‎# of ‎‏‎‎‏‏‎{total}‎‏‎‎‏‏‏‎ apps have access to location‎‏‎‎‏‎}}"</string>
@@ -1875,14 +1874,11 @@
     <string name="show_ime" msgid="4334255501724746849">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‏‎‎‎‎‏‎‎‏‏‎‎‏‎‏‏‏‏‎‎‏‏‎‏‎‏‎‎‎‏‏‏‎‏‎‎‎‎‏‎‏‏‎‎‎‎‎‎‏‎‎‎‏‏‎‎‎‎‏‎Use on-screen keyboard‎‏‎‎‏‎"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‎‏‎‎‏‏‎‏‏‏‎‎‏‎‏‎‏‏‎‏‎‏‏‎‏‏‎‎‎‏‎‎‏‏‏‏‏‏‏‏‎‏‎‏‏‏‏‏‏‎‎‏‎‏‎‏‏‏‎Keep it on screen while physical keyboard is active‎‏‎‎‏‎"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‏‎‏‏‏‏‎‏‏‏‎‎‏‎‏‏‏‏‎‏‎‏‏‎‎‎‏‏‏‏‏‏‎‎‎‎‏‏‏‏‏‎‎‎‏‏‎‎‏‏‏‎‏‎‎‎‎‎‎Bounce keys‎‏‎‎‏‎"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‎‏‏‏‏‏‎‏‎‏‏‏‏‏‎‏‏‏‏‏‎‏‎‏‏‎‏‏‎‎‎‎‎‏‏‎‎‏‏‎‏‏‎‏‏‎‎‎‏‎‏‎‏‎‏‏‏‎‎The keyboard ignores quickly repeated presses of the same key within ‎‏‎‎‏‏‎<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g>‎‏‎‎‏‏‏‎ ms‎‏‎‎‏‎"</string>
     <string name="slow_keys" msgid="2891452895499690837">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‎‎‎‎‎‏‎‎‎‎‎‏‎‎‎‎‎‎‏‎‎‎‏‎‏‏‎‏‏‎‎‎‎‎‏‎‎‎‎‏‎‎‎‏‎‏‎‎‎‏‏‎‏‎‏‎‏‎‏‎Slow keys‎‏‎‎‏‎"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‏‎‎‎‏‏‎‎‎‎‏‏‎‏‎‏‏‏‎‎‎‎‏‏‏‏‎‎‏‎‎‏‏‎‏‏‎‏‏‏‏‏‏‎‏‏‎‏‏‎‎‏‏‎‏‏‏‏‎‎‎Adjusts the time it takes for a key press to activate to ‎‏‎‎‏‏‎<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g>‎‏‎‎‏‏‏‎ ms‎‏‎‎‏‎"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‎‏‏‎‎‎‏‏‎‎‎‏‎‏‎‏‎‏‎‎‎‏‎‏‎‏‎‏‏‎‎‎‏‎‎‎‎‏‎‎‎‎‏‏‏‎‎‏‎‎‎‏‎‏‎‎‏‏‎Sticky keys‎‏‎‎‏‎"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‏‎‎‏‏‎‎‏‏‎‏‎‏‎‎‏‎‏‏‏‏‎‏‏‎‏‎‏‏‎‎‏‏‏‎‎‎‎‎‏‏‎‏‎‎‏‎‎‎‎‎‏‏‎‏‎‏‏‏‏‎Press one key at a time for shortcuts instead of holding keys down together‎‏‎‎‏‎"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‎‎‏‏‎‏‏‎‏‏‏‎‏‏‎‏‏‏‎‏‎‎‎‎‎‎‎‏‏‏‏‏‎‎‏‎‏‏‎‎‎‎‏‎‎‎‏‎‎‏‎‎‏‎‏‎‎‎‎‎‎Keyboard shortcuts‎‏‎‎‏‎"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‎‏‎‏‏‏‏‏‎‏‏‎‏‏‏‏‎‏‎‏‎‎‎‏‏‎‏‎‏‎‎‏‏‏‏‎‎‏‏‏‎‎‎‏‎‏‏‎‏‎‎‏‏‏‎‎‎‏‏‎Show list of shortcuts‎‏‎‎‏‎"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‎‎‏‏‎‏‎‏‏‎‎‎‏‎‎‏‎‏‏‎‎‏‎‏‏‏‎‏‏‏‎‏‏‎‏‎‏‏‎‎‎‎‎‎‏‎‏‎‏‎‎‏‎‎‏‏‏‏‏‏‎Work profile keyboards &amp; tools‎‏‎‎‏‎"</string>
@@ -1936,7 +1932,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‏‏‏‏‏‎‏‎‎‏‏‎‎‎‏‎‎‏‏‏‎‎‎‎‎‏‎‎‏‏‏‏‏‎‎‏‎‎‎‎‎‎‎‏‎‎‏‏‎‎‏‎‎‎‎‏‏‎‎‏‎Reset‎‏‎‎‏‎"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‎‏‏‎‏‏‎‎‏‎‎‏‏‎‎‏‏‎‏‎‎‏‏‎‏‎‎‎‏‎‎‎‏‎‎‎‎‏‎‏‏‎‎‎‎‏‎‏‎‎‏‏‏‎‎‏‎‏‏‎Choose modifier key‎‏‎‎‏‎"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‏‎‏‎‎‏‎‎‎‎‏‎‏‏‎‏‏‏‎‏‏‏‎‏‏‏‎‏‏‎‎‎‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‎‏‎‎‎‏‎Choose a new key for ‎‏‎‎‏‏‎<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>‎‏‎‎‏‏‏‎:‎‏‎‎‏‎"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‏‎‎‏‏‎‏‎‎‏‏‎‎‏‎‎‎‎‏‎‏‎‏‎‎‏‏‎‎‎‏‎‏‎‏‏‎‎‏‎‎‎‎‏‎‎‎‎‏‎‎‎‎‎‎‎‎‎‎‎‎‏‎‎‏‏‎<xliff:g id="IME_LABEL">%s</xliff:g>‎‏‎‎‏‏‏‎ layout‎‏‎‎‏‎"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‎‎‎‏‎‎‏‏‎‏‏‏‎‎‎‎‏‏‏‏‏‏‎‎‏‏‎‏‏‎‎‏‏‎‎‏‏‎‎‏‎‎‎‏‏‏‎‏‏‏‎‏‎‏‎‏‎‎‏‎Default‎‏‎‎‏‎"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‏‏‎‏‏‎‏‎‎‎‏‎‎‎‎‎‎‏‎‏‏‎‎‎‎‏‏‎‎‏‎‎‎‏‏‎‏‎‏‎‏‏‎‏‎‎‎‏‎‎‎‏‎‎‎‎‎‎‏‎Automatic: ‎‏‎‎‏‏‎<xliff:g id="LAYOUT_LABEL">%s</xliff:g>‎‏‎‎‏‏‏‎‎‏‎‎‏‎"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‎‏‎‎‎‏‎‎‏‎‏‏‏‎‎‎‎‎‏‎‏‏‏‏‏‎‏‎‏‎‎‎‎‎‏‎‏‎‎‏‎‎‏‎‏‏‏‎‎‎‏‏‎‎‏‎‏‎‎‎User selected: ‎‏‎‎‏‏‎<xliff:g id="LAYOUT_LABEL">%s</xliff:g>‎‏‎‎‏‏‏‎‎‏‎‎‏‎"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‎‏‏‎‎‏‏‎‎‏‏‎‎‎‏‎‏‏‏‏‏‎‎‎‎‏‏‏‏‏‎‏‎‏‎‏‏‎‏‎‏‏‎‎‎‏‏‎‎‎‏‏‏‏‎‏‏‏‎‎Speech‎‏‎‎‏‎"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‏‎‏‎‏‎‏‏‎‏‎‏‎‎‏‎‎‎‎‏‎‏‎‎‎‏‏‏‎‏‏‏‎‏‎‏‎‏‏‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎‎‏‏‎‎Pointer speed‎‏‎‎‏‎"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‎‏‏‎‏‏‎‎‎‎‏‎‎‏‎‎‎‎‎‎‎‎‎‏‏‎‎‎‎‏‎‎‏‎‏‎‏‏‎‎‎‎‎‏‏‎‏‎‎‏‏‏‏‏‏‏‏‏‏‎‎Game Controller‎‏‎‎‏‎"</string>
@@ -1992,8 +1991,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‎‎‏‏‎‏‎‏‏‎‏‏‎‎‎‏‎‏‎‎‏‏‏‎‏‏‎‎‎‏‎‏‎‎‏‎‎‏‎‎‏‎‏‎‎‎‎‎‎‏‎‎‎‎‎‎‏‏‏‎You can customize this device to fit your needs. These accessibility features can be changed later in Settings.‎‏‎‎‏‎"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‎‎‎‏‎‎‎‏‎‎‏‏‏‎‏‎‎‏‏‏‎‎‏‎‎‏‎‎‏‎‎‏‏‎‎‏‏‎‎‎‎‎‎‎‎‏‎‏‎‏‎‎‏‏‎‎‏‏‏‏‎Change font size‎‏‎‎‏‎"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‎‎‎‏‏‎‏‏‎‎‏‎‎‎‎‏‏‎‎‎‎‎‎‏‏‎‎‎‎‏‏‏‏‏‏‏‏‎‏‏‏‏‎‎‎‎‏‎‏‏‏‏‏‎‏‏‎‏‏‎Screen reader‎‏‎‎‏‎"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‏‏‏‎‏‏‏‏‎‎‏‎‏‎‏‎‎‏‎‏‏‎‎‎‎‎‎‏‎‎‏‎‎‏‏‎‎‎‏‏‏‎‎‏‏‏‎‏‎‏‎‎‏‏‏‎‎‏‎‎‎Physical keyboard options‎‏‎‎‏‎"</string>
     <string name="captions_category_title" msgid="574490148949400274">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‏‏‏‏‏‏‏‏‏‎‎‎‏‏‏‏‏‏‏‏‏‎‏‏‏‏‏‏‎‎‏‎‎‏‏‏‎‎‎‏‎‏‏‏‎‎‎‏‏‎‏‎‏‏‎‏‎‎‏‎‎Captions‎‏‎‎‏‎"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‏‎‎‏‎‏‎‏‎‏‎‎‎‎‎‎‎‏‎‎‏‏‏‎‏‏‎‏‎‏‎‎‎‏‏‏‏‎‎‏‏‏‎‎‎‎‎‏‎‏‎‎‎‏‎‎‎‎‏‎‎Audio‎‏‎‎‏‎"</string>
     <string name="general_category_title" msgid="6298579528716834157">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‏‏‏‎‏‏‎‏‎‎‏‎‎‎‎‏‏‎‎‏‎‏‏‎‏‎‏‏‏‎‎‎‏‏‎‏‎‏‏‎‏‏‎‏‏‎‏‎‏‎‏‎‏‏‎‏‏‎‏‎General‎‏‎‎‏‎"</string>
@@ -2059,6 +2057,9 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‎‎‎‏‏‏‎‏‎‎‎‎‏‎‏‎‎‏‎‎‏‎‏‏‏‎‎‎‏‏‎‎‎‏‏‎‎‎‏‏‎‏‏‏‎‏‎‎‏‏‏‎‎‎‏‏‎‏‎‎Continue anyway‎‏‎‎‏‎"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‎‎‎‎‏‎‎‏‏‏‏‏‏‎‏‏‎‎‎‎‎‏‎‏‎‏‏‏‏‏‏‏‏‎‏‏‎‎‎‏‏‎‎‏‏‏‎‎‏‏‏‎‎‏‏‏‎‏‎Cancel‎‏‎‎‏‎"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‎‎‎‏‎‎‎‎‎‎‎‏‏‏‏‎‎‎‎‎‏‏‎‎‎‎‎‏‏‎‎‎‎‏‏‎‏‏‏‎‏‏‏‏‎‏‎‎‎‎‎‎‎‏‏‏‎‎‎‏‎Magnification settings‎‏‎‎‏‎"</string>
+    <string name="accessibility_magnification_one_finger_panning_title" msgid="4503949739883092989">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‏‏‎‏‎‎‎‎‎‎‏‎‎‏‏‏‏‏‎‎‏‏‎‏‏‎‎‏‏‏‎‏‎‏‏‏‏‏‏‎‎‎‏‏‏‎‏‏‎‏‏‏‏‏‏‏‏‎‏‎One-finger panning‎‏‎‎‏‎"</string>
+    <string name="accessibility_magnification_one_finger_panning_summary_on" msgid="9133125894310777539">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‏‏‎‏‎‏‏‏‏‏‏‎‏‏‎‎‎‎‏‏‎‎‏‏‏‎‎‏‎‎‎‏‎‏‏‎‏‎‏‎‎‎‎‏‏‎‏‎‎‏‎‏‏‎‎‎‎‏‏‎Move the magnification area by dragging one finger.‎‏‎‎‏‎"</string>
+    <string name="accessibility_magnification_one_finger_panning_summary_off" msgid="8979146350396559805">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‏‎‎‏‎‎‏‏‏‎‎‎‏‎‏‎‏‏‎‎‎‎‎‏‎‎‎‎‎‏‏‏‎‎‏‏‎‏‎‎‎‎‏‏‏‎‏‎‎‎‏‏‎‏‏‏‏‎‏‎Move the magnification area by dragging two fingers.‎‏‎‎‏‎"</string>
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‏‏‏‎‏‎‏‎‏‏‎‎‎‏‎‏‎‏‎‏‏‎‎‎‏‏‏‎‎‎‎‎‎‏‎‎‎‎‏‎‏‎‏‏‏‎‎‏‏‏‎‎‏‏‏‏‎‎‎‎‎Magnify with shortcut‎‏‎‎‏‎"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‏‏‏‏‏‏‏‎‎‏‏‏‏‏‎‎‏‎‎‏‎‎‎‏‏‏‏‏‏‎‏‎‎‎‏‏‎‎‎‏‏‎‎‏‎‏‎‎‏‎‏‏‏‏‏‎‏‏‏‎Magnify with shortcut &amp; triple-tap‎‏‎‎‏‎"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‎‏‎‏‎‎‏‏‏‎‎‎‎‎‎‏‏‎‎‏‎‏‏‏‏‏‎‏‎‎‎‏‎‏‏‎‎‏‎‏‏‏‎‎‎‏‏‏‎‎‎‏‏‏‏‏‏‎‎‎About ‎‏‎‎‏‏‎<xliff:g id="SERVICE">%1$s</xliff:g>‎‏‎‎‏‏‏‎‎‏‎‎‏‎"</string>
@@ -2243,12 +2244,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‎‎‏‏‎‎‎‏‎‏‏‎‎‏‎‏‎‏‎‎‏‎‎‎‏‏‎‎‎‎‎‎‎‏‏‏‏‏‎‏‎‏‏‎‎‏‏‎‎‏‎‏‎‏‎‎‏‏‎‎‎Hold volume keys‎‏‎‎‏‎"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‎‏‏‎‎‎‏‏‎‏‎‎‎‏‎‎‏‏‏‎‏‏‎‎‎‏‎‏‏‎‏‎‎‎‏‎‏‎‏‏‎‏‏‏‎‏‏‏‏‎‎‎‎‎‎‏‏‏‏‎Triple tap screen‎‏‎‎‏‎"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‏‏‎‎‏‎‏‏‏‏‎‎‏‏‎‎‏‏‎‎‏‏‎‎‏‏‎‎‏‎‎‏‏‏‏‎‎‎‎‏‎‎‎‎‎‎‏‎‏‏‏‏‏‎‏‏‎‏‏‎Edit accessibility shortcuts‎‏‎‎‏‎"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‎‎‏‎‏‏‎‎‏‎‏‏‏‎‏‎‏‏‏‎‏‏‎‎‎‎‏‎‏‏‎‎‏‏‏‏‏‏‎‎‎‎‏‎‎‏‎‎‎‎‎‎‏‏‏‎‏‎‏‎‎Choose your shortcut for %1$s‎‏‎‎‏‎"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‏‏‎‏‎‏‏‏‎‏‎‏‏‏‎‏‎‏‎‎‎‎‎‎‏‏‏‎‎‏‏‎‎‎‏‎‎‏‏‏‎‏‎‎‎‏‎‎‎‎‎‏‎‎‎‎‎‏‎‎Continue‎‏‎‎‏‎"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‎‎‎‏‏‎‎‎‏‎‎‏‎‏‎‎‎‏‏‏‎‏‏‎‏‏‏‎‏‏‎‏‏‎‎‎‏‏‎‎‏‏‎‎‎‏‎‎‎‏‏‎‏‏‏‏‏‏‏‎‎Hearing devices‎‏‎‎‏‎"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‏‏‎‎‏‏‎‎‏‎‏‏‏‎‏‎‎‏‎‏‏‏‎‏‏‏‎‏‏‏‎‏‏‏‏‎‏‎‏‏‎‏‎‎‎‏‎‏‏‎‏‏‏‎‏‎‎‏‎‏‎Set up and manage ASHA and LE Audio hearing aids, cochlear implants, and other amplification devices‎‏‎‎‏‎"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‏‏‎‎‏‏‏‎‎‏‎‎‏‎‎‏‏‎‏‎‎‏‏‏‎‏‏‏‎‏‎‏‎‎‎‎‏‎‎‎‏‎‏‎‏‏‎‎‏‎‏‎‏‏‎‎‎‏‎No hearing devices connected‎‏‎‎‏‎"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‏‏‎‏‏‏‎‏‏‏‎‏‎‏‎‏‏‎‎‎‎‎‏‎‎‏‎‏‏‎‎‎‎‏‎‏‏‏‎‏‎‏‏‎‏‏‎‏‎‎‏‎‏‏‎‎‏‏‏‏‎Add hearing aids‎‏‎‎‏‎"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‏‎‎‎‎‎‏‏‏‎‏‏‎‎‎‎‎‎‎‏‏‎‎‏‏‎‏‎‎‎‎‏‏‎‏‎‎‎‏‎‎‎‎‏‎‎‎‎Pair hearing aids‎‏‎‎‏‎"</string>
@@ -2266,8 +2265,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‏‏‎‎‎‏‎‎‏‎‎‎‎‏‎‎‎‎‎‏‎‎‎‏‏‏‎‏‎‎‎‎‏‏‎‏‏‏‏‏‏‎‏‎‏‏‏‎‏‏‏‏‏‏‎‎‎‏‎‎‎Hearing aid compatibility‎‏‎‎‏‎"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‏‎‎‎‎‎‏‎‎‏‎‏‏‎‏‏‎‏‎‎‏‎‏‏‏‎‏‏‎‏‎‎‎‎‏‏‏‎‏‏‎‎‎‏‎‎‎‏‎‏‏‏‏‎‎‎‏‎‏‏‎Improves compatibility with telecoils and reduces unwanted noise‎‏‎‎‏‎"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‏‎‏‎‏‏‎‏‎‎‎‏‎‏‏‏‏‎‎‎‏‏‎‏‎‎‏‏‎‏‎‎‏‎‏‏‎‎‎‎‎‎‎‎‏‎‎‎‏‎‏‎‏‏‏‏‎‏‎‎About hearing devices‎‏‎‎‏‎"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‎‏‏‏‎‎‎‏‏‎‏‏‎‏‏‎‏‏‎‎‎‏‎‏‎‎‏‏‏‏‎‏‏‏‏‏‏‏‎‏‎‎‏‎‎‏‏‏‏‎‏‎‎‎‏‎‎‏‎‎To find other hearing devices that aren’t supported by ASHA or LE Audio, tap ‎‏‎‎‏‏‎"<b>"‎‏‎‎‏‏‏‎Pair new device‎‏‎‎‏‏‎"</b>"‎‏‎‎‏‏‏‎ &gt; ‎‏‎‎‏‏‎"<b>"‎‏‎‎‏‏‏‎See more devices‎‏‎‎‏‏‎"</b>"‎‏‎‎‏‏‏‎‎‏‎‎‏‎"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‏‎‏‏‏‎‏‏‎‏‏‏‏‎‎‎‏‎‎‎‏‎‎‎‎‏‏‏‎‎‎‎‏‎‏‎‏‎‏‏‎‎‎‏‎‏‎‏‏‎‏‏‏‏‏‏‎‏‏‏‎Pair hearing device‎‏‎‎‏‎"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‎‎‏‎‏‏‏‎‎‏‏‏‏‎‏‏‏‏‏‎‎‏‏‎‏‎‏‏‎‏‏‎‏‏‏‏‎‏‎‎‏‏‎‏‏‏‎‏‏‏‎‎‏‏‏‎‏‎‏‎You can pair ASHA and LE Audio hearing devices on this page. Make sure your hearing device is turned on and ready to pair.‎‏‎‎‏‎"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‏‎‎‎‏‏‎‏‏‎‎‎‏‎‎‎‎‏‏‎‏‏‎‏‎‎‎‏‎‎‏‏‎‏‎‎‎‏‏‎‎‏‏‏‎‎‏‎‎‎‏‏‎‏‏‏‏‎‎‏‎Available hearing devices‎‏‎‎‏‎"</string>
@@ -4639,6 +4637,9 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‎‎‎‏‏‏‎‏‏‏‏‎‎‏‏‎‏‎‏‎‏‏‎‏‏‏‎‏‎‏‏‎‏‏‎‏‏‎‎‏‎‎‎‏‎‏‎‏‎‎‏‏‎‎‎‏‎‏‎‏‎Texts‎‏‎‎‏‎"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‎‎‎‏‏‎‎‏‎‎‎‎‎‎‎‎‏‏‏‏‏‏‎‏‏‎‎‏‏‏‎‎‎‎‏‎‎‎‎‏‎‏‎‏‏‏‎‏‏‏‏‎‏‏‏‏‎‎‎‎‎Automatic data switching‎‏‎‎‏‎"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‎‏‏‎‎‏‎‏‏‏‏‏‏‎‏‏‎‎‏‎‏‏‎‏‏‎‎‏‎‎‎‏‎‎‏‎‏‎‎‎‏‏‎‎‏‎‏‏‎‎‏‏‏‎‏‏‎‎‏‏‎Use data from either SIM depending on coverage and availability‎‏‎‎‏‎"</string>
+    <string name="sim_action_restart_dialog_title" msgid="3507413479633430120">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‎‎‎‎‏‎‏‎‏‏‎‎‏‏‎‏‎‏‎‏‏‏‏‏‏‎‏‎‎‎‎‎‎‏‎‏‏‏‏‏‎‏‏‏‏‎‏‎‎‏‏‎‎‏‏‎‏‎‎‎‎Restart to use 2 SIMs‎‏‎‎‏‎"</string>
+    <string name="sim_action_restart_dialog_msg" msgid="4737611046767629774">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‎‎‎‏‏‎‏‏‏‏‏‏‎‏‏‎‎‎‎‎‎‎‏‎‎‏‎‏‎‏‏‎‎‏‏‎‏‎‎‎‏‏‎‏‎‎‎‏‎‏‎‏‏‏‎‎‏‏‏‎‎To use 2 SIMs at once, restart your device, then turn on both SIMs‎‏‎‎‏‎"</string>
+    <string name="sim_action_restart_dialog_cancel" msgid="665560106686565624">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‎‏‎‎‏‎‎‏‏‏‏‎‎‏‎‎‎‏‎‏‏‎‏‏‎‎‏‎‎‎‎‎‎‎‏‏‏‏‎‏‏‏‎‎‏‎‏‎‎‏‏‎‎‏‏‏‏‏‎‎‎‎Use ‎‏‎‎‏‏‎<xliff:g id="CARRIER_NAME">%1$s</xliff:g>‎‏‎‎‏‏‏‎ only‎‏‎‎‏‎"</string>
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‎‎‎‏‎‎‏‏‏‎‎‎‎‏‏‏‏‏‎‏‏‏‎‏‏‏‏‏‎‎‎‎‏‏‏‎‎‎‎‏‏‎‎‏‎‏‎‏‎‏‎‎‏‏‎‏‏‏‏‎‎Data only‎‏‎‎‏‎"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‏‏‏‏‏‏‎‎‏‏‎‏‏‎‎‎‎‎‎‎‎‏‏‏‏‎‎‎‎‏‎‏‏‎‎‏‎‏‎‏‏‎‎‎‎‏‏‎‏‎‎‎‏‎‏‎‏‏‏‏‎Set up‎‏‎‎‏‎"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‏‏‎‎‏‎‎‎‎‎‏‏‎‏‎‏‏‏‏‏‏‎‏‏‎‏‎‎‏‏‎‏‏‎‎‏‎‏‏‏‎‎‎‎‏‏‏‏‏‏‎‎‏‎‎‎‏‏‎‏‏‎Next‎‏‎‎‏‎"</string>
@@ -4917,12 +4918,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‎‏‎‏‎‏‎‏‎‏‎‏‎‎‎‎‎‎‎‎‏‏‎‎‎‏‏‎‎‎‎‎‏‎‎‏‏‎‏‎‎‏‏‎‏‎‏‏‎‎‎‎‏‎‎‎‎‏‏‎‎‎Helps identify the relative position of nearby devices that have UWB‎‏‎‎‏‎"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‎‏‏‎‎‏‎‎‏‏‏‎‎‎‏‎‎‎‏‎‎‏‏‏‎‎‏‎‎‏‏‎‎‏‏‏‎‏‏‏‏‎‎‎‏‏‏‏‏‏‏‎‎‎‏‏‎‎‏‎‏‎‎‎Turn off airplane mode to use UWB‎‏‎‎‏‎"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‎‎‎‎‎‎‎‏‎‏‏‏‏‏‎‎‎‏‏‎‎‏‎‎‎‎‏‎‏‎‏‏‏‏‎‎‏‎‎‎‎‏‏‎‏‏‎‏‎‎‏‎‎‎‏‎‎‏‎‎‎UWB is unavailable in the current location‎‏‎‎‏‎"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‎‏‏‏‎‏‎‎‏‏‏‎‏‎‏‎‎‎‏‏‎‎‏‎‏‏‏‏‎‎‎‎‎‏‏‎‎‏‏‎‏‏‎‎‎‏‎‏‏‏‏‎‎‎‏‎‎‎‏‎‏‎‎‎Thread‎‏‎‎‏‎"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‏‏‏‏‏‏‏‎‏‏‏‎‏‏‎‎‎‏‎‎‎‎‏‎‎‏‏‎‎‎‏‏‎‎‏‏‏‎‏‎‏‎‏‎‎‏‏‏‏‎‎‎‎‏‏‏‎‎‏‏‎Connect to compatible devices using Thread for a seamless smart home experience‎‏‎‎‏‎"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‎‎‏‎‎‎‎‎‎‎‏‎‏‎‏‎‎‏‏‏‎‎‏‎‏‎‎‏‎‏‎‏‏‎‏‏‎‎‏‏‏‏‏‏‏‏‎‎‏‏‎‎‎‎‎‎‎‎‎‏‏‎Turn off airplane mode to use Thread‎‏‎‎‏‎"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‏‏‏‏‎‎‎‎‏‏‏‏‏‎‎‏‎‎‎‏‎‎‏‎‏‏‏‎‏‎‏‎‏‎‎‏‏‏‏‎‏‏‎‎‏‎‏‏‎‏‎‎‏‎‏‏‎‎‎‎‎‎‎Camera access‎‏‎‎‏‎"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‎‏‎‏‏‏‎‏‎‏‏‎‏‏‏‏‏‏‏‎‎‎‎‏‏‏‎‎‏‏‏‎‏‎‎‎‎‎‏‎‏‏‏‎‏‏‎‎‎‎‏‎‏‎‎‎‎‎‎‏‏‎Microphone access‎‏‎‎‏‎"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"‎‏‎‎‎‎‎‏‎‏‏‏‎‎‎‎‎‎‏‎‎‏‎‎‎‏‎‏‏‏‏‏‏‏‎‎‏‏‏‏‏‏‎‏‏‏‎‎‏‎‎‎‏‏‎‏‎‎‎‏‏‏‎‏‏‎‎‎‎‎‏‏‎‎‏‏‎‎‏‎‎‎‎‏‏‏‎‏‏‏‏‎‏‏‏‎‎For apps and services‎‏‎‎‏‎"</string>
diff --git a/res/values-es-rUS/arrays.xml b/res/values-es-rUS/arrays.xml
index a52af72..4bc3c80 100644
--- a/res/values-es-rUS/arrays.xml
+++ b/res/values-es-rUS/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tratar como red de uso medido"</item>
     <item msgid="2047166446768045816">"Tratar como red de uso no medido"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Usar MAC aleatoria (pred.)"</item>
-    <item msgid="741680937828608749">"Usar MAC del dispositivo"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"No"</item>
     <item msgid="2163015208097377388">"Sí"</item>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index 63bda37..e829796 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -596,7 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configurando espacio privado…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Las notificaciones de las apps en el espacio privado se ocultan cuando está bloqueado"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Explora los parámetros de configuración del espacio privado para ocultar el espacio privado y configurar el bloqueo automático"</string>
-    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Algunas apps requeridas podrían ya estar instaladas en el espacio privado"</string>
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Las apps requeridas ya están instaladas en tu espacio privado"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"No se pudo configurar el espacio privado"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Reintentar"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"¿Desbloquear espacio privado con bloq. de pant.?"</string>
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Tu operador no permite que te conectes a esta red porque usa un protocolo de seguridad antiguo que es menos seguro"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permitir WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Cerrar"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"¿Quieres desconectarte de <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Te conectaste a una red WEP. Si bloqueas estas redes, te desconectarás."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opciones avanzadas"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista desplegable \"Opciones avanzadas\""</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expandir"</string>
@@ -1542,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"¿Deseas usar <xliff:g id="NEW_APP">%s</xliff:g> para administrar tus conexiones de red?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitudes de ubicaciones recientes"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ubicación de perfil de trabajo"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Permisos de ubicación de apps"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"La ubicación está desactivada"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# de {total} apps tiene acceso a la ubicación}other{# de {total} apps tienen acceso a la ubicación}}"</string>
@@ -1875,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Usar teclado en pantalla"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Mientras el teclado físico está activo"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Rechazo de teclas"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"El teclado ignora las presiones de la misma tecla repetidas con rapidez dentro de los <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Teclas lentas"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajusta el tiempo que lleva activar la presión de una tecla a <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Teclas especiales"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Presiona una tecla a la vez para hacer la combinación de teclas en lugar de presionarlas juntas"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Combinaciones de teclas"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostrar lista de combinación de teclas"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclados y herramientas del perfil de trabajo"</string>
@@ -1936,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Restablecer"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Elegir tecla modificadora"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Elige una nueva tecla para <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Predeterminadas"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Voz"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Velocidad del puntero"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Controlador de juegos"</string>
@@ -1992,8 +1995,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Personaliza este dispositivo para adaptarlo a tus necesidades. Puedes modificar las funciones de accesibilidad más tarde en Configuración."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Cambiar tamaño de fuente"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Lector de pantalla"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opciones del teclado físico"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtítulos"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"General"</string>
@@ -2004,11 +2006,11 @@
     <string name="color_contrast_note" msgid="7592686603372566198">"Es posible que algunas apps no admitan todos los parámetros de contraste de texto y colores"</string>
     <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Modifica cómo se ven los colores y el texto en contraste con el color del fondo de pantalla"</string>
     <string name="color_contrast_preview" msgid="6791430227535363883">"Vista previa"</string>
-    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen y Adam"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helena, Adán"</string>
     <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Hace 2 días"</string>
-    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"¿Hacer seguim.?"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"¿Seguimiento?"</string>
     <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Informe del viaje de negocios"</string>
-    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Si necesitas ayuda adicional, comunícate\nconmigo o Helen. Este informe"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Si necesitas ayuda adicional, comunícate\nconmigo o Helena. Este informe"</string>
     <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Gastos del cliente"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Oscurecer la pantalla"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Controles de interacción"</string>
@@ -2059,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuar de todos modos"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancelar"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Configuración de ampliación"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ampliar con gesto"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ampliar con acceso directo y presionar tres veces"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Información sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2243,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mantén presionadas las teclas de volumen"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Presionar tres veces la pantalla"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Editar combinaciones de accesibilidad"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Elige tu combinación de teclas para %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Dispositivos auditivos"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configura y gestiona audífonos ASHA y LE Audio, implantes cocleares y otros dispositivos de amplificación de sonido"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"No hay dispositivos auditivos conectados"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Agregar audífonos"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Vincula los audífonos"</string>
@@ -2266,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilidad con audífonos"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Mejora la compatibilidad con el acoplamiento inductivo y reduce el ruido no deseado"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Información sobre disp. auditivos"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Para encontrar otros dispositivos auditivos que no son compatibles con ASHA o LE Audio, presiona "<b>"Vincular nuevo disp."</b>" &gt; "<b>"Ver más dispositivos"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Vincular dispos. auditivo"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Puedes vincular los dispositivos auditivos ASHA y LE Audio en esta página. Asegúrate de que los dispositivos auditivos estén encendidos y listos para la vinculación."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dispositivos disponibles"</string>
@@ -4639,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mensajes de texto"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Cambio de datos automático"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Usa datos de cualquier SIM según la cobertura y la disponibilidad"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Solo datos"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configuración"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Siguiente"</string>
@@ -4917,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Ayuda a identificar la posición relativa de dispositivos cercanos que cuentan con UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desactiva el modo de avión para usar UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB no está disponible en la ubicación actual"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Conéctate a dispositivos compatibles usando Thread para obtener una experiencia fluida de casa inteligente"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desactiva el modo de avión para usar Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Acceso a la cámara"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Acceso al micrófono"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Para apps y servicios"</string>
diff --git a/res/values-es/arrays.xml b/res/values-es/arrays.xml
index 703bb51..2fd55e0 100644
--- a/res/values-es/arrays.xml
+++ b/res/values-es/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tratar como red de uso medido"</item>
     <item msgid="2047166446768045816">"Tratar como red de uso no medido"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Usar MAC aleatoria (predeterminado)"</item>
-    <item msgid="741680937828608749">"Usar MAC del dispositivo"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"No"</item>
     <item msgid="2163015208097377388">"Sí"</item>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 1ef2f48..e87950c 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Emparejar derecho"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Emparejar izquierdo"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Para todos los audífonos disponibles"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Más ajustes de audífonos"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Cambia los ajustes multidispositivo, como los controles de combinación de teclas y telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Para este dispositivo"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Salida de audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Acerca de la salida de audio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configurando espacio privado…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Las notificaciones de las aplicaciones del espacio privado se ocultan si está bloqueado"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Consulta los ajustes del espacio privado para ocultarlo y definir un bloqueo automático"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Las aplicaciones requeridas ya están instaladas en tu espacio privado"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"No se ha podido crear el espacio privado"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Reintentar"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"¿Usar bloqueo de pantalla para desbloquear espacio?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplicaciones y notificaciones"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notificaciones sensibles en la pantalla de bloqueo"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Se muestra contenido sensible cuando el espacio privado está desbloqueado"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Crea una cuenta de Google para proteger la privacidad de tus datos"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"En la siguiente pantalla, podrás iniciar sesión en una cuenta para usarla con tu espacio privado"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Crea una cuenta específica para evitar que aparezcan datos fuera del espacio privado, como:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Fotos, archivos, correos, contactos, eventos del calendario y otros datos sincronizados"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historial de descarga de aplicaciones y recomendaciones"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historial de navegación, marcadores y contraseñas guardadas"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Contenido sugerido relacionado con tu actividad en las aplicaciones del espacio privado"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Entendido"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Puedes añadir hasta <xliff:g id="COUNT">%d</xliff:g> huellas digitales"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Has añadido el número máximo de huellas digitales"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"No se pueden añadir más huellas digitales"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Tu operador no te permite conectarte a esta red porque usa un protocolo de seguridad antiguo que es menos seguro"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permitir WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Cerrar"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"¿Desconectar de <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Te has conectado a una red WEP. Si bloqueas estas redes, perderás la conexión."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opciones avanzadas"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista desplegable de opciones avanzadas"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"mostrar"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"¿Usar <xliff:g id="NEW_APP">%s</xliff:g> para administrar tus conexiones de red?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitudes de ubicación recientes"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ubicación para el perfil de trabajo"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Permisos de ubicación de aplicaciones"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"La ubicación está desactivada"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# de {total} aplicaciones tiene acceso a la ubicación}other{# de {total} aplicaciones tienen acceso a la ubicación}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Usar teclado en pantalla"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Mantenlo en pantalla mientras el teclado físico está activo"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Teclas de rebote"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"El teclado ignora las pulsaciones repetidas de la misma tecla que se hayan hecho en <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Teclas lentas"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajusta el tiempo que se tarda en activar una pulsación de tecla a <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Teclas persistentes"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Pulsa una tecla para cada acceso directo en lugar de mantener pulsadas todas las teclas a la vez"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Combinaciones de teclas"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Muestra lista de combinaciones de teclas"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Perfiles de trabajo y herramientas"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Restablecer"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Elige una tecla modificadora"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Elige una nueva tecla para <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Predeterminado"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Voz"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Velocidad del puntero del ratón"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Mandos de videojuegos"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Puedes personalizar este dispositivo para adaptarlo a tus necesidades. Estas funciones de accesibilidad se pueden cambiar más tarde en Ajustes."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Cambiar tamaño de la fuente"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Lector de pantalla"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opciones de teclado físico"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtítulos"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"General"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Visualización"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Color y movimiento"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contraste de color"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Un mayor contraste hace que el texto, los botones e iconos destaquen más. Elige el contraste que más te guste."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Puede que algunas aplicaciones no admitan todos los ajustes de contraste de color y texto"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ajusta el aspecto de los colores y el texto con respecto al color del fondo de pantalla"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Previsualizar"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Hace 2 días"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"¿Seguir?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Informe del viaje de negocios"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Para recibir más ayuda, ponte en contacto \nconmigo o con Helen. Este informe"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Gastos del cliente"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Oscurecer pantalla"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Controles de interacción"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Controles de tiempo"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuar de todos modos"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancelar"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Ajustes de ampliación"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ampliación con acceso directo"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Amplía con un acceso directo y tres toques"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Información de <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"No transparente"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texto de alto contraste"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Cambia el color del texto a blanco o negro para maximizar el contraste con el fondo"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximizar el contraste del texto"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Cambia el color del texto a blanco o negro para aumentar el contraste con el fondo."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Actualizar ampliación automáticamente"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Actualizar ampliación de la pantalla al cambiar aplicaciones"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Colgar con botón de encendido"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mantener teclas de volumen"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tocar tres veces la pantalla"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Editar accesos directos de accesibilidad"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Elige el acceso directo para %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Audífonos"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configura y gestiona audífonos ASHA y LE Audio, implantes cocleares y otros dispositivos de amplificación de sonido"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"No hay audífonos conectados"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Añadir audífonos"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Emparejar audífonos"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilidad con audífonos"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Mejora la compatibilidad con las telebobinas y reduce el ruido no deseado"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Acerca de los audífonos"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Para buscar otros audífonos que no sean compatibles con ASHA o LE Audio, toca "<b>"Emparejar uno nuevo"</b>" &gt; "<b>"Ver más dispositivos"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Emparejar audífono"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"En esta página puedes emparejar audífonos ASHA y LE Audio. Comprueba que tu audífono está encendido y listo para emparejarse."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Audífonos disponibles"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mensajes de texto"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Cambio automático de datos"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Usa los datos de cualquiera de las dos SIMs en función de la cobertura y la disponibilidad"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Solo datos"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configurar"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Siguiente"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Ayuda a determinar la posición relativa de los dispositivos cercanos que usan UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desactiva el modo Avión para usar UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB no está disponible en esta ubicación"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Conéctate a dispositivos compatibles mediante Thread para conseguir una experiencia fluida de hogar inteligente"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desactiva el modo Avión para usar Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Acceso a la cámara"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Acceso al micrófono"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Para aplicaciones y servicios"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Cancelar"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contraste"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Estándar"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Predeterminado"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Medio"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Alto"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Esta aplicación solo puede abrirse en una ventana"</string>
diff --git a/res/values-et/arrays.xml b/res/values-et/arrays.xml
index 6ae2cb1..27496e9 100644
--- a/res/values-et/arrays.xml
+++ b/res/values-et/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Käsitle mahupõhisena"</item>
     <item msgid="2047166446768045816">"Käsitle mittemahupõhisena"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Kasuta juhuslikustatud MAC-aadr. (vaikeseade)"</item>
-    <item msgid="741680937828608749">"Kasuta seadme MAC-aadressi"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ei"</item>
     <item msgid="2163015208097377388">"Jah"</item>
diff --git a/res/values-et/strings.xml b/res/values-et/strings.xml
index 6131d97..09f3d0a 100644
--- a/res/values-et/strings.xml
+++ b/res/values-et/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Seo parempoolne"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Seo vasakpoolne"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Kõigi saadaolevate kuuldeseadmete jaoks"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Rohkem kuuldeseadme seadeid"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Muutke seadmeüleseid seadeid, nagu otseteed ja telecoili juhtelemendid"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Selle seadme jaoks"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Heliväljund"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Teave heliväljundi kohta"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Privaatse ruumi seadistamine …"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Kui privaatne ruum on lukustatud, siis on privaatse ruumi rakenduste märguanded peidetud"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Uurige privaatse ruumi seadeid, et privaatne ruum peita ja seadistada automaatne lukustamine"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Nõutavad rakendused on teie privaatsesse ruumi juba installitud"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Privaatset ruumi ei saanud seadistada"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Proovi uuesti"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Kas kasutada privaatse ruumi avamiseks ekraanilukku?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Rakendused ja märguanded"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Tundlikud märguanded lukustuskuval"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Kuva tundlik sisu, kui privaatne ruum on avatud"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"looge Google\'i konto, et oma andmed privaatsena hoida"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Järgmisel ekraanikuval saate sisse logida kontole, mida kasutada oma privaatse ruumiga"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Looge spetsiaalne konto, et aidata peatada andmete kuvamine väljaspool privaatset ruumi, näiteks:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sünkroonitud fotod, failid, meilid, kontaktid, kalendrisündmused ja muud andmed"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Rakenduse allalaadimiste ajalugu ja soovitused"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Sirvimisajalugu, järjehoidjad ja salvestatud paroolid"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Privaatse ruumi rakendustes teie tegevusega seotud soovitatud sisu"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Selge"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Saate lisada kuni <xliff:g id="COUNT">%d</xliff:g> sõrmejälge"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Olete lisanud maksimaalse arvu sõrmejälgi"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Rohkem sõrmejälgi ei saa lisada"</string>
@@ -824,7 +813,7 @@
     <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Kui Bluetooth on sisse lülitatud, saab seade suhelda teiste lähikonna Bluetooth-seadmetega"</string>
     <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"Kui Bluetooth on sees, saab seade suhelda teiste lähikonna Bluetooth-seadmetega Funktsioonid, nagu Kiirjagamine, Leia mu seade ja seadme asukoht, kasutavad Bluetoothi."</string>
     <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Kui Bluetooth on sisse lülitatud, saab teie seade suhelda teiste läheduses olevate Bluetooth-seadmetega.\n\nSeadme kasutuskogemuse täiustamiseks saavad rakendused ja teenused endiselt igal ajal otsida läheduses olevaid seadmeid isegi siis, kui Bluetooth on välja lülitatud. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Saate seda muuta Bluetoothi skannimise seadetes."</string>
-    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"Kui Bluetooth on sees, saab seade suhelda teiste lähikonna Bluetooth-seadmetega Funktsioonid, nagu Kiirjagamine, Leia mu seade ja seadme asukoht, kasutavad Bluetoothi.\n\nRakendused ja teenused saavadendiselt igal ajal otsida läheduses olevaid seadmeid isegi siis, kui Bluetooth on välja lülitatud. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Saate seda muuta Bluetoothi skannimise seadetes."</string>
+    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"Kui Bluetooth on sees, saab seade suhelda teiste lähikonna Bluetooth-seadmetega Funktsioonid, nagu Kiirjagamine, Leia mu seade ja seadme asukoht, kasutavad Bluetoothi.\n\nRakendused ja teenused saavad endiselt igal ajal otsida läheduses olevaid seadmeid isegi siis, kui Bluetooth on välja lülitatud. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Saate seda muuta Bluetoothi skannimise seadetes."</string>
     <string name="bluetooth_scan_change" msgid="1744636222637390367">"Muutke"</string>
     <string name="device_details_title" msgid="1155622417516195481">"Seadme üksikasjad"</string>
     <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Klaviatuuriseaded"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Teie operaator ei luba teil selle võrguga ühendust luua, kuna see kasutab vanemat turvaprotokolli, mis on vähem turvaline"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Luba WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Sule"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Kas katkestada ühendus võrguga <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Olete ühendatud WEP-võrguga. Kui blokeerite need võrgud, katkestatakse teie ühendus."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Täpsemad valikud"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rippmenüü loend Täpsemad valikud"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"laienda"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Kas kasutada võrguühenduste haldamiseks rakendust <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Hiljutised asukohapäringud"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Tööprofiili asukohaluba"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Asukohale juurdepääsu load"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Asukoht on välja lülitatud"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# rakendusel {total}-st on asukohale juurdepääs}other{# rakendusel {total}-st on asukohale juurdepääs}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Kasuta ekraaniklaviatuuri"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Hoia seda ekraanil, kui füüsiline klaviatuur on aktiivne"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Ühekordse puudutusega klahvid"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Klaviatuur eirab <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms jooksul tehtud sama klahvi korduvaid vajutusi"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Aeglased klahvid"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Määrab klahvivajutuse aktiveerumiseks kuluva aja väärtusele <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Nakkeklahvid"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Otseteede puhul klahvide korraga allhoidmise asemel vajutage klahve ükshaaval"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klaviatuuri otseteed"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Kuva otseteede loend"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tööprofiili klaviatuurid ja tööriistad"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Lähtesta"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Muuteklahvi valimine"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Valige muuteklahvi <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> jaoks uus klahv:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Vaikeseade"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Kõne"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Kursori kiirus"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Mängukontroller"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Seadet saab kohandada vastavalt oma vajadustele. Neid juurdepääsetavuse funktsioone saab hiljem muuta menüüs Seaded."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Muutke fondi suurust"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekraanilugeja"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Füüsilise klaviatuuri valikud"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtiitrid"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Heli"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Üldine"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Ekraan"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Värvid ja liigutused"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Värvi kontrastsus"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Suurem kontrastsus muudab teksti, nupud ja ikoonid väljapaistvamaks. Valige kontrastsus, mis tundub teie jaoks kõige sobivam."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Mõni rakendus ei pruugi kõiki värvi ja teksti kontrastsuse seadeid toetada"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Kohandage, kuidas värvid ja tekst ekraani taustavärvil välja näevad"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Eelvaade"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 päeva tagasi"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Kas täpsustada?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Ärireisi aruanne"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Lisaabi saamiseks võtke ühendust \nminu või Heleniga. See aruanne"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Kliendi kulud"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekraanikuva muutmine tumedamaks"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktsiooni juhtnupud"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Ajastuse juhtelemendid"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Jätka ikkagi"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Tühista"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Suurendamisseaded"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Otsetee abil suurendamine"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Otsetee ja kolmikpuudutusega suurendamine"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Teave funktsiooni <xliff:g id="SERVICE">%1$s</xliff:g> kohta"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Läbipaistmatu"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Suure kontrastsusega tekst"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Muutke tekst mustaks või valgeks. Maksimeerib kontrasti taustaga."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Teksti kontrastsuse maksimeerimine"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Muutke tekst mustaks või valgeks, et kontrastsust taustaga suurendada."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ekraanisuurenduse värskendus"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ekraanisuurenduse kasutus rakenduste vahetamisel"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Toitenupp lõpetab kõne"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Helitugevuse klahvide allhoidmine"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Kolmikpuudutuse ekraanikuva"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Juurdepääsetavuse otseteede muutmine"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Valige funktsiooni %1$s jaoks otsetee"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Jätka"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Kuuldeseadmed"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Saate seadistada ja hallata ASHA ning LE Audio toega kuuldeaparaate, kõrvaimplantaate ja muid võimendusseadmeid"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ühtegi kuuldeseadet pole ühendatud"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Lisa kuuldeaparaate"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Kuuldeaparaatide sidumine"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Ühilduvus kuuldeaparaatidega"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Parandab ühilduvust induktiivsidestitega (telecoils) ja vähendab soovimatut müra"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Teave kuuldeseade kohta"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Muude kuuldeseadmete leidmiseks, mida ASHA või LE Audio ei toeta, puudutage valikuid "<b>"Uue seadme sidumine"</b>" &gt; "<b>"Kuva rohkem seadmeid"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Kuuldeseadme sidumine"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Saate ASHA ja LE Audio kuuldeseadmed siduda sellel lehel. Veenduge, et teie kuuldeseade oleks sisse lülitatud ja sidumiseks valmis."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Saadaval kuuldeseadmed"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Tekstsõnumid"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automaatne andmeside vahetamine"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Levialast ja saadavusest olenevalt kasutage mõlema SIM-i andmesidet"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Ainult andmeside"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Seadistamine"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Järgmine"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Aitab tuvastada läheduses olevate ülilairibaühendust kasutavate seadmete suhtelist asukohta"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Ülilairibaühenduse kasutamiseks lülitage lennukirežiim välja."</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB pole praeguses asukohas saadaval."</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Nutika kodu sujuva kasutuskogemuse jaoks kasutage ühilduvate seadmete ühendamiseks Threadi"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Threadi kasutamiseks lülitage lennukirežiim välja"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Juurdepääs kaamerale"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Juurdepääs mikrofonile"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Rakenduste ja teenuste jaoks"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Tühista"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrastsus"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Tavaline"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Vaikeseade"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Keskmine"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Kõrge"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Selle rakenduse saab avada ainult ühes aknas"</string>
diff --git a/res/values-eu/arrays.xml b/res/values-eu/arrays.xml
index cf4a036..b3df98f 100644
--- a/res/values-eu/arrays.xml
+++ b/res/values-eu/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tratatu sare neurtu gisa"</item>
     <item msgid="2047166446768045816">"Tratatu neurtu gabeko sare gisa"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Erabili ausazko MAC helbide bat (lehenetsia)"</item>
-    <item msgid="741680937828608749">"Erabili gailuaren MAC helbidea"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ez"</item>
     <item msgid="2163015208097377388">"Bai"</item>
diff --git a/res/values-eu/strings.xml b/res/values-eu/strings.xml
index d1f7270..3110f31 100644
--- a/res/values-eu/strings.xml
+++ b/res/values-eu/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Parekatu eskuineko audifonoa"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Parekatu ezkerreko audifonoa"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Entzumen-gailu erabilgarri guztietarako"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Entzumen-gailuen ezarpen gehiago"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Aldatu gailuarteko ezarpenak, hala nola lasterbideak eta teleharilak kontrolatzeko aukerak"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Gailu honetarako"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio-irteera"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Audio-irteerari buruz"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Eremu pribatua konfiguratzen…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Eremu pribatua blokeatuta badago, hango aplikazioen jakinarazpenak ezkutatzen dira"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Arakatu eremu pribatuko ezarpenak eremu pribatua ezkutatzeko eta blokeo automatikoa konfiguratzeko"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Beharrezko aplikazioak jada instalatuta daude eremu pribatuan"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Ezin izan da konfiguratu eremu pribatu bat"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Saiatu berriro"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Pantailaren blokeoa erabili nahi duzu eremu pribatua desblokeatzeko?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikazioak eta jakinarazpenak"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Kontuzko jakinarazpenak pantaila blokeatuan"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Erakutsi kontuzko edukia eremu pribatua desblokeatuta dagoenean"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Sortu Google-ko kontu bat datuak pribatu mantentzeko"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Hurrengo pantailan, eremu pribatuarekin erabili nahi duzun kontuan saioa hasi ahalko duzu"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Sortu beste kontu bat datuak ez daitezen agertu eremu pribatutik kanpo; adibidez, hauek:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinkronizatutako argazkiak, fitxategiak, mezu elektronikoak, kontaktuak, egutegiko gertaerak eta beste datuak"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Aplikazioen deskargen historia eta gomendioak"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Arakatze-historia, laster-markak eta gordetako pasahitzak"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Eremu pribatuko aplikazioetako jarduerekin lotuta iradokitako edukia"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Ados"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"<xliff:g id="COUNT">%d</xliff:g> hartz-marka gehi ditzakezu gehienez"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Iritsi zara onartzen den gehieneko hatz-marka kopurura"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Ezin duzu gehitu beste hatz-markarik"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Zure operadoreak ez dizu uzten sare honetara konektatzen, hain segurua ez den segurtasun-protokolo zaharrago bat erabiltzen duelako"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Eman WEP sareak erabiltzeko baimena"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Itxi"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> saretik deskonektatu nahi duzu?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP sare batera konektatuta zaude. Halako sareak blokeatzen badituzu, deskonektatu egingo zara."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Aukera aurreratuak"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Aukera aurreratuak dago hautatuta goitibeherako zerrendan"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"zabaldu"</string>
@@ -962,7 +949,7 @@
     <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"5,0 GHz-eko banda hobetsia"</string>
     <string name="wifi_ip_settings" msgid="6420498748726599133">"IParen ezarpenak"</string>
     <string name="wifi_privacy_settings" msgid="3283946009000725698">"Pribatutasuna"</string>
-    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"MAC"</string>
+    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"MACa"</string>
     <string name="wifi_privacy_device_name_settings" msgid="3699130177041345275">"Gailuaren izena"</string>
     <string name="wifi_privacy_send_device_name_toggle_title" msgid="1228107313152880073">"Bidali gailuaren izena"</string>
     <string name="wifi_privacy_send_device_name_toggle_summary" msgid="5995365836332817655">"Partekatu gailuaren izena sarearekin"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"<xliff:g id="NEW_APP">%s</xliff:g> erabili nahi duzu sareko konexioak kudeatzeko?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Azken kokapen-eskaerak"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Laneko profilaren kokapena"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Aplikazioen kokapen-baimenak"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Kokapena desaktibatuta dago"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{#/{total} aplikaziok kokapena atzi dezake}other{#/{total} aplikaziok kokapena atzi dezakete}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Erabili pantailako teklatua"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Erakutsi pantailan teklatu fisikoa aktibo dagoen bitartean"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Errebote-teklak"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Teklatuak ez ikusi egiten dio tekla bera <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms igaro baino lehen behin eta berriro sakatzen bada"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Tekla motelak"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Tekla-sakatze bat aktibatzeko denbora doitzen du, <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms-tara"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Tekla itsaskorrak"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Lasterbideetan, sakatu teklak banan-banan, guztiak aldi berean sakatu ordez"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Lasterbideak"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Erakutsi lasterbideen zerrenda"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Laneko profilaren teklatuak eta tresnak"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Berrezarri"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Aukeratu tekla aldatzailea"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Aukeratu <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> teklarako beste tekla bat:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Lehenetsia"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Hizketa"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Erakuslearen abiadura"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Bideo-jokoen kontrolagailua"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Doitu gailua zure beharretara. Ezarpenak atalean alda ditzakezu erabilerraztasun-eginbideak."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Aldatu letra-tamaina"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Pantaila-irakurgailua"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Teklatu fisikoaren aukerak"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Azpitituluak"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audioa"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Orokorrak"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Pantaila"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Koloreak eta mugimendua"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kolore-kontrastea"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Kontraste handiagoarekin, gehiago nabarmentzen dira testua, botoiak eta ikonoak. Aukeratu gehien gustatzen zaizun kontraste-maila."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Baliteke oraindik aplikazio batzuek ez onartzea kolore- eta testu-kontrasteen ezarpen guztiak"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Doitu koloreek eta testuak zure pantailaren atzeko planoaren aurrean duten itxura"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Aurrebista"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Duela 2 egun"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Jarraipena egin nahi duzu?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Laneko bidaiaren txostena"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Laguntza gehiago lortzeko, jarri \nnirekin edo Helenekin harremanetan. Txosten hau izango da:"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Bezeroaren gastuak"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ilundu pantaila"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interakzioa kontrolatzeko aukerak"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Denbora kontrolatzeko aukerak"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Egin aurrera, halere"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Utzi"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Luparen ezarpenak"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Handitu pantaila lasterbidearekin"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Handitu pantaila lasterbide eta hiru ukitutxorekin"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> aplikazioari buruz"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Gardentasunik gabe"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Kontraste handiko testua"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Aldatu testuaren kolorea beltzera edo zurira. Atzeko planoarekiko kontrastea handitzen du."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximizatu testuaren kontrastea"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Aldatu testuaren kolorea beltzera edo zurira atzeko planoarekiko kontrastea areagotzeko."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Eguneratu auto. pantaila-handiagotzea"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Eguneratu handiagotzea aplik. batetik bestera pasatzean."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Amaitu deiak etengailuarekin"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Eduki sakatuta bolumen-botoiak"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Sakatu pantaila hiru aldiz"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Editatu erabilerraztasun-lasterbideak"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Aukeratu %1$s atzitzeko lasterbidea"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Egin aurrera"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Entzumen-gailuak"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Konfiguratu eta kudeatu ASHA eta kontsumo txikiko audioa darabiltzaten audifonoak, kokleako inplanteak eta beste anplifikazio-gailu batzuk"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ez dago entzumen-gailurik konektatuta"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Gehitu audifonoak"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Parekatu audifonoak"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Audifonoekiko bateragarritasuna"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Teleharilarekiko bateragarritasuna hobetzen du, eta nahi ez den zarata murrizten"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Entzumen-gailuei buruz"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHArekin edo kontsumo txikiko audioarekin bateragarriak ez diren beste entzumen-gailu batzuk aurkitzeko, sakatu "<b>"Parekatu gailu bat"</b>" &gt; "<b>"Ikusi gailu gehiago"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Parekatu entzumen-gailu bat"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Orri honetan, ASHA eta kontsumo txikiko audioa darabilten entzumen-gailuak pareka ditzakezu. Ziurtatu entzumen-gailua aktibatuta eta parekatzeko prest dagoela."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Entzumen-gailu erabilgarriak"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Testu-mezuak"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Datuak automatikoki aldatzea"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Erabili SIMetako baten datuak, estalduraren eta erabilgarritasunaren arabera"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Datuak soilik"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Konfiguratu"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Hurrengoa"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Banda ultrazabala darabilten inguruko gailuen arteko distantzia erlatiboa zehazten laguntzen du"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desaktibatu hegaldi modua banda ultrazabala erabiltzeko"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Banda ultrazabala ez dago erabilgarri kokapen honetan"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Konektatu gailu bateragarriekin Thread erabilita, etxe domotikoa arazorik gabe erabiltzeko"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desaktibatu hegaldi modua Thread erabiltzeko"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kamera erabiltzeko baimena"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofonoa erabiltzeko baimena"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Aplikazio eta zerbitzuetarako"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Utzi"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrastea"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Arrunta"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Lehenetsia"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Tartekoa"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Altua"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Leiho bakar batean ireki daiteke aplikazioa"</string>
diff --git a/res/values-fa/arrays.xml b/res/values-fa/arrays.xml
index 313dba4..6a31eba 100644
--- a/res/values-fa/arrays.xml
+++ b/res/values-fa/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"محدودشده حساب شود"</item>
     <item msgid="2047166446768045816">"محدودنشده حساب شود"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"‏استفاده از MAC تصادفی (پیش‌فرض)"</item>
-    <item msgid="741680937828608749">"‏استفاده از MAC دستگاه"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"نه"</item>
     <item msgid="2163015208097377388">"بله"</item>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index 63533b1..441f28d 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"جفت کردن گوش راست"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"جفت کردن گوش چپ"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"برای همه دستگاه‌های شنیداری (سمعک) دردسترس"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"تنظیمات بیشتر دستگاه کمک‌شنوایی"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"تنظیمات بین دستگاهی مانند کنترل‌های تله‌کویل و میان‌بر را تغییر دهید"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"برای این دستگاه"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"خروجی صوتی"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"درباره خروجی صوتی"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"درحال راه‌اندازی فضای خصوصی…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"اعلان‌های برنامه‌های فضای خصوصی هنگام قفل بودن فضا پنهان می‌شوند"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"برای پنهان کردن فضای خصوصی و تنظیم قفل خودکار، تنظیمات فضای خصوصی را کاوش کنید"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"برنامه‌های ضروری قبلاً در فضای خصوصی شما نصب شده‌اند"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"فضای خصوصی راه‌اندازی نشد"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"امتحان مجدد"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"از قفل صفحه برای باز کردن قفل فضای خصوصی استفاده شود؟"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"برنامه‌ها و اعلان‌ها"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"اعلان‌های حساس در صفحه قفل"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"وقتی قفل فضای خصوصی باز است، محتوای حساس نمایش داده می‌شود"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"‏برای کمک به خصوصی نگه داشتن داده‌هایتان، «حساب Google» ایجاد کنید"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"در صفحه بعدی می‌توانید وارد حساب شوید تا با آن از فضای خصوصی خود استفاده کنید"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"برای کمک به جلوگیری از نمایش داده‌ها در خارج از فضای خصوصی، حساب اختصاصی ایجاد کنید، برای مثال:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"عکس‌ها، فایل‌ها، ایمیل‌ها، مخاطبین، رویدادهای تقویم، و داده‌های دیگر همگام‌سازی شده است"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"تاریخچه بارگیری برنامه و توصیه‌ها"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"سابقه مرور، نشانک‌ها و گذرواژه‌های ذخیره‌شده"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"محتوای پیشنهادی مرتبط با فعالیتتان در برنامه‌های فضای خصوصی"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"متوجه‌ام"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"می‌توانید حداکثر <xliff:g id="COUNT">%d</xliff:g> اثرانگشت اضافه کنید"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"حداکثر تعداد اثرانگشت را اضافه کرده‌اید"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"نمی‌توانید اثرانگشت‌های بیشتری اضافه کنید"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"شرکت مخابراتی‌تان اجازه نمی‌دهد به این شبکه متصل شوید زیرا از پروتکل امنیتی قدیمی‌تری استفاده می‌کند که امنیت کمتری دارد"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"‏مجاز کردن WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"بستن"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"اتصال <xliff:g id="NAME">%1$s</xliff:g> قطع شود؟"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"‏به شبکه WEP متصل هستید. اگر این شبکه‌ها را مسدود کنید، اتصال شما قطع خواهد شد."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"گزینه‌های پیشرفته"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"گزینه‌های پیشرفتهٔ فهرست کرکره‌ای"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"بزرگ کردن"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"برای مدیریت ارتباطات شبکه‌تان از <xliff:g id="NEW_APP">%s</xliff:g> استفاده می‌کنید؟"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"درخواست‌های اخیر موقعیت مکانی"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"محل نمایه کارتان"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"اجازه‌های مکان برنامه"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"مکان خاموش است"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# برنامه از {total} برنامه به مکان دسترسی دارد}one{# برنامه از {total} برنامه به مکان دسترسی دارد}other{# برنامه از {total} برنامه به مکان دسترسی دارد}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"استفاده از صفحه‌کلید مجازی"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"وقتی صفحه‌کلید فیزیکی فعال است این ویرایشگر را روی صفحه نگه‌می‌دارد"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"کلیدهای واگشت"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"صفحه‌کلید فشردن‌های تکراری و سریع یک کلید در <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> میلی‌ثانیه را نادیده می‌گیرد"</string>
     <string name="slow_keys" msgid="2891452895499690837">"کلیدهای آهسته"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"فاصله زمانی بین فشردن کلید و فعال‌سازی آن را روی <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> میلی‌ثانیه تنظیم می‌کند"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"کلیدهای چسبان"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"به‌جای اینکه چند کلید را به‌طور هم‌زمان پایین نگه دارید، هربار یک کلید را برای میان‌برها فشار دهید"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"میان‌برهای صفحه‌کلید"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"نمایش فهرست میان‌برها"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"نمایه کاری صفحه‌کلیدها و ابزارها"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"بازنشانی"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"کلید توصیف‌گر را انتخاب کنید"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"کلید جدیدی برای <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> انتخاب کنید:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"پیش‌فرض"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"گفتار"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"سرعت اشاره‌گر"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"دسته کنترل بازی"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"می‌توانید این دستگاه را متناسب با نیازهایتان سفارشی کنید. می‌توانید بعداً در «تنظیمات»، این ویژگی‌های دسترس‌پذیری را تغییر دهید."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"تغییر اندازه قلم"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"صفحه‌خوان"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"گزینه‌های صفحه‌کلید فیزیکی"</string>
     <string name="captions_category_title" msgid="574490148949400274">"زیرنویس"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"صوتی"</string>
     <string name="general_category_title" msgid="6298579528716834157">"کلی"</string>
     <string name="display_category_title" msgid="6638191682294461408">"نمایشگر"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"رنگ و حرکت"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"کنتراست رنگ"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"کنتراست بیشتر باعث می‌شود متن، دکمه‌ها، و نمادها بیشتر برجسته شوند. کنتراستی را انتخاب کنید که به‌نظرتان بهترین است."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"ممکن است برخی‌از برنامه‌ها از همه تنظیمات کنتراست رنگ و متن پشتیبانی نکنند"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"رنگ‌ها و متن را در برابر رنگ پس‌زمینه صفحه‌نمایشتان تنظیم کنید"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"پیش‌نمایش"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"هلن و آدام"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"۲ روز پیش"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"پیگیری می‌کنید؟"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"گزارش سفر کاری"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"برای کمک بیشتر، لطفاً با \nمن یا هلن تماس بگیرید. این گزارش ایجاد خواهد شد"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"هزینه‌های کارخواه"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"تیره‌تر کردن صفحه"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"کنترل‌های تعامل"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"کنترل‌های زمان‌بندی"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"درهرصورت ادامه داده شود"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"لغو"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"تنظیمات درشت‌‌نمایی"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"درشت‌نمایی بااستفاده از میان‌بر"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"درشت‌نمایی بااستفاده از میان‌بر و سه ضربه"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"درباره <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"غیرشفاف"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"نوشتار با کنتراست بالا"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"رنگ نوشتار را به سیاه یا سفید تغییر می‌دهد. تضاد با پس‌زمینه را به‌حداکثر می‌رساند."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"بیشینه‌سازی کنتراست متن"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"برای افزایش کنتراست با پس‌زمینه، رنگ متن را به سیاه یا سفید تغییر دهید."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"به‌روزرسانی خودکار درشت‌‌نمایی صفحه"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"به‌روزرسانی درشت‌‌نمایی صفحه در انتقال‌های برنامه"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"قطع تماس با دکمه روشن/خاموش"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"کلیدهای میزان صدا را نگه‌دارید"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"سه ضربه روی صفحه بزنید"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ویرایش میان‌برهای دسترس‌پذیری"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"‏میان‌بر %1$s را انتخاب کنید"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ادامه"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"دستگاه‌های کمک‌شنوایی"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"راه‌اندازی و مدیریت سمعک‌های سازگار با «جاری‌سازی صوتی ویژه سمعک‌ها» و «صدای کم‌مصرف»، کاشت حلزون، و دیگر دستگاه‌های تقویت صدا"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"هیچ دستگاه کمک‌شنوایی‌ای متصل نشده است"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"افزودن سمعک‌ها"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"جفت کردن سمعک"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"سازگاری با سمعک"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"سازگاری با تله‌کویل را بهبود می‌بخشد و نوفه ناخواسته را کاهش می‌دهد"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"درباره دستگاه‌های کمک‌شنوایی"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"‏برای پیدا کردن دیگر سمعک‌هایی که از «جاری‌سازی صوتی ویژه سمعک‌ها» (ASHA) یا «صدای کم‌مصرف» (LE Audio) پشتیبانی نمی‌کنند، روی "<b>"جفت کردن دستگاه جدید"</b>" &gt; "<b>"دیدن دستگاه‌های بیشتر"</b>" ضربه بزنید"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"جفت کردن دستگاه کمک‌شنوایی"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"‏می‌توانید سمعک‌های سازگار با «جاری‌سازی صوتی ویژه سمعک‌ها» (ASHA) و «صدای کم‌مصرف» را در این صفحه جفت کنید. مطمئن شوید سمعک روشن و برای جفت کردن آماده باشد."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"دستگاه‌های کمک‌شنوایی موجود"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"پیامک‌ها"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"عوض کردن خودکار داده"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"بسته به پوشش و دردسترس بودن، از داده یکی از سیم‌کارت‌ها استفاده می‌شود"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"فقط داده"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"راه‌اندازی"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"بعدی"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"به شناسایی موقعیت نسبی دستگاه‌های اطراف دارای باند فوق‌وسیع کمک می‌کند"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"برای استفاده از باند فوق‌وسیع، «حالت هواپیما» را خاموش کنید"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"باند فوق‌وسیع در مکان کنونی دردسترس نیست"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"‏برای داشتن تجربه‌ای یکپارچه در خانه هوشمند، بااستفاده از Thread به دستگاه‌های سازگار متصل شوید"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"‏برای استفاده از Thread، «حالت هواپیما» را خاموش کنید"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"دسترسی به دوربین"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"دسترسی میکروفون"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"برای برنامه‌ها و سرویس‌ها"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"لغو"</string>
     <string name="contrast_title" msgid="6885768151336508075">"تضاد"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"استاندارد"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"پیش‌فرض"</string>
     <string name="contrast_medium" msgid="384414510709285811">"متوسط"</string>
     <string name="contrast_high" msgid="3988567609694797696">"بالا"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"این برنامه فقط در ۱ پنجره می‌تواند باز شود"</string>
diff --git a/res/values-fi/arrays.xml b/res/values-fi/arrays.xml
index e68580b..1ba84ee 100644
--- a/res/values-fi/arrays.xml
+++ b/res/values-fi/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Merkitse maksulliseksi"</item>
     <item msgid="2047166446768045816">"Merkitse maksuttomaksi"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Käytä satunnaistettua MACia (oletus)"</item>
-    <item msgid="741680937828608749">"Käytä laitteen MAC-osoitetta"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ei"</item>
     <item msgid="2163015208097377388">"Kyllä"</item>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 49e3deb..ea78779 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Liitä oikea korva"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Liitä vasen korva"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Kaikille saatavilla oleville kuulolaitteille"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Lisää kuulolaiteasetuksia"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Muuta laitteidenvälisiä asetuksia, kuten pikanäppäimiä ja induktiivisia ohjaimia"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Tälle laitteelle"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audion toistotapa"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Tietoa audion toistotavasta"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Yksityistä tilaa otetaan käyttöön…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Ilmoitukset yksityisen tilan sovelluksista ovat piilotettuina, kun se on lukittu"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Tutki yksityisen tilan asetuksia, joilla voit piilottaa tilan ja ottaa automaattisen lukituksen käyttöön"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Vaaditut sovellukset on jo asennettu yksityiseen tilaan"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Yksityisen tilan käyttöönotto epäonnistui"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Yritä uudelleen"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Käytetäänkö avaamiseen näytön lukitusta?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Sovellukset ja ilmoitukset"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Arkaluontoiset ilmoitukset lukitusnäytöllä"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Näytä arkaluontoinen sisältö, kun yksityisen tilan lukitus on avattuna"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Luo Google-tili, jotta voit pitää datasi yksityisenä"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Seuraavalla näytöllä voit kirjautua sisään tilille, jota voit käyttää yksityisessä tilassa"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Luo oma tili, jotta voit lopettaa datan näkymisen yksityisen tilan ulkopuolella, esimerkiksi:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Synkronoidut kuvat, tiedostot, sähköpostit, yhteystiedot, kalenteritapahtumat ja muu data"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Sovellusten lataushistoria ja suositukset"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Selaushistoria, kirjanmerkit ja tallennetut salasanat"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Toimintaasi perustuva ehdotettu sisältö yksityisen tilan sovelluksissa"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Voit lisätä korkeintaan <xliff:g id="COUNT">%d</xliff:g> sormenjälkeä"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Et voi lisätä useampia sormenjälkiä."</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Enempää sormenjälkiä ei voi lisätä."</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operaattori ei salli yhteyden muodostamista tähän verkkoon, koska se käyttää vanhempaa tietoturvaprotokollaa, joka on vähemmän turvallinen"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Salli WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Sulje"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Katkaistaanko yhteys (<xliff:g id="NAME">%1$s</xliff:g>)?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Laitteesi on yhteydessä WEP-verkkoon. Jos estät nämä verkot, yhteys katkeaa."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Lisäasetukset"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lisäasetusten avattava lista"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"laajenna"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Hallinnoidaanko verkkoyhteyksiä sovelluksella <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Viimeisimmät sijaintipyynnöt"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Työprofiilin sijainti"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Sovellusten sijaintiluvat"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Sijainti ei ole käytössä"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{#/{total} sovelluksella on pääsyoikeus sijaintiin}other{#/{total} sovelluksella on pääsyoikeus sijaintiin}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Käytä näyttönäppäimistöä"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Pidä näytöllä, kun fyysinen näppäimistö on aktiivinen"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Toistuvien painallusten ohitus"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Näppäimistö ei huomioi <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> millisekunnin sisällä toistettuja saman näppäimen painalluksia"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Hitaat näppäimet"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Muuta <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> millisekuntiin aika, jona näppäin aktivoituu painalluksesta"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Päälle jäävät näppäimet"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Käytä pikanäppäimiä painamalla yhtä näppäintä kerralla monen näppäimen sijaan"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Pikanäppäimet"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Näytä pikanäppäimet"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Työprofiilin näppäimistöt ja työkalut"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Nollaa"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Valitse muokkausnäppäin"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Valitse uusi näppäin (<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>):"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Oletus"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Puhe"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Osoittimen nopeus"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Peliohjaimet"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Voit muokata laitteen ominaisuuksia tarpeidesi mukaan. Saavutettavuusvalintoja voi muuttaa myöhemmin asetuksissa."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Muuta fonttikokoa"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Näytönlukuohjelma"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Fyysisen näppäimistön asetukset"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Tekstitykset"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Yleiset"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Näyttö"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Väri ja liike"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Värikontrasti"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Korkeampi kontrasti tekee tekstistä, painikkeita ja kuvakkeista näkyvämpiä. Valitse haluamasi kontrasti."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Jotkin sovellukset eivät välttämättä tue kaikkia väri‑ ja tekstikontrastin asetuksia"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Muuta värien ja tekstin näkyvyyttä puhelimen taustaväriä vasten"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Esikatselu"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helena, Aatu"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 päivää sitten"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Kysyttävää?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Yritysmatkan raportti"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Jos tarvitset lisäapua, ota yhteyttä \nminuun tai Helenaan. Tämän raportin aihe on"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Asiakkaan kulut"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Tummenna näyttöä"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Käytönhallinta"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Ajoitussäätimet"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Jatka silti"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Peru"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Suurennusasetukset"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Suurenna pikanäppäimellä"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Suurenna pikanäppäimellä ja kolmoisnapautuksella."</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Tietoja: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Läpinäkymätön"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Suurikontrastinen teksti"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Muuta tekstin väri mustaksi tai valkoiseksi. Maksimoi kontrastin taustan kanssa."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Korkein tekstikontrasti"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Muuta tekstin väri mustaksi tai valkoiseksi lisätäksesi kontrastia taustan kanssa."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Päivitä näytön suurennus automaatt."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Päivitä näytön suurennus sovellussiirtymissä"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Puhelun katkaisu virtapainikkeella"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Paina äänenvoimakkuuspainikkeita pitkään"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Kolmoisnapauta näyttöä"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Muokkaa saavutettavuuspikanäppäimiä"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Valitse pikanäppäin: %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Jatka"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Kuulolaitteet"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Ota käyttöön ja ylläpidä ASHA:n ja LE Audion kuulolaitteita, sisäkorvaimplantteja ja muita sisäkorvaimplantteja"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ei yhdistettyjä kuulolaitteita"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Lisää kuulolaitteita"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Liitä kuulolaitteet"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kuulolaiteyhteensopivuus"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Parantaa yhteensopivuutta induktiosilmukan kanssa ja vähentää ei-toivottuja ääniä"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Tietoa kuulolaitteista"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Jos haluat löytää muita kuulolaitteita, joita ASHA tai LE Audio ei tue, valitse "<b>"Muodosta uusi laitepari"</b>" ja "<b>"Näytä lisää laitteita"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Laiteparin muodostaminen"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Tällä sivulla voit muodostaa laitepareja ASHA- ja LE Audio ‑kuulolaitteista. Varmista, että kuulolaite on päällä ja valmis muodostamaan laiteparin."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Käytettävät kuulolaitteet"</string>
@@ -3823,7 +3804,7 @@
     <string name="filter_instant_apps" msgid="2292108467020380068">"Pikasovellukset"</string>
     <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Poistettu käytöstä"</string>
     <string name="advanced_apps" msgid="7643010673326578815">"Lisäasetukset"</string>
-    <string name="app_permissions" msgid="8666537659217653626">"Lupien ylläpito"</string>
+    <string name="app_permissions" msgid="8666537659217653626">"Lupienhallinta"</string>
     <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Sijainnin datan jakamisen päivitykset"</string>
     <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Tarkista sovellukset, jotka ovat muuttaneet tapaa, jolla ne voivat jakaa sijaintitietoja"</string>
     <string name="tap_to_wake" msgid="3313433536261440068">"Herätä napauttamalla"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Tekstiviestit"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automaattinen datan vaihto"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Käytä kumman tahansa SIMin dataa kattavuudesta ja saatavuudesta riippuen"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Vain data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Ota käyttöön"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Seuraava"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Auttaa tunnistamaan lähistöllä olevien UWB-laitteiden suhteellisen sijainnin"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Laita lentokonetila pois päältä, jotta voit käyttää UWB:tä"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB ei ole saatavilla nykyisessä sijainnissa"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Saat saumattoman käyttökokemuksen älykkäässä kodissa, kun yhdistät yhteensopivat laitteet käyttämällä Threadia"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Laita lentokonetila pois päältä, jotta voit käyttää Threadia"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Pääsy kameraan"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Pääsy mikrofoniin"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Sovellukset ja palvelut"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Peru"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrasti"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Tavallinen"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Oletus"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Keskitaso"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Suuri"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Tämän sovelluksen voi avata vain yhdessä ikkunassa"</string>
diff --git a/res/values-fr-feminine/strings.xml b/res/values-fr-feminine/strings.xml
new file mode 100644
index 0000000..d3f7c6a
--- /dev/null
+++ b/res/values-fr-feminine/strings.xml
@@ -0,0 +1,33 @@
+<?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:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Plus que # étape pour être développeuse.}one{Plus que # étapes pour être développeuse.}other{Plus que # étapes pour être développeuse.}}"</string>
+    <string name="show_dev_on" msgid="2840850085134853754">"Vous êtes désormais développeuse !"</string>
+    <string name="show_dev_already" msgid="7041756429707644630">"Inutile, vous êtes déjà développeuse."</string>
+    <string name="no_internet_access_text" msgid="3611993143350310936">"Ce réseau ne dispose d\'aucun accès à Internet. Rester connectée ?"</string>
+    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Vous n\'êtes pas autorisée à modifier la langue de l\'appareil."</string>
+    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Rediriger le vibreur vers la manette de jeu lorsque vous êtes connectée"</string>
+    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Cela limitera la consommation de données et l\'utilisation de la batterie, mais vous devrez synchroniser manuellement chaque compte pour récupérer les infos récentes. Et en cas de changement, vous n\'en serez pas avertie."</string>
+    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Vous êtes déjà connectée à un VPN permanent. Si vous vous connectez à un autre VPN, le VPN actuel sera remplacé et le mode permanent sera désactivé."</string>
+    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Vous êtes déjà connectée à un VPN. Si vous vous connectez à un autre VPN, le VPN actuel sera remplacé."</string>
+    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Sélectionnez un profil VPN auquel rester connectée en permanence. Le trafic réseau ne sera autorisé que lorsque vous serez connectée à ce VPN."</string>
+    <string name="guest_category_title" msgid="5562663588315329152">"Invitée (Vous)"</string>
+    <string name="users_summary" msgid="8473589474976307510">"Connectée en tant que \"<xliff:g id="USER_NAME">%1$s</xliff:g>\""</string>
+    <string name="zen_suggestion_summary" msgid="1984990920503217">"Suspendre les notifications pour rester concentrée"</string>
+    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Un appareil Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, souhaite accéder à vos contacts et à votre journal d\'appels. Ceci inclut des données concernant les appels entrants et sortants.\n\nVous ne vous êtes jamais connectée à <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> auparavant."</string>
+</resources>
diff --git a/res/values-fr-masculine/strings.xml b/res/values-fr-masculine/strings.xml
new file mode 100644
index 0000000..fc6e172
--- /dev/null
+++ b/res/values-fr-masculine/strings.xml
@@ -0,0 +1,33 @@
+<?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:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Plus que # étape pour être développeur.}one{Plus que # étapes pour être développeur.}other{Plus que # étapes pour être développeur.}}"</string>
+    <string name="show_dev_on" msgid="2840850085134853754">"Vous êtes désormais développeur !"</string>
+    <string name="show_dev_already" msgid="7041756429707644630">"Inutile, vous êtes déjà développeur."</string>
+    <string name="no_internet_access_text" msgid="3611993143350310936">"Ce réseau ne dispose d\'aucun accès à Internet. Rester connecté ?"</string>
+    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Vous n\'êtes pas autorisé à modifier la langue de l\'appareil."</string>
+    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Rediriger le vibreur vers la manette de jeu lorsque vous êtes connecté"</string>
+    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Cela limitera la consommation de données et l\'utilisation de la batterie, mais vous devrez synchroniser manuellement chaque compte pour récupérer les infos récentes. Et en cas de changement, vous n\'en serez pas averti."</string>
+    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Vous êtes déjà connecté à un VPN permanent. Si vous vous connectez à un autre VPN, le VPN actuel sera remplacé et le mode permanent sera désactivé."</string>
+    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Vous êtes déjà connecté à un VPN. Si vous vous connectez à un autre VPN, le VPN actuel sera remplacé."</string>
+    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Sélectionnez un profil VPN auquel rester connecté en permanence. Le trafic réseau ne sera autorisé que lorsque vous serez connecté à ce VPN."</string>
+    <string name="guest_category_title" msgid="5562663588315329152">"Invité (Vous)"</string>
+    <string name="users_summary" msgid="8473589474976307510">"Connecté en tant que \"<xliff:g id="USER_NAME">%1$s</xliff:g>\""</string>
+    <string name="zen_suggestion_summary" msgid="1984990920503217">"Suspendre les notifications pour rester concentré"</string>
+    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Un appareil Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, souhaite accéder à vos contacts et à votre journal d\'appels. Ceci inclut des données concernant les appels entrants et sortants.\n\nVous ne vous êtes jamais connecté à <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> auparavant."</string>
+</resources>
diff --git a/res/values-fr-neuter/strings.xml b/res/values-fr-neuter/strings.xml
new file mode 100644
index 0000000..7fca6a9
--- /dev/null
+++ b/res/values-fr-neuter/strings.xml
@@ -0,0 +1,33 @@
+<?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:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Plus que # étape pour être développeur·euse.}one{Plus que # étapes pour être développeur·euse.}other{Plus que # étapes pour être développeur·euse.}}"</string>
+    <string name="show_dev_on" msgid="2840850085134853754">"Vous êtes désormais développeur·euse !"</string>
+    <string name="show_dev_already" msgid="7041756429707644630">"Inutile, vous êtes déjà développeur·euse."</string>
+    <string name="no_internet_access_text" msgid="3611993143350310936">"Ce réseau ne dispose d\'aucun accès à Internet. Rester connecté·e ?"</string>
+    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Vous n\'êtes pas autorisé·e à modifier la langue de l\'appareil."</string>
+    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Rediriger le vibreur vers la manette de jeu lorsque vous êtes connecté·e"</string>
+    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Cela limitera la consommation de données et l\'utilisation de la batterie, mais vous devrez synchroniser manuellement chaque compte pour récupérer les infos récentes. Et en cas de changement, vous n\'en serez pas averti·e."</string>
+    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Vous êtes déjà connecté·e à un VPN permanent. Si vous vous connectez à un autre VPN, le VPN actuel sera remplacé et le mode permanent sera désactivé."</string>
+    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Vous êtes déjà connecté·e à un VPN. Si vous vous connectez à un autre VPN, le VPN actuel sera remplacé."</string>
+    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Sélectionnez un profil VPN auquel rester connecté·e en permanence. Le trafic réseau ne sera autorisé que lorsque vous serez connecté·e à ce VPN."</string>
+    <string name="guest_category_title" msgid="5562663588315329152">"Invité·e (Vous)"</string>
+    <string name="users_summary" msgid="8473589474976307510">"Connecté·e en tant que \"<xliff:g id="USER_NAME">%1$s</xliff:g>\""</string>
+    <string name="zen_suggestion_summary" msgid="1984990920503217">"Suspendre les notifications pour garder votre concentration"</string>
+    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Un appareil Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, souhaite accéder à vos contacts et à votre journal d\'appels. Ceci inclut des données concernant les appels entrants et sortants.\n\nVous ne vous êtes jamais connecté·e à <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> auparavant."</string>
+</resources>
diff --git a/res/values-fr-rCA/arrays.xml b/res/values-fr-rCA/arrays.xml
index 63b1ded..aef11d4 100644
--- a/res/values-fr-rCA/arrays.xml
+++ b/res/values-fr-rCA/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Considérer comme facturé à l\'usage"</item>
     <item msgid="2047166446768045816">"Considérer comme non facturé à l\'usage"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Utiliser une adresse MAC aléatoire (par défaut)"</item>
-    <item msgid="741680937828608749">"Utiliser l\'adresse MAC de l\'appareil"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Non"</item>
     <item msgid="2163015208097377388">"Oui"</item>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index 8097cef..a576cf4 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Assoc. oreille droite"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Assoc. oreille gauche"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Pour tous les appareils auditifs accessibles"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Plus de paramètres de l\'appareil auditif"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Modifiez les paramètres multiappareils, comme les raccourcis et les commandes du phonocapteur"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Pour cet appareil"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Sortie audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"À propos de la sortie audio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configuration de l\'Espace privé en cours…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Les notifications des applications de l\'Espace privé sont masquées lorsqu\'il est verrouillé"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Explorer les paramètres de l\'Espace privé pour le masquer et pour configurer le verrouillage automatique"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Les applications requises sont déjà installées dans votre Espace privé"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Impossible de configurer un Espace privé"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Réessayer"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Utiliser le verrouillage de l\'écran pour déverrouiller l\'Espace privé?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Applications et notifications"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notifications confidentielles sur l\'écran de verrouillage"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Afficher le contenu confidentiel lorsque l\'Espace privé est déverrouillé"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Créez un compte Google pour préserver la confidentialité de vos données"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Sur l\'écran suivant, vous pouvez vous connecter à un compte à utiliser avec votre Espace privé"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Créez un compte dédié pour éviter que des données n\'apparaissent en dehors de l\'Espace privé, comme :"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Photos, fichiers, courriels, contacts, événements d\'agenda et autres données synchronisés"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historique des téléchargements d\'applis et recommandations"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historique de navigation, favoris et mots de passe enregis."</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Contenu suggéré relativement à votre activité dans les applications de l\'Espace privé"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Vous pouvez ajouter jusqu\'à <xliff:g id="COUNT">%d</xliff:g> empreintes digitales"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Vous avez ajouté le nombre maximal d\'empreintes digitales"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Impossible d\'ajouter des empreintes digitales"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Votre opérateur ne vous permet pas de vous connecter à ce réseau, car il utilise un protocole de sécurité plus ancien et moins sécuritaire"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Autoriser WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Fermer"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Se déconnecter du réseau <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Vous êtes connecté à un réseau WEP. Si vous bloquez ces réseaux, vous serez déconnecté."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Options avancées"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Liste déroulante des options avancées"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"développer"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Utiliser <xliff:g id="NEW_APP">%s</xliff:g> pour gérer vos connexions réseau?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Demandes de localisation récentes"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Position pour profil profess."</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Autor. localisation de l\'appli"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Le signalement de position est désactivé"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# application sur {total} a accès à la position}one{# application sur {total} a accès à la position}other{# applications sur {total} ont accès à la position}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Utiliser le clavier à l\'écran"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Afficher lorsque le clavier physique est activé"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Touches non répétées"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Le clavier ignore les appuis répétés rapidement sur les touches de la même clé dans un délai de <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Touches lentes"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Règle le temps nécessaire pour qu\'un appui sur une touche soit activé à <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Touches rémanentes"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Appuyer sur une clé à la fois pour activer les raccourcis plutôt que de maintenir plusieurs touches enfoncées en même temps"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Raccourcis clavier"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Afficher la liste de raccourcis"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Claviers et outils pour le profil professionnel"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Réinitialiser"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Choisir la touche de modification"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Choisir une nouvelle touche pour <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> :"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Par défaut"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Parole"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Vitesse du pointeur"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Manette de jeu"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Vous pouvez personnaliser cet appareil en fonction de vos besoins. Vous pourrez modifier ces fonctionnalités d\'accessibilité plus tard dans les paramètres."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Modifier la taille de la police"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Lecteur d\'écran"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Options de clavier physique"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Sous-titres"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Général"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Affichage"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Couleur et mouvement"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contraste des couleurs"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Un contraste plus élevé fait ressortir davantage le texte, les boutons et les icônes. Choisissez le contraste qui vous convient le mieux."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Certaines applications peuvent ne pas prendre en charge tous les paramètres de contraste de couleur et de texte"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ajustez l\'apparence des couleurs et du texte par rapport à la couleur de l\'arrière-plan de votre écran"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Aperçu"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Hélène, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Il y a 2 jours"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Faire un suivi?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Rapport sur le voyage d\'aff."</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Pour obtenir de l\'assistance supplémentaire, veuillez communiquer avec \nmoi ou avec Hélène. Ce rapport sera"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Dépenses du client"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Assombrir l\'écran"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Commandes d\'interaction"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Commandes du minutage"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuer quand même"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Annuler"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Paramètres d\'agrandissement"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Agrandir avec un raccourci"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Agrandir avec le raccourci et en touchant trois fois"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"À propos de <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Opaque"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texte de contraste élevé"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Changez la couleur du texte en noir ou en blanc. Cela aide à maximiser le contraste avec l\'arrière-plan."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximiser le contraste du texte"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Modifiez la couleur du texte en noir ou en blanc pour augmenter le contraste avec l\'arrière-plan."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Mise à jour auto de la loupe"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Mettre à jour la loupe si transition entre applis"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Interrupteur pour raccrocher"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Maintenir enfoncées les touches de volume"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Toucher l\'écran trois fois"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Modifier les raccourcis d\'accessibilité"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Choisissez votre raccourci pour %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuer"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Appareils auditifs"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configurer et gérer les prothèses auditives, les implants cochléaires et les autres appareils d\'amplification ASHA et LE Audio"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Aucun appareil auditif connecté"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Ajouter des prothèses auditives"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Associer prothèses audit."</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilité : prothèses auditives"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Améliore la compatibilité avec les phonocapteurs et réduit les bruits indésirables"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"À propos des appareils auditifs"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Pour trouver d\'autres appareils auditifs qui ne sont pas pris en charge par ASHA ou LE Audio, touchez "<b>"Associer un appareil"</b>" &gt; "<b>"Afficher d\'autres appareils"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Associer appareil auditif"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Vous pouvez associer les appareils auditifs ASHA et LE Audio sur cette page. Assurez-vous que votre appareil auditif est activé et prêt à être associé."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Appareils auditifs accessibles"</string>
@@ -3905,7 +3886,7 @@
     <string name="usb_summary_UVC_power" msgid="226810354412154061">"Caméra Web et alimentation"</string>
     <string name="background_check_pref" msgid="5304564658578987535">"Vérification en arrière-plan"</string>
     <string name="assist_access_context_title" msgid="5201495523514096201">"Utiliser le texte affiché à l\'écran"</string>
-    <string name="assist_access_context_summary" msgid="6951814413185646275">"Autoriser l\'application d\'assistance à accéder au contenu affiché à l\'écran sous forme de texte"</string>
+    <string name="assist_access_context_summary" msgid="6951814413185646275">"Autorisez l\'application d\'assistance à accéder au contenu affiché à l\'écran sous forme de texte"</string>
     <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Utiliser la saisie d\'écran"</string>
     <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Autorisez l\'application d\'assistance à accéder au contenu affiché à l\'écran sous forme d\'image"</string>
     <string name="assist_flash_title" msgid="5449512572885550108">"Faire clignoter l\'écran"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Messages texte"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Commutation auto. de données"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Utiliser les données de l\'une ou l\'autre carte SIM en fonction de la couverture et de la disponibilité"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Données uniquement"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configuration"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Suivant"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Aide à déterminer la position relative des appareils à proximité qui utilisent la connectivité à bande ultralarge"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Désactivez le mode Avion pour utiliser la connectivité à bande ultralarge"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"La BUL n\'est pas accessible à l\'emplacement actuel"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Se connecter aux appareils compatibles à l\'aide de Thread pour une expérience harmonieuse de maison intelligente"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Désactiver le mode Avion pour utiliser Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Accès à la caméra"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Accès au microphone"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Pour les applications et les services"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Annuler"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contraste"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Par défaut"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Moyen"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Élevé"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Cette application ne peut être ouverte que dans une seule fenêtre."</string>
diff --git a/res/values-fr/arrays.xml b/res/values-fr/arrays.xml
index 38252ae..348a740 100644
--- a/res/values-fr/arrays.xml
+++ b/res/values-fr/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Traiter comme limitée"</item>
     <item msgid="2047166446768045816">"Traiter comme illimitée"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Utiliser une adresse MAC aléatoire (par défaut)"</item>
-    <item msgid="741680937828608749">"Utiliser MAC de l\'appareil"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Non"</item>
     <item msgid="2163015208097377388">"Oui"</item>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index 7da1166..a6d1a0a 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Associer le droit"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Associer le gauche"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Pour tous les appareils auditifs disponibles"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Plus de paramètres concernant les appareils auditifs"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Modifier les paramètres de l\'appareil, tels que les commandes liées aux raccourcis et au phonocapteur."</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Pour cet appareil"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Sortie audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"À propos de la sortie audio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configuration de l\'espace privé…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Les notifications provenant des applis de l\'espace privé sont masquées lorsque celui-ci est verrouillé"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Rendez-vous dans les paramètres d\'espace privé pour masquer l\'espace privé et configurer le verrouillage automatique"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Certaines applis indispensables sont déjà installées dans votre espace privé"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Impossible de configurer un espace privé"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Réessayer"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Utiliser le verrouillage de l\'écran pour déverrouiller l\'espace privé ?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Applis et notifications"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notifications sensibles sur l\'écran de verrouillage"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Afficher le contenu sensible lorsque l\'espace privé est déverrouillé"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Créez un compte Google pour préserver la confidentialité de vos données"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"À la page suivante, vous pourrez vous connecter à un compte grâce auquel vous accéderez à votre espace privé"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"En créant un compte dédié, vous empêchez vos données d\'apparaître en dehors de votre espace privé, notamment : "</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Photos, fichiers, e-mails, contacts, événements d\'agenda synchronisés, et autres données."</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historique des applis téléchargées et recommandations"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historique de navigation, favoris et mots de passe enregistrés"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Suggestions de contenu en fonction de votre activité sur les applis de l\'espace privé"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Vous pouvez ajouter jusqu\'à <xliff:g id="COUNT">%d</xliff:g> empreintes digitales"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Vous avez ajouté le nombre maximal autorisé d\'empreintes digitales"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Impossible d\'ajouter d\'autres empreintes digitales"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Votre opérateur ne vous permet pas de vous connecter à ce réseau parce qu\'il utilise un ancien protocole moins sécurisé"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Autoriser le WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Fermer"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Se déconnecter de <xliff:g id="NAME">%1$s</xliff:g> ?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Vous êtes connecté à un réseau WEP. Si vous bloquez ces réseaux, vous serez déconnecté."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Options avancées"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Liste déroulante \"Options avancées\""</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"développer"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Utiliser <xliff:g id="NEW_APP">%s</xliff:g> pour gérer vos connexions réseau ?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Demandes de localisation récentes"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Position du profil pro"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Accès des applis à la position"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"La localisation est désactivée"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# appli sur {total} a accès à la position}one{# appli sur {total} a accès à la position}other{# applis sur {total} ont accès à la position}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Utiliser le clavier à l\'écran"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Afficher le clavier virtuel même lorsque le clavier physique est actif"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Touches à rebonds"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Le clavier ignore les frappes rapides et consécutives d\'une même touche dans un intervalle de <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Touches lentes"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajuste le temps qu\'il faut pour appuyer sur une touche afin d\'activer <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Touches persistantes"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Pour les raccourcis, appuyez sur une touche à la fois au lieu de maintenir les touches enfoncées"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Raccourcis clavier"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Afficher la liste des raccourcis"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Claviers et outils du profil professionnel"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Réinitialiser"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Choisir une touche de modification"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Choisir une nouvelle touche pour <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> :"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Mise en page <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Par défaut"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatique : <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Utilisateur sélectionné : <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Voix"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Vitesse du pointeur"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Manette de jeu"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Vous pouvez personnaliser cet appareil en fonction de vos besoins et modifier ces fonctionnalités d\'accessibilité ultérieurement dans les paramètres."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Modifier la taille de la police"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Lecteur d\'écran"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Options du clavier physique"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Sous-titres"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Général"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Affichage"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Couleur et mouvement"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contraste des couleurs"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Un contraste plus élevé fait ressortir le texte, les boutons et les icônes. Choisissez le contraste en fonction de vos préférences."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Certaines applis sont susceptibles de ne pas prendre en charge tous les paramètres relatifs au contraste du texte et des couleurs"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ajustez la manière dont les couleurs ainsi que le texte s\'affichent sur l\'arrière-plan de votre écran"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Aperçu"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Il y a 2 jours"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Suivre ?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Rapport du déplacement professionnel"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Pour plus d\'aide, veuillez contacter \nHelen ou moi-même. Ce rapport sera"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Dépenses du client"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Assombrir l\'écran"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Commandes d\'interaction"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Contrôle du temps d\'appui"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuer"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Annuler"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Paramètres d\'agrandissement"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Agrandir avec un raccourci"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Agrandir avec un raccourci et trois tapotements"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"À propos de <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Opaque"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texte avec contraste élevé"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mettre le texte en noir ou blanc pour accentuer le contraste avec le fond."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximiser le contraste du texte"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Mettez le texte en noir ou blanc pour accentuer le contraste avec l\'arrière-plan."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Mise à jour auto de la loupe"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Mettre à jour la loupe si transition entre applis"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Bouton Marche/Arrêt pour raccrocher"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Maintenir enfoncés les boutons de volume"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Appuyer trois fois sur l\'écran"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Modifier les raccourcis d\'accessibilité"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Choisissez votre raccourci pour %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuer"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Appareils auditifs"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configurez et gérez les appareils auditifs ASHA et LE Audio, les implants cochléaires ainsi que d\'autres amplificateurs auditifs"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Aucun appareil auditif connecté"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Ajouter des appareils auditifs"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Associer les appareils"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilité avec appareils auditifs"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Améliore la compatibilité avec les phonocapteurs et réduit les bruits indésirables"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"À propos des appareils auditifs"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Pour détecter d\'autres appareils auditifs qui ne sont pas pris en charge par ASHA ou LE Audio, appuyez sur "<b>"Associer un nouvel appareil"</b>" &gt; "<b>"Voir d\'autres appareils"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Associer appareil auditif"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Sur cette page, vous avez la possibilité d\'associer des appareils auditifs de type ASHA et LE Audio. Vérifiez que votre appareil auditif est allumé et prêt à être associé."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Appareils auditifs dispos"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Migration automatique des données"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Utiliser les données de l\'une ou l\'autre des cartes SIM en fonction de la couverture et de la disponibilité"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Données uniquement"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configuration"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Suivant"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Aide à identifier la position relative des appareils à proximité disposant de l\'UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Désactiver le mode Avion pour utiliser l\'UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB n\'est pas disponible dans le lieu actuel"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Se connecter à des appareils compatibles à l\'aide de Thread pour une expérience de maison connectée fluide"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Désactiver le mode Avion pour utiliser Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Accès à la caméra"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Accès au micro"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Pour les applis et services"</string>
@@ -5063,7 +5044,7 @@
     <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Le format de code QR n\'est pas valide"</string>
     <string name="convert_to_esim_title" msgid="71037864129009206">"Convertir en eSIM"</string>
     <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Transférer l\'eSIM à un autre appareil"</string>
-    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# appli}one{# applis}other{# applis}}"</string>
+    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# appli}one{# appli}other{# applis}}"</string>
     <string name="background_install_title" msgid="607913515188276168">"Applis installées en arrière-plan"</string>
     <string name="background_install_summary" msgid="3890296129543309666">"Le fabricant de votre appareil peut y installer des applis en arrière-plan ou autoriser votre opérateur et d\'autres partenaires à le faire.\n\nAucune des applis listées ici n\'est nécessaire au fonctionnement normal de votre appareil. Vous pouvez désinstaller celles dont vous ne voulez pas."</string>
     <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Aucune appli installée en arrière-plan"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Annuler"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contraste"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Par défaut"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Moyen"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Élevé"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Cette appli ne peut être ouverte que dans 1 fenêtre"</string>
diff --git a/res/values-gl/arrays.xml b/res/values-gl/arrays.xml
index dd63ce2..8592c23 100644
--- a/res/values-gl/arrays.xml
+++ b/res/values-gl/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tratar como rede sen tarifa plana"</item>
     <item msgid="2047166446768045816">"Tratar como rede con tarifa plana"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Usar MAC aleatorio (predefinido)"</item>
-    <item msgid="741680937828608749">"Usar MAC do dispositivo"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Non"</item>
     <item msgid="2163015208097377388">"Si"</item>
diff --git a/res/values-gl/strings.xml b/res/values-gl/strings.xml
index 9e32815..ba5b172 100644
--- a/res/values-gl/strings.xml
+++ b/res/values-gl/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Vincular dereito"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Vincular esquerdo"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Para todos os dispositivos auditivos dispoñibles"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Máis opcións de configuración de dispositivos auditivos"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Cambia a configuración multidispositivo, como os controis dos atallos e da telebobina"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Para este dispositivo"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Saída de audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Acerca da saída de audio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configurando espazo privado…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Cando o espazo privado está bloqueado, ocúltanse as notificacións das súas aplicacións"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Revisa a configuración do espazo privado para ocultalo e definir o bloqueo automático"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"As aplicacións requiridas xa están instaladas no espazo privado"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Non se puido configurar ningún espazo privado"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Tentar de novo"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Usar bloqueo pant. para desbloquear espazo priv.?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplicacións e notificacións"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notificacións confidenciais na pantalla de bloqueo"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Mostra contido confidencial cando o espazo privado está desbloqueado"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Crea unha Conta de Google para axudar a manter a privacidade dos teus datos"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na seguinte pantalla podes iniciar sesión nunha conta para usala co teu espazo privado"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Crea unha conta específica para axudar a evitar que os datos aparezan fóra do teu espazo privado, como:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Fotos, ficheiros, correos, contactos, eventos do calendario e outros datos sincronizados"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Recomendacións e historial de descarga de aplicacións"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historial de navegación, marcadores e contrasinais gardados"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Contido suxerido relacionado coa túa actividade nas aplicacións do espazo privado"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Entendido"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Podes engadir ata <xliff:g id="COUNT">%d</xliff:g> impresións dixitais"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Engadiches o número máximo de impresións dixitais"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Non se poden engadir máis impresións dixitais"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"O teu operador non permite que te conectes a esta rede porque utiliza un protocolo de seguranza máis antigo que é menos seguro"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permitir WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Pechar"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Queres desconectarte de <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Tes conexión cunha rede WEP. Se bloqueas estas redes, perderás a conexión."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opcións avanzadas"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista despregable Opcións avanzadas"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"despregar"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Queres utilizar <xliff:g id="NEW_APP">%s</xliff:g> para xestionar as túas conexións de rede?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitudes de localización recentes"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Localización do perfil de traballo"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Permisos de localización das aplicacións"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"A localización está desactivada"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# de {total} aplicacións ten acceso á localización}other{# de {total} aplicacións teñen acceso á localización}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Utilizar teclado en pantalla"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Móstrase na pantalla mentres o teclado físico estea activo"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Teclas de rebote"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"O teclado ignora as pulsacións repetidas rapidamente da mesma tecla nun intervalo de <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Teclas lentas"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Axusta o tempo que tarda a activación dunha tecla premida a <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Teclas presas"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Preme unha tecla de cada vez para os atallos, en lugar de manter premidas varias"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Atallos de teclado"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostra a lista de atallos"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclados e ferramentas do perfil de traballo"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Restablecer"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Escoller unha tecla modificadora"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Escolle unha nova tecla para <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Predeterminado"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Voz"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Velocidade do punteiro"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Mando do xogo"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Podes personalizar este dispositivo segundo as túas necesidades. Podes cambiar estas funcións de accesibilidade máis tarde en Configuración."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Cambiar tamaño do tipo de letra"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Lector de pantalla"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opcións do teclado físico"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtítulos"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Xeral"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Pantalla"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Cor e movemento"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contraste de cor"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Se sobes o contraste, destacarán máis os textos, os botóns e as iconas. Elixe o que mellor che cadre."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"É posible que algunhas aplicacións non admitan todas as opcións de configuración de contraste de cor e texto"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Axusta como se ven as cores e o texto sobre a cor de fondo da túa pantalla"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Vista previa"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Hai 2 días"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Seguimento?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Informe de viaxe de negocios"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Para ter asistencia adicional, ponte en contacto \ncomigo ou con Helen. O informe vai ser"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Gastos do cliente"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Escurecer pantalla"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Controis de interacción"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Controis de tempo"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuar igualmente"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancelar"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Configuración da ampliación"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ampliar con atallo"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ampliar con atallo e tres toques"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Acerca de: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Non transparente"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texto de alto contraste"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Cambia a cor do texto a negro ou branco. Maximiza o contraste co fondo."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximizar o contraste do texto"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Cambia a cor do texto a negro ou branco para aumentar o contraste co fondo."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Actualizar aumento automaticamente"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Actualizar aumento pantalla en transicións de apps"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Botón de acendido para colgar"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Manter premidas as teclas de volume"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tres toques na pantalla"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Editar os atallos de accesibilidade"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Escolle o atallo para %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Dispositivos auditivos"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configura e xestiona audiófonos ASHA e de audio de baixo consumo, implantes cocleares e outros dispositivos de amplificación"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Non hai ningún dispositivo auditivo conectado"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Engade audiófonos"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Vincular os audiófonos"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilidade disps. auditivos"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Mellora a compatibilidade con telebobinas e reduce o ruído non desexado"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Acerca dos dispositivos auditivos"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Para atopar outros dispositivos auditivos que non sexan compatibles con ASHA ou co audio de baixo consumo, toca "<b>"Vincular dispositivo"</b>" &gt; "<b>"Ver máis dispositivos"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Vincular disp. auditivo"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Nesta páxina podes vincular os dispositivos auditivos ASHA e de audio de baixo consumo. Asegúrate de que o teu dispositivo auditivo está activado e listo para vincularse."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dispositivos auditivos dispoñibles"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mensaxes de texto"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Cambio automático de datos"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Usa os datos de calquera das SIM en función da cobertura e a dispoñibilidade"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Só datos"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configurar"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Seguinte"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Axuda a identificar a posición relativa dos dispositivos próximos con banda ultralarga"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desactiva o modo avión para utilizar a banda ultralarga"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"A banda ultralarga non está dispoñible na localización actual"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Conéctate a dispositivos compatibles por medio de Thread e desfruta dunha experiencia domótica perfecta"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desactiva o modo avión para utilizar Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Acceso á cámara"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Acceso ao micrófono"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Para aplicacións e servizos"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Cancelar"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contraste"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Nivel estándar"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Valor predeterminado"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Nivel medio"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Nivel alto"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Esta aplicación só se pode abrir en 1 ventá"</string>
diff --git a/res/values-gu/arrays.xml b/res/values-gu/arrays.xml
index 08a002d..dfa5804 100644
--- a/res/values-gu/arrays.xml
+++ b/res/values-gu/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"મીટર કરેલું તરીકે ગણો"</item>
     <item msgid="2047166446768045816">"મીટર ન કરેલું તરીકે ગણો"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"રેન્ડમ કરેલા MACનો ઉપયોગ કરો (ડિફૉલ્ટ)"</item>
-    <item msgid="741680937828608749">"MAC ડિવાઇસનો ઉપયોગ કરો"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"ના"</item>
     <item msgid="2163015208097377388">"હા"</item>
diff --git a/res/values-gu/strings.xml b/res/values-gu/strings.xml
index 15d4106..b53214f 100644
--- a/res/values-gu/strings.xml
+++ b/res/values-gu/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"જમણા કાનનું જોડો"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"ડાબા કાનનું જોડો"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"બધા ઉપલબ્ધ શ્રવણ ડિવાઇસ માટે"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"સાંભળવામાં મદદ આપતા ડિવાઇસ સંબંધિત વધુ સેટિંગ"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"શૉર્ટકટ અને ટેલીકોઇલ નિયંત્રણો જેવા ક્રૉસ-ડિવાઇસના સેટિંગમાં ફેરફાર કરો"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"આ ડિવાઇસ માટે"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ઑડિયો આઉટપુટ"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ઑડિયો આઉટપુટ વિશે"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"ખાનગી સ્પેસનું સેટઅપ કરી રહ્યાં છીએ…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"જ્યારે ખાનગી સ્પેસ લૉક કરવામાં આવી હોય, ત્યારે તમારી ખાનગી સ્પેસમાંની ઍપના નોટિફિકેશન છુપાવવામાં આવે છે"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"ખાનગી સ્પેસ છુપાવવા અને ઑટોમૅટિક રીતે લૉક કરવાનું સેટઅપ કરવા માટે, ખાનગી સ્પેસના સેટિંગની શોધખોળ કરો"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"તમારી ખાનગી સ્પેસમાં જરૂરી ઍપ પહેલાંથી જ ઇન્સ્ટૉલ કરવામાં આવી છે"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"કોઈ ખાનગી સ્પેસનું સેટઅપ કરી શકાતું નથી"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ફરી પ્રયાસ કરો"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"ખાનગી સ્પેસને અનલૉક કરવા સ્ક્રીન લૉકનો ઉપયોગ કરીએ?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"ઍપ અને નોટિફિકેશન"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"લૉક સ્ક્રીન પર સંવેદનશીલ નોટિફિકેશન"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"જ્યારે ખાનગી સ્પેસ અનલૉક કરેલી હોય ત્યારે સંવેદનશીલ કન્ટેન્ટ બતાવો"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"તમારો ડેટા ખાનગી રાખવામાં સહાયતા માટે, કોઈ Google એકાઉન્ટ બનાવો"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"આગલી સ્ક્રીન પર, તમારી ખાનગી સ્પેસ સાથે ઉપયોગ કરવા માટે, તમે કોઈ એકાઉન્ટમાં સાઇન ઇન કરી શકો છો"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"તમારી ખાનગી સ્પેસની બહાર ડેટા દેખાવાનું રોકવામાં સહાયતા માટે, કોઈ ખાસ એકાઉન્ટ બનાવો, જેમ કે:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"ફોટા, ફાઇલો, ઇમેઇલ, સંપર્કો, કૅલેન્ડર ઇવેન્ટ અને સિંક કરેલો અન્ય ડેટા"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"ઍપનો ડાઉનલોડ ઇતિહાસ અને સુઝાવો"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"બ્રાઉઝિંગ ઇતિહાસ, બુકમાર્ક અને સાચવેલા પાસવર્ડ"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"ખાનગી સ્પેસ ઍપમાં તમારી ઍક્ટિવિટીથી સંબંધિત સૂચવેલું કન્ટેન્ટ"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"સમજાઈ ગયું"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"તમે <xliff:g id="COUNT">%d</xliff:g> જેટલી ફિંગરપ્રિન્ટ ઉમેરી શકો છો"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"તમે મહત્તમ ફિંગરપ્રિન્ટ્સ ઉમેર્યા છે"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"વધુ ફિંગરપ્રિન્ટ્સ ઉમેરી શકતાં નથી"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"તમારા મોબાઇલ ઑપરેટર તમને આ નેટવર્ક સાથે કનેક્ટ કરવાની મંજૂરી આપતા નથી કારણ કે તે જૂના સુરક્ષા પ્રોટોકૉલનો ઉપયોગ કરે છે, જે ઓછો સુરક્ષિત છે"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEPને મંજૂરી આપો"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"બંધ કરો"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g>થી ડિસ્કનેક્ટ કરીએ?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"તમે કોઈ WEP નેટવર્ક સાથે કનેક્ટેડ છો. જો તમે આ નેટવર્કને બ્લૉક કરશો, તો તમે ડિસ્કનેક્ટ થઈ જશો."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"વિગતવાર વિકલ્પો"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"વિગતવાર વિકલ્પોની ડ્રૉપ-ડાઉન સૂચિ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"મોટા કરો"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"તમારા નેટવર્ક કનેક્શન્સનું સંચાલન કરવા માટે <xliff:g id="NEW_APP">%s</xliff:g> નો ઉપયોગ કરો?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"તાજેતરની સ્થાન વિનંતિ"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ઑફિસની પ્રોફાઇલ માટે સ્થાન"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ઍપ માટે લોકેશનની પરવાનગીઓ"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"સ્થાન બંધ છે"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total}માંથી # ઍપ લોકેશનનો ઍક્સેસ ધરાવે છે}one{{total}માંથી # ઍપ લોકેશનનો ઍક્સેસ ધરાવે છે}other{{total}માંથી # ઍપ લોકેશનનો ઍક્સેસ ધરાવે છે}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ઑન-સ્ક્રીન કીબોર્ડનો ઉપયોગ કરો"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"જ્યારે ભૌતિક કીબોર્ડ સક્રિય હોય ત્યારે તેને સ્ક્રીન પર રાખો"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"બાઉન્સ કી"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> msની અંદર એક જ કીને વારંવાર ઝડપથી દબાવવાની પ્રક્રિયાની કીબોર્ડ અવગણના કરે છે"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ધીમી કી"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms સુધીમાં સક્રિય થવા માટે, કોઈ કીને દબાવવામાં લાગતા સમયની ગોઠવણી કરે છે"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"સ્ટીકી કી"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"શૉર્ટકટ માટે કીને એકસાથે દબાવી રાખવાને બદલે એક સમયે એક જ કી દબાવો"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"કીબોર્ડ શૉર્ટકટ"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"શૉર્ટકટની સૂચિ બતાવો"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"કાર્યાલયનું પ્રોફાઇલ અને સાધનો"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"રીસેટ કરો"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"મૉડિફાયર કી પસંદ કરો"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> માટે નવી કી પસંદ કરો:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ડિફૉલ્ટ"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"સ્પીચ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"પૉઇન્ટરની ગતિ"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"રમત નિયંત્રક"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"તમે તમારી જરૂરિયાતો મુજબ આ ડિવાઇસને કસ્ટમાઇઝ કરી શકો છો. સેટિંગમાં આ ઍક્સેસિબિલિટી સુવિધાઓ પછીથી બદલી શકાય છે."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ફૉન્ટનું કદ બદલો"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"સ્ક્રીન રીડર"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"વાસ્તવિક કીબોર્ડના વિકલ્પો"</string>
     <string name="captions_category_title" msgid="574490148949400274">"કૅપ્શન"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ઑડિયો"</string>
     <string name="general_category_title" msgid="6298579528716834157">"સામાન્ય"</string>
     <string name="display_category_title" msgid="6638191682294461408">"ડિસ્પ્લે"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"રંગ અને મોશન"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"કલર કૉન્ટ્રાસ્ટ"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"વધુ ઉચ્ચ કૉન્ટ્રાસ્ટ ટેક્સ્ટ, બટન અને આઇકનને વધુ સ્પષ્ટ રીતે જોઈ શકાવા યોગ્ય બનાવે છે. તમારા માટે શ્રેષ્ઠતમ દેખાતો કૉન્ટ્રાસ્ટ પસંદ કરો."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"અમુક ઍપ કદાચ રંગ અને ટેક્સ્ટના કૉન્ટ્રાસ્ટ સંબંધિત બધા સેટિંગને સપોર્ટ ન કરે, તેવું બની શકે છે"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"તમારી સ્ક્રીનના બૅકગ્રાઉન્ડ રંગ મુજબ રંગો અને ટેક્સ્ટની ગોઠવણ કરો"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"પ્રીવ્યૂ કરો"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"હેલન, ઍડમ"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 દિવસ અગાઉ"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ફૉલોઅપ કરીએ કે?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"વ્યવસાય ટ્રિપ રિપોર્ટ"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"હજી વધુ સહાય માટે, કૃપા કરીને \nમારો કે હેલનનો સંપર્ક કરો. આ રિપોર્ટ"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"ક્લાયન્ટ સંબંધી ખર્ચા"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"સ્ક્રીનને વધુ ઘેરી બનાવો"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ક્રિયાપ્રતિક્રિયાના નિયંત્રણો"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"સમયના નિયંત્રણો"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"તેમ છતાં ચાલુ રાખો"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"રદ કરો"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"સ્ક્રીન મોટી કરવાનું સેટિંગ"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"શૉર્ટકટ વડે વિસ્તૃત કરો"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"શૉર્ટકટ વડે વિસ્તૃત કરો અને ત્રણ વાર ટૅપ કરો"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> વિશે"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"અપારદર્શક"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ઉચ્ચ કોન્ટ્રાસ્ટ ટેક્સ્ટ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"ટેક્સ્ટનો રંગ બદલીને કાળો અથવા સફેદ કરો. આને કારણે બૅકગ્રાઉન્ડ અનુસાર કોન્ટ્રાસ્ટ વધી જાય છે."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"ટેક્સ્ટનો કૉન્ટ્રાસ્ટ મહત્તમ કરો"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"બૅકગ્રાઉન્ડ સાથેના કૉન્ટ્રાસ્ટમાં વધારો કરવા માટે, ટેક્સ્ટનો રંગ બદલીને કાળો કે સફેદ કરો."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"સ્ક્રીન મોટી કરવાનું ઑટોમૅટિક અપડેટ કરો"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"ઍપ્લિકેશન સંક્રમણો પર સ્ક્રીન વિસ્તૃતીકરણને અપડેટ કરો"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"પાવર બટન કૉલને સમાપ્ત કરે છે"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"વૉલ્યૂમ કીને દબાવી રાખો"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"સ્ક્રીનને ત્રણ વાર ટૅપ કરો"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ઍક્સેસિબિલિટી શૉર્ટકટમાં ફેરફાર કરો"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s માટે તમારો શૉર્ટકટ પસંદ કરો"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"આગળ ચાલુ રાખો"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"સાંભળવામાં મદદ આપતા ડિવાઇસ"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA અને LE ઑડિયો સાંભળવામાં મદદ આપતા યંત્રો, કૉક્લિઅર ઇમ્પ્લાન્ટ અને અન્ય ઍમ્પ્લિફિકેશન ડિવાઇસનું સેટઅપ કરો અને તેને મેનેજ કરો"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"સાંભળવામાં મદદ આપતું કોઈ ડિવાઇસ કનેક્ટેડ નથી"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"શ્રવણ યંત્રો ઉમેરો"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"શ્રવણ યંત્રો જોડો"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"શ્રવણ યંત્રની સુસંગતતા"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ટેલિકૉઇલ સાથેની સુસંગતતા વધારે છે અને વણજોઈતો અવાજ ઘટાડે છે"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"સાંભળવામાં સહાય કરતા ડિવાઇસ વિશે"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA કે LE ઑડિયો દ્વારા સપોર્ટ આપવામાં આવતો ન હોય તેવા સાંભળવામાં મદદ આપતા અન્ય ડિવાઇસ શોધવા માટે, "<b>"નવા ડિવાઇસનું જોડાણ કરો"</b>" અને "<b>"વધુ ડિવાઇસ જુઓ"</b>" પર ટૅપ કરો"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"સાંભળવામાં મદદ આપતા યંત્રનું જોડાણ બનાવો"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"આ પેજ પર તમે ASHA અને LE ઑડિયો સાંભળવામાં મદદ આપતા ડિવાઇસનું જોડાણ કરી શકો છો. ખાતરી કરો કે તમારું સાંભળવામાં મદદ આપતું ડિવાઇસ ચાલુ છે અને જોડાણ કરવા માટે તૈયાર છે."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"સાંભળવાના સહાયક ઉપલબ્ધ ડિવાઇસ"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ટેક્સ્ટ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ઑટોમૅટિક રીતે ડેટા સ્વિચ કરવો"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"કવરેજ અને ઉપલબ્ધતાના આધારે કોઈપણ સિમ કાર્ડમાંથી ડેટાનો ઉપયોગ કરો"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ફક્ત ડેટા"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"સેટઅપ કરો"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"આગળ"</string>
@@ -4681,7 +4668,7 @@
     <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"તમારું સક્રિય સિમ કાર્ડ પસંદ કરો અથવા એકવારમાં 2 સિમ કાર્ડનો ઉપયોગ કરો"</string>
     <string name="choose_sim_title" msgid="66509047151583877">"ઉપયોગ કરવા માટે સિમ કાર્ડ પસંદ કરો"</string>
     <string name="choose_sim_text" msgid="8992163497852069924">"{count,plural, =1{આ ડિવાઇસ પર 1 સિમ કાર્ડ ઉપલબ્ધ છે, પરંતુ એક સમયે માત્ર એક સિમ કાર્ડનો જ ઉપયોગ કરી શકાય છે}=2{આ ડિવાઇસ પર 2 સિમ કાર્ડ ઉપલબ્ધ છે, પરંતુ એક સમયે માત્ર એક સિમ કાર્ડનો જ ઉપયોગ કરી શકાય છે}one{આ ડિવાઇસ પર # સિમ કાર્ડ ઉપલબ્ધ છે, પરંતુ એક સમયે માત્ર એક સિમ કાર્ડનો જ ઉપયોગ કરી શકાય છે}other{આ ડિવાઇસ પર # સિમ કાર્ડ ઉપલબ્ધ છે, પરંતુ એક સમયે માત્ર એક સિમ કાર્ડનો જ ઉપયોગ કરી શકાય છે}}"</string>
-    <string name="choose_sim_activating" msgid="6485547671356386998">"<xliff:g id="ELLIPSIS">…</xliff:g> ચાલુ કરી રહ્યાં છીએ"</string>
+    <string name="choose_sim_activating" msgid="6485547671356386998">"ચાલુ કરી રહ્યાં છીએ<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
     <string name="choose_sim_could_not_activate" msgid="866488735834045525">"અત્યારે આ સિમ કાર્ડ ચાલુ કરી શકાયું નથી"</string>
     <string name="switch_sim_dialog_title" msgid="5407316878973237773">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g>નો ઉપયોગ કરીએ?"</string>
     <string name="switch_sim_dialog_text" msgid="7530186862171635464">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g>નો ઉપયોગ મોબાઇલ ડેટા, કૉલ અને SMS માટે કરવામાં આવશે."</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB ધરાવતાં નજીકના ડિવાઇસનું સંબંધિત અંતર ઓળખવામાં સહાય કરે છે"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWBનો ઉપયોગ કરવા માટે એરપ્લેન મોડ બંધ કરો"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"હાલના લોકેશનમાં UWB અનુપલબ્ધ છે"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"સ્માર્ટ ઘરના વિક્ષેપરહિત અનુભવ માટે, Threadનો ઉપયોગ કરીને સુસંગત ડિવાઇસ સાથે કનેક્ટ કરો"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Threadનો ઉપયોગ કરવા માટે એરપ્લેન મોડ બંધ કરો"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"કૅમેરાનો ઍક્સેસ"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"માઇક્રોફોનનો ઍક્સેસ"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ઍપ અને સેવાઓ માટે"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"રદ કરો"</string>
     <string name="contrast_title" msgid="6885768151336508075">"કોન્ટ્રાસ્ટ"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"સ્ટૅન્ડર્ડ"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ડિફૉલ્ટ"</string>
     <string name="contrast_medium" msgid="384414510709285811">"મધ્યમ"</string>
     <string name="contrast_high" msgid="3988567609694797696">"વધુ"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"આ ઍપ માત્ર 1 વિન્ડોમાં ખોલી શકાય છે"</string>
diff --git a/res/values-hi/arrays.xml b/res/values-hi/arrays.xml
index 9cc1a65..0b126bb 100644
--- a/res/values-hi/arrays.xml
+++ b/res/values-hi/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"सीमित डेटा वाले नेटवर्क के तौर पर मानें"</item>
     <item msgid="2047166446768045816">"सीमित डेटा वाले नेटवर्क के तौर पर न मानें"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"किसी भी MAC पते का इस्तेमाल करें (डिफ़ॉल्ट सेटिंग)"</item>
-    <item msgid="741680937828608749">"डिवाइस MAC का इस्तेमाल करें"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"नहीं"</item>
     <item msgid="2163015208097377388">"हां"</item>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index 0bb8df2..7e02fe7 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"दाईं मशीन को जोड़ें"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"बाईं मशीन को जोड़ें"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"कान की सभी उपलब्ध मशीनों के लिए"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"कान की मशीन के लिए, ज़्यादा सेटिंग"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"क्रॉस-डिवाइस की सेटिंग बदलें. जैसे, शॉर्टकट और टेलीकॉइल कंट्रोल"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"इस डिवाइस के लिए"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ऑडियो आउटपुट"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ऑडियो आउटपुट की जानकारी"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"प्राइवेट स्पेस सेट अप किया जा रहा है…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"प्राइवेट स्पेस वाले ऐप्लिकेशन लॉक होने पर, इनकी सूचनाएं छिपी हुई रहती हैं"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"प्राइवेट स्पेस को छिपाने और अपने-आप लॉक होने की सुविधा सेट अप करने के लिए, प्राइवेट स्पेस की सेटिंग देखें"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"कुछ सिस्टम ऐप्लिकेशन, पहले से ही आपके प्राइवेट स्पेस में इंस्टॉल हैं"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"प्राइवेट स्पेस को सेट अप नहीं किया जा सका"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"फिर से कोशिश करें"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"स्क्रीन लॉक से प्राइवेट स्पेस को अनलॉक करें?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"ऐप्लिकेशन और सूचनाएं"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"लॉक स्क्रीन पर संवेदनशील सूचनाएं"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"प्राइवेट स्पेस अनलॉक होने पर संवेदनशील कॉन्टेंट दिखाएं"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"अपने डेटा को निजी बनाए रखने के लिए, Google खाता बनाएं"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"अगली स्क्रीन पर, प्राइवेट स्पेस का इस्तेमाल करने के लिए, किसी खाते से साइन इन किया जा सकता है"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"डेटा को प्राइवेट स्पेस से बाहर दिखाने से रोकने के लिए, खास तौर पर खाता बनाएं. जैसे:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"सिंक किए गए फ़ोटो, फ़ाइलें, ईमेल, संपर्क, कैलेंडर इवेंट, और अन्य डेटा"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"ऐप्लिकेशन को डाउनलोड करने का इतिहास और सुझाव"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ब्राउज़िंग इतिहास, बुकमार्क, और सेव किए गए पासवर्ड"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"प्राइवेट स्पेस वाले ऐप्लिकेशन में, आपकी गतिविधि के हिसाब से सुझाया गया कॉन्टेंट"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"ठीक है"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"ज़्यादा से ज़्यादा <xliff:g id="COUNT">%d</xliff:g> फ़िंगरप्रिंट जोड़े जा सकते हैं"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"आप अधिकतम संख्या में फ़िंगरप्रिंट जोड़ चुके हैं"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"और ज़्यादा फ़िंगरप्रिंट नहीं जोड़े जा सकते"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"आपको मोबाइल और इंटरनेट सेवा देने वाली कंपनी, इस नेटवर्क से कनेक्ट करने की अनुमति नहीं देती है. ऐसा इसलिए, क्योंकि यह पुराने सिक्योरिटी प्रोटोकॉल का इस्तेमाल करता है, जो कि कम सुरक्षित है"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP नेटवर्क को अनुमति दें"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"बंद करें"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"क्या आपको <xliff:g id="NAME">%1$s</xliff:g> से डिसकनेक्ट करना है?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"आपका डिवाइस WEP नेटवर्क से कनेक्ट है. इन नेटवर्क को ब्लॉक करने से, आपका डिवाइस डिसकनेक्ट हो जाएगा."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"बेहतर विकल्प"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"बेहतर विकल्पों की ड्रॉप-डाउन सूची"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"बड़ा करें"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"आपके नेटवर्क कनेक्शन प्रबंधित करने के लिए <xliff:g id="NEW_APP">%s</xliff:g> का उपयोग करें?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"हाल में किए गए जगह के अनुरोध"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"वर्क प्रोफ़ाइल की जगह"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ऐप्लिकेशन के लिए जगह की जानकारी की अनुमतियां"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"जगह की जानकारी बंद है"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} में से # ऐप्लिकेशन के पास, जगह की जानकारी का ऐक्सेस है}one{{total} में से # ऐप्लिकेशन के पास, जगह की जानकारी का ऐक्सेस है}other{{total} में से # ऐप्लिकेशन के पास, जगह की जानकारी का ऐक्सेस है}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ऑन-स्क्रीन कीबोर्ड का इस्तेमाल करें"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"सामान्य कीबोर्ड चालू रहने के दौरान इसे स्‍क्रीन पर दिखाते रहें"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"बाउंस कुंजियां"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"इससे कीबोर्ड, <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> एमएस में बार-बार एक ही कुंजी को दबाते रहने से उसे अनदेखा कर देता है"</string>
     <string name="slow_keys" msgid="2891452895499690837">"स्लो बटन"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"इससे <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> एमएस को ऐक्टिवेट करने के लिए कुंजी दबाने में लगने वाले समय में बदलाव हो जाता है"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"स्टिकी बटन"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"शॉर्टकट के लिए, कई कुंजियों को एक साथ दबाए रखने की बजाय, एक बार में एक ही कुंजी को दबाएं"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"कीबोर्ड शॉर्टकट"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"शॉर्टकट की सूची दिखाएं"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"काम के प्रोफ़ाइल से जुड़े कीबोर्ड और टूल"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"रीसेट करें"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"कार्रवाई बदलने वाली कुंजी चुनें"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> के लिए, कोई नई कुंजी चुनें:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> का लेआउट"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"डिफ़ॉल्ट"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"अपने-आप चुना गया: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"उपयोगकर्ता का चुना गया: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"बोली"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"पॉइंटर स्पीड"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"गेमनियंत्रक"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"इस फ़ोन में अपनी ज़रूरतों के हिसाब से बदलाव किए जा सकते हैं. ये सुलभता सुविधाएं बाद में सेटिंग में बदली जा सकती हैं."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"फ़ॉन्ट का साइज़ बदलें"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"स्क्रीन रीडर"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"फ़िज़िकल कीबोर्ड के विकल्प"</string>
     <string name="captions_category_title" msgid="574490148949400274">"कैप्शन"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ऑडियो"</string>
     <string name="general_category_title" msgid="6298579528716834157">"सामान्य"</string>
     <string name="display_category_title" msgid="6638191682294461408">"डिसप्ले"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"रंग और मोशन"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"कलर कंट्रास्ट"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"ज़्यादा कंट्रास्ट की मदद से, टेक्स्ट, बटन, और आइकॉन सबसे अलग दिखते हैं. अपने लिए सबसे बेहतरीन कंट्रास्ट चुनें."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"ऐसा हो सकता है कि कुछ ऐप्लिकेशन में, सभी रंग और टेक्स्ट के कंट्रास्ट की सेटिंग काम न करें"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"रंग और टेक्स्ट को स्क्रीन के बैकग्राउंड कलर के हिसाब से बदलें"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"झलक देखें"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"हेलेन, एडम"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"दो दिन पहले"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"फ़ॉलो अप करें?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"कारोबार यात्रा की रिपोर्ट"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"ज़्यादा मदद पाने के लिए, कृपया \nमुझसे या हेलेन से संपर्क करें. इस रिपोर्ट को"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"क्लाइंट से जुड़े खर्चे"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"स्क्रीन की चमक को कम करें"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"इंटरैक्शन कंट्रोल"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"समय से जुड़े कंट्रोल"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"जारी रखें"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"अभी नहीं"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"ज़ूम करने की सुविधा की सेटिंग"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"शॉर्टकट की मदद से बड़ा करके देखें"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"तीन बार टैप और शॉर्टकट की मदद से बड़ा करके देखें"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> के बारे में जानकारी"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"पारदर्शी नहीं है"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ज़्यादा कंट्रास्ट वाला टेक्स्ट"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"टेक्स्ट का रंग बदलकर काला या सफ़ेद करें. इससे बैकग्राउंड के मुताबिक कंट्रास्ट बढ़ जाता है."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"टेक्स्ट के कंट्रास्ट को बढ़ाएं"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"बैकग्राउंड के मुताबिक कंट्रास्ट को बढ़ाने के लिए, टेक्स्ट का रंग बदलकर काला या सफ़ेद करें."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"स्क्रीन को बड़ा करने की सुविधा को अपने आप अपडेट करें"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"ऐप ट्रांज़िशन पर स्क्रीन को बड़ा दिखाना अपडेट करें"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"पावर बटन से कॉल काटना"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"आवाज़ बढ़ाने और घटाने वाले बटनों को दबाकर रखें"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"स्क्रीन पर तीन बार टैप करें"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"सुलभता ऐप्लिकेशन के लिए शॉर्टकट में बदलाव करें"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s के लिए शॉर्टकट चुनें"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"जारी रखें"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"कान की मशीनें"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA और LE Audio वाली कान की मशीनें, कॉकलीयर इंप्लांट, और अन्य एंप्लिफ़िकेशन डिवाइसों को सेट अप और मैनेज करें"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"कान की कोई भी मशीन कनेक्ट नहीं है"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"सुनने में मदद करने वाले डिवाइस जोड़ें"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"कान की मशीन को जोड़ें"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"कान की मशीन के साथ काम करने की सुविधा"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"टेलीकॉइल के साथ काम करने की सुविधा को बेहतर बनाएं और आस-पास के शोर को कम करें"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"कान की मशीनों के बारे में जानकारी"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA या LE Audio के साथ काम नहीं करने वाली कान की अन्य मशीनें ढूंढने के लिए, "<b>"नया डिवाइस जोड़ें"</b>" और "<b>"ज़्यादा डिवाइस देखें"</b>" पर टैप करें"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"कान की मशीन जोड़ें"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"इस पेज पर ASHA और LE Audio वाली कान की मशीनों को जोड़ा जा सकता है. यह पक्का कर लें कि कान की मशीन चालू है और जोड़े जाने के लिए तैयार है."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"कान की उपलब्ध मशीनें"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"मैसेज"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"अपने-आप डेटा स्विच होना"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"नेटवर्क कवरेज या उसकी उपलब्धता के आधार पर डेटा का इस्तेमाल करें"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"सिर्फ़ डेटा"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"सेट अप करें"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"अगले पेज पर जाएं"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"इससे आपको आस-पास मौजूद यूडब्ल्यूबी वाले डिवाइसों की, जगह की जानकारी का पता लगाने में मदद मिलती है"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"यूडब्ल्यूबी की सुविधा का इस्तेमाल करने के लिए, हवाई जहाज़ मोड बंद करें"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"यूडब्ल्यूबी टेक्नोलॉजी मौजूदा जगह पर उपलब्ध नहीं है"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"बिना किसी रूकावट के स्मार्ट होम का बेहतरीन अनुभव पाने के लिए, Thread का इस्तेमाल करके, साथ में काम करने वाले डिवाइसों से कनेक्ट करें"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread का इस्तेमाल करने के लिए फ़्लाइट मोड बंद करें"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"कैमरे का ऐक्सेस"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"माइक्रोफ़ोन का ऐक्सेस"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ऐप्लिकेशन और सेवाओं के लिए"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"रहने दें"</string>
     <string name="contrast_title" msgid="6885768151336508075">"कंट्रास्ट"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"स्टैंडर्ड"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"डिफ़ॉल्ट"</string>
     <string name="contrast_medium" msgid="384414510709285811">"सामान्य"</string>
     <string name="contrast_high" msgid="3988567609694797696">"ज़्यादा"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"इस ऐप्लिकेशन को सिर्फ़ एक विंडो में खोला जा सकता है"</string>
diff --git a/res/values-hr/arrays.xml b/res/values-hr/arrays.xml
index 426408a..45ca84c 100644
--- a/res/values-hr/arrays.xml
+++ b/res/values-hr/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Mreža s ograničenim prometom"</item>
     <item msgid="2047166446768045816">"Mreža bez ograničenja prometa"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Koristi nasumičnu MAC adresu (zadano)"</item>
-    <item msgid="741680937828608749">"Koristi MAC adresu uređaja"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ne"</item>
     <item msgid="2163015208097377388">"Da"</item>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index 3c8b832..14aaffa 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Upari desno uho"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Upari lijevo uho"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Za sve dostupne slušne uređaje"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Više postavki slušnih pomagala"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Izmijenite postavke za više uređaja kao što su kontrole prečaca i telezavojnica"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Za ovaj uređaj"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audioizlaz"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"O audioizlazu"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"U tijeku je postavljanje privatnog prostora…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Obavijesti aplikacija u privatnom prostoru sakrivene su kada je on zaključan"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Istražite postavke privatnog prostora da biste sakrili privatni prostor i postavili automatsko zaključavanje"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Zatražene aplikacije već su instalirane u vašem privatnom prostoru"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Postavljanje privatnog prostora nije uspjelo"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Pokušajte ponovo"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Koristiti zaključavanje zaslona za otključavanje?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikacije i obavijesti"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Osjetljive obavijesti na zaključanom zaslonu"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Prikaži osjetljivi sadržaj kad je privatni prostor otključan"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Izradite Google račun kako biste zaštitili privatnost svojih podataka"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na sljedećem zaslonu možete se prijaviti na račun koji želite upotrebljavati sa svojim privatnim prostorom"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Izradite namjenski račun kako biste spriječili prikazivanje podataka izvan privatnog prostora, npr.:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinkronizirane fotografije, datoteke, e-poruke, kontakti, događaji iz kalendara i drugo"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Povijest preuzimanja aplikacija i preporuke"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Povijest pregledavanja, oznake i spremljene zaporke"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Predloženi sadržaj povezan s vašom aktivnošću u aplikacijama privatnog prostora"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Shvaćam"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Maksimalni broj otisaka prstiju koji možete dodati: <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodali ste maksimalan broj otisaka prstiju"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nije moguće dodati više otisaka prstiju"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Vaš mobilni operater ne dopušta da se povežete s ovom mrežom jer ona koristi stariji sigurnosni protokol koji je manje siguran"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Dopusti WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Zatvori"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Želite li prekinuti vezu s mrežom <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Povezani ste s WEP mrežom. Ako blokirate navedene mreže, veza će se prekinuti."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Napredne opcije"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Padajući popis Napredne opcije"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"proširi"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Želite li upotrebljavati aplikaciju <xliff:g id="NEW_APP">%s</xliff:g> za upravljanje mrežnim vezama?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavni zahtjevi za lokaciju"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za poslovni profil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Dopuštenja za pristup lokaciji"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokacija je isključena"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# od {total} aplikacije ima pristup lokaciji}one{# od {total} aplikacije imaju pristup lokaciji}few{# od {total} aplikacije imaju pristup lokaciji}other{# od {total} aplikacija imaju pristup lokaciji}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Upotreba tipkovnice na zaslonu"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Zadrži na zaslonu dok je fizička tipkovnica aktivna"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Sprečavanje ponovljenih unosa"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tipkovnica zanemaruje brzo ponovljene pritiske iste tipke unutar <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Spore tipke"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Prilagođava vrijeme potrebno za aktivaciju pritiskom tipke na <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Ljepljive tipke"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Pritisnite jednu po jednu tipku za prečace umjesto da ih pritisnete zajedno"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tipkovni prečaci"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Prikaži popis prečaca"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tipkovnice i alati radnog profila"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Poništi"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Odaberi modifikatorsku tipku"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Odaberite novu tipku za <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Izgled: <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Zadano"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatski: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Izgled koji je odabrao korisnik: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Govor"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Brzina pokazivača"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Upravljač igrama"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Ovaj uređaj možete prilagoditi svojim potrebama. Značajke pristupačnosti možete promijeniti kasnije u postavkama."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Promijenite veličinu fonta"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Čitač zaslona"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opcije fizičke tipkovnice"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Titlovi"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Zvuk"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Općenito"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Zaslon"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Boja i pokret"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kontrast boja"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Veći kontrast omogućuje da se tekst, gumbi i ikone bolje istaknu. Odaberite kontrast koji vam najbolje izgleda."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Neke aplikacije možda ne podržavaju sve postavke kontrasta boja i teksta"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Prilagodite kako boje i tekst izgledaju u odnosu na boju pozadine zaslona"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Pregled"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Prije dva dana"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Dodatni upit?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Izvješće o poslovnom putu"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Za dodatnu pomoć obratite se \nmeni ili Helen. Ovo izvješće bit će"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Troškovi klijenta"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Zatamnjenje zaslona"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrole interakcije"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrole tajminga"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Ipak nastavi"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Odustani"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Postavke povećavanja"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Povećanje pomoću prečaca"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Povećanje pomoću prečaca i trostrukog dodira"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"O usluzi <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Neprozirno"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst s visokim kontrastom"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mijenja boju teksta u crnu ili bijelu. Maksimizira kontrast s pozadinom."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Povećajte kontrast teksta"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Promijenite boju teksta u crnu ili bijelu kako bi se povećao kontrast u odnosu na pozadinu."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Autom. ažuriranje uvećanja zaslona"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ažuriranje uvećanja zaslona pri izmjeni aplikacija"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Tipka za uklj. prekida poziv"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Držite tipke za glasnoću"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triput dodirnite zaslon"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Uređivanje prečaca pristupačnosti"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Odaberite prečac za značajku %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Nastavi"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Slušna pomagala"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Postavite ASHA i LE Audio slušna pomagala, umjetne pužnice i druge uređaje za pojačanje zvuka"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nije povezano nijedno slušno pomagalo"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Dodaj slušne aparate"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Uparite slušna pomagala"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilnost sa slušnim pomagalima"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Poboljšava kompatibilnost s telezavojnicama i smanjuje neželjenu buku"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"O slušnim uređajima"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Da biste pronašli druga slušna pomagala koja nisu podržana putem protokola ASHA ili LE Audija, dodirnite "<b>"Upari novi uređaj"</b>" &gt; "<b>"Pregled više uređaja"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Uparite slušni uređaj"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Na ovoj stranici možete upariti slušna pomagala s ASHA protokolom i aplikacijom LE Audio. Provjerite je li vaše slušno pomagalo uključeno i spremno za uparivanje."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostupni slušni uređaji"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Tekstne poruke"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Autom. prebacivanje podataka"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Upotrijebite podatke s jedne od SIM kartica ovisno o pokrivenosti i dostupnosti"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Samo podatkovna veza"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Postavi"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Dalje"</string>
@@ -4942,12 +4926,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomoć pri određivanju relativnog položaja uređaja u blizini koji imaju UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Isključite način rada u zrakoplovu da biste koristili UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB nije dostupan na trenutačnoj lokaciji"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Povežite se s kompatibilnim uređajima pomoću Threada za besprijekoran doživljaj pametnog doma"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Isključite način rada u zrakoplovu da biste koristili Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Pristup fotoaparatu"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Pristup mikrofonu"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Za aplikacije i usluge"</string>
@@ -5124,8 +5105,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Odustani"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standardni"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Zadano"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Srednji"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Visoki"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ova se aplikacija može otvoriti samo u jednom prozoru"</string>
diff --git a/res/values-hu/arrays.xml b/res/values-hu/arrays.xml
index 5b31c91..10d3a02 100644
--- a/res/values-hu/arrays.xml
+++ b/res/values-hu/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Kezelje forgalomkorlátosként"</item>
     <item msgid="2047166446768045816">"Kezelje nem forgalomkorlátosként"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Véletlenszerű MAC-cím (alapért.)"</item>
-    <item msgid="741680937828608749">"Az eszköz MAC-címének használata"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nem"</item>
     <item msgid="2163015208097377388">"Igen"</item>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index 88459a6..88c8efa 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Jobb fül párosítása"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Bal fül párosítása"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Minden rendelkezésre álló hallókészüléknél"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"További hallókészülék-beállítások"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Módosíthatja a többeszközös beállításokat (pl. gyorsparancsok és telecoil-vezérlők)."</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Ennél az eszköznél"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Hangkimenet"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"A hangkimenetről"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"A privát terület beállítása…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"A magánterületen lévő alkalmazásoktól érkező értesítések rejtve maradnak, amikor le van zárva a magánterület"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"A magánterületet érintő beállítások felfedezésével elrejtheti a magánterületet, és beállíthatja az automatikus zárolást"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"A szükséges alkalmazások már telepítve vannak a magánterületén"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Nem sikerült a magánterület beállítása"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Újra"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"A privát terület feloldása képernyőzárral?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Alkalmazások és értesítések"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Bizalmas értesítések a lezárási képernyőn"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Bizalmas tartalmak megjelenítése, ha a magánterület zárolása fel van oldva"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Google-fiók létrehozásával könnyebben gondoskodhat adatai privát jellegének megőrzéséről"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"A következő képernyőn bejelentkezhet a magánterülettel használni kívánt fiókba"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Hozzon létre külön fiókot annak megakadályozásához, hogy az adatok a magánterületen kívül is megjelenjenek, például:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Szinkronizált fotók, fájlok, e-mailek, névjegyek, naptáresemények és egyéb adatok"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Alkalmazásletöltési előzmények és ajánlások"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Böngészési előzmények, könyvjelzők és mentett jelszavak"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Javasolt tartalmak a magánterület alkalmazásaiban végzett tevékenységei alapján"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Értem"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Legfeljebb <xliff:g id="COUNT">%d</xliff:g> ujjlenyomatot adhat hozzá"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Elérte a hozzáadható ujjlenyomatok maximális számát"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nem lehet több ujjlenyomatot hozzáadni"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Szolgáltatója nem engedélyezi a csatlakozást, mert ez a hálózat egy régebbi, kevésbé biztonságos biztonsági protokollt használ."</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"A WEP engedélyezése"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Bezárás"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Biztosan megszakítja a kapcsolatot a következővel: <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP hálózathoz csatlakozott. A hálózatok letiltásával megszakad a kapcsolat."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Speciális beállítások"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Legördülő lista – Speciális beállítások"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"kibontás"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Szeretné a(z) <xliff:g id="NEW_APP">%s</xliff:g> alkalmazást használni a hálózati kapcsolatok kezelésére?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Legutóbbi helylekérdezések"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"A munkahelyi profil helye"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Appok helyelérési engedélyei"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"A helyadatok ki vannak kapcsolva"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total}/# alkalmazás hozzáfér a helyadatokhoz}other{{total}/# alkalmazás hozzáfér a helyadatokhoz}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Képernyő-billentyűzet használata"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Maradjon a képernyőn, amíg a fizikai billentyűzet aktív"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Billentyűblokkolás"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"A billentyűzet nem veszi figyelembe, ha ugyanazt a billentyűt többször is lenyomják <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms-on belül"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Lassú billentyűk"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Átállítja a billentyű lenyomásától az aktiválásig eltelő időtartamot <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms-ra"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Beragadó billentyűk"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Egyszerre egy billentyű lenyomásával használhat billentyűparancsokat több billentyű egyszeri lenyomva tartása helyett"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Billentyűparancsok"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Billentyűparancsok listájának megjelenítése"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Munkaprofil billentyűzetei és eszközei"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Alaphelyzet"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Módosító billentyű választása"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Válasszon új billentyűt a(z) <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> számára:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Alapértelmezett"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Beszéd"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Mutató sebessége"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Játékvezérlő"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Eszközét saját igényeinek megfelelően testre szabhatja. Ezeket a kisegítő lehetőségeket később a Beállítások menüben módosíthatja."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Betűméret módosítása"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Képernyőolvasó"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Fizikai billentyűzet beállításai"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Feliratok"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Hang"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Általános"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Megjelenítés"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Szín és mozgás"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Színkontraszt"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"A magasabb kontrasztnak köszönhetően könnyebben kivehetők a szövegek, a gombok és az ikonok. Válassza ki az Önnek megfelelő kontrasztot."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Előfordulhat, hogy egyes alkalmazások nem támogatják a szín- és szövegkontraszttal kapcsolatos összes beállítást."</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Módosíthatja, hogy a színek és a szövegek hogyan jelenjenek meg a képernyő háttérszínéhez képest."</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Előnézet"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 napja"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"További kérdés?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Üzleti út jelentése"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Kérem, további segítségért forduljon \nhozzám vagy Helenhez. Ez a jelentés"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Ügyfélkiadások"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Képernyő sötétítése"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interakcióvezérlők"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Időzítési vezérlők"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Folytatás mégis"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Mégse"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Nagyítási beállítások"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Nagyítás gyorsparanccsal"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Nagyítás gyorsparanccsal és három koppintással"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Nem átlátszó"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Nagy kontrasztú szöveg"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"A szöveg színének módosítása feketére vagy fehérre, hogy maximálisan elkülönüljön a háttértől."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Szövegkontraszt maximalizálása"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Feketére vagy fehérre módosíthatja a szöveg színét, hogy nagyobb legyen a kontraszt a háttérhez képest."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Képernyőnagyítás automatikus frissítése"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Nagyítás frissítése az alkalmazások közti átmeneteknél"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"A bekapcs. gomb megszakítja a hívást"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hangerőgombok nyomva tartása"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Három koppintás a képernyőre"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Kisegítő lehetőségek gyorsparancsainak szerkesztése"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Válassza ki a billentyűparancsot a következőhöz: %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Tovább"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hallásjavító eszközök"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Az ASHA protokollt és az alacsony energiaszintű hangátvitelt támogató hallókészülékek, cochleáris implantátumok és egyéb erősítőeszközök beállítása és kezelése"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nincs csatlakoztatva hallókészülék"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Hallókészülékek hozzáadása"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Hallókészülék párosítása"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Hallókészülék-kompatibilitás"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Javítja a Telecoil rendszerű készülékekkel való kompatibilitást, és csökkenti a nem kívánt zajokat"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"A hallókészülékekről"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Az ASHA protokollt vagy az alacsony energiaszintű hangátvitelt nem támogató egyéb hallókészülékek kereséséhez koppintson az "<b>"Új eszköz párosítása"</b>" &gt; "<b>"További eszközök megjelenítése"</b>" lehetőségre."</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Hallásjavító párosítása"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Ezen az oldalon az ASHA protokollt és az alacsony energiaszintű hangátvitelt támogató hallókészülékeket párosíthatja. Győződjön meg arról, hogy a hallókészüléke be van kapcsolva, és készen áll a párosításra."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Elérhető hallókészülékek"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS-ek"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatikus adatváltás"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Adatok használata bármelyik SIM-ről a lefedettségtől és a rendelkezésre állástól függően"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Csak adatkapcsolat"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Beállítás"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Következő"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Segít az UWB technológiát használó közeli eszközök relatív pozíciójának a meghatározásában"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Kapcsolja ki a Repülős üzemmódot az UWB használatához"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Aktuális tartózkodási helyén nem áll rendelkezésre az UWB szolgáltatás"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Csatlakozhat kompatibilis eszközökhöz Thread használatával, hogy zökkenőmentes okosotthoni élményben legyen része"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"A Thread használatához kapcsolja ki a Repülős üzemmódot"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Hozzáférés a kamerához"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Hozzáférés a mikrofonhoz"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Alkalmazásoknál és szolgáltatásoknál"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Mégse"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontraszt"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Normál"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Alapértelmezett"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Közepes"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Nagy"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ez az alkalmazás csak egy ablakban nyitható meg"</string>
diff --git a/res/values-hy/arrays.xml b/res/values-hy/arrays.xml
index cb568c3..15b6ca5 100644
--- a/res/values-hy/arrays.xml
+++ b/res/values-hy/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Սահմանափակ"</item>
     <item msgid="2047166446768045816">"Անսահմանափակ"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Օգտագործել պատահական MAC հասցե (կանխադրված)"</item>
-    <item msgid="741680937828608749">"Օգտագործել սարքի MAC հասցեն"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ոչ"</item>
     <item msgid="2163015208097377388">"Այո"</item>
diff --git a/res/values-hy/strings.xml b/res/values-hy/strings.xml
index 5566870..bd2d9ca 100644
--- a/res/values-hy/strings.xml
+++ b/res/values-hy/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Զուգակցել աջ ականջը"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Զուգակցել ձախ ականջը"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Բոլոր հասանելի լսողական սարքերի համար"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Լսողական սարքերի այլ կարգավորումներ"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Փոխեք միաժամանակ մի քանի սարքի միացման կարգավորումները, օրինակ՝ դյուրանցումը, և հեռակոճի պարամետրերը"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Այս սարքի համար"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Աուդիո ելք"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Աուդիո ելքի մասին"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Անձնական տարածքի կարգավորում…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Մասնավոր տարածքում հավելվածներից ծանուցումները թաքցված են, երբ այն կողպված է"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Ստուգեք մասնավոր տարածքի կարգավորումները՝ այն թաքցնելու և ավտոմատ կողպումը կարգավորելու համար"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Պահանջվող հավելվածներն արդեն տեղադրված են ձեր մասնավոր տարածքում"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Չհաջողվեց մասնավոր տարածք կարգավորել"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Նորից փորձել"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Օգտագործե՞լ էկրանի կողպում անձնական տարածքի համար"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Հավելվածներ և ծանուցումներ"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Զգայուն ծանուցումներ կողպէկրանի վրա"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Ցույց տալ զգայուն բովանդակություն, երբ մասնավոր տարածքն ապակողպված է"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Ստեղծեք Google հաշիվ՝ ձեր տվյալներն ապահով պահելու համար"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Հաջորդ էկրանին դուք կարող եք մտնել հաշիվ՝ ձեր մասնավոր տարածքի հետ օգտագործելու համար"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Ստեղծեք առանձին հաշիվ, որպեսզի խուսափեք մասնավոր տարածքից դուրս տվյալների արտահոսքից, օրինակ՝"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Համաժամացված նկարներ, ֆայլեր, նամակներ, կոնտակտներ, օրացույցի միջոցառումներ և այլ տվյալներ"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Հավելվածների ներբեռնման պատմություն և առաջարկներ"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Այցելությունների պատմություն, էջանիշներ և պահված գաղտնաբառեր"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Մասնավոր տարածքի հավելվածներում ձեր գործողություններին առնչվող առաջարկվող բովանդակություն"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Պարզ է"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Կարող եք ավելացնել առավելագույնը <xliff:g id="COUNT">%d</xliff:g> մատնահետք"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Դուք ավելացրել եք մատնահետքերի առավելագույն թույլատրելի քանակը"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Հնարավոր չէ ավելացնել այլ մատնահետքեր"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Ձեր օպերատորը թույլ չի տալիս միանալ այս ցանցին, քանի որ այն օգտագործում է պաշտպանության ցածր մակարդակով անվտանգության հին հաղորդակարգ"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Թույլատրել WEP-ով ցանցեր"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Փակել"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Անջատվե՞լ <xliff:g id="NAME">%1$s</xliff:g> ցանցից"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Դուք միացել եք WEP ցանցի։ Եթե արգելափակեք այս ցանցերը, կապը կընդհատվի։"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Ընդլայնված ընտրանքներ"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Իջնող ցանկի լրացուցիչ կարգավորումներ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ծավալել"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Օգտագործե՞լ <xliff:g id="NEW_APP">%s</xliff:g> ծրագիրը՝ ձեր ցանցային կապերը կառավարելու համար:"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Տեղորոշման վերջին հարցումները"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Տեղ աշխատանքային պրոֆիլի համար"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Տեղորոշման թույլտվություններ"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Տեղորոշումն անջատված է"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Տեղադրության տվյալները հասանելի են # հավելվածի՝ {total}-ից}one{Տեղադրության տվյալները հասանելի են # հավելվածի՝ {total}-ից}other{Տեղադրության տվյալները հասանելի են # հավելվածի՝ {total}-ից}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Օգտագործել էկրանի ստեղնաշարը"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Պահել էկրանին, երբ ֆիզիկական ստեղնաշարն ակտիվ է"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Վերադառնալու ստեղներ"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Ստեղնաշարը անտեսում է միևնույն ստեղնի արագ սեղմումները, որոնք կրկնվում են <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> մվ-ի ընթացքում"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Դանդաղ ստեղներ"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Կարգավորում է ժամանակի տևողությունը, որից հետո ստեղնը արձագանքում է սեղմմանը՝ <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> մվ"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Կպչուն ստեղներ"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Դյուրանցումների համար միաժամանակ սեղմեք մեկ ստեղն, այլ ոչ թե միասին սեղմած պահեք մի քանիսը"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Ստեղնային դյուրանցումներ"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Ցույց տալ ստեղնաշարի դյուրանցումների ցանկը"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Աշխատանքային պրոֆիլի ստեղնաշարեր և գործիքներ"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Վերականգնել"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Ընտրեք կերպափոխիչ ստեղնը"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Ընտրել նոր ստեղն <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> ստեղնի փոխարեն՝"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Կանխադրված"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Խոսք"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Նշորդի արագությունը"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Խաղերի կարգավորիչ"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Օգտվեք հատուկ հնարավորություններից՝ հարմար աշխատանքի համար։ Այս գործառույթները կարող եք փոփոխել սարքի կարգավորումներում։"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Փոխեք տառաչափը"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Էկրանի ընթերցիչ"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Ֆիզիկական ստեղնաշարի տարբերակներ"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Ենթագրեր"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Աուդիո"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Ընդհանուր"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Էկրան"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Գույն և շարժում"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Գույների կոնտրաստ"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Բարձր կոնտրաստն ավելի է առանձնացնում տեքստը, կոճակները և պատկերակները։ Ընտրեք ձեզ հարմարավետ կոնտրաստ։"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Որոշ հավելվածներ հնարավոր է՝ չաջակցեն գույների և տեքստի կոնտրաստի կարգավորումները"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Հարմարեցրեք գույների և տեքստի տեսքը ձեր էկրանի ֆոնի գույնին"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Նախադիտում"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Հելեն, Ադամ"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 օր առաջ"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Հիշեցնե՞լ"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Բիզնես ուղևորության հաշվետվություն"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Լրացուցիչ օգնության համար դիմեք \nինձ կամ Հելենին։ Այս հաղորդումը"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Հաճախորդի ծախսեր"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Էկրանի մգացում"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Կառավարման տարրեր"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Ժամանակի կարգավորումներ"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Շարունակել"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Չեղարկել"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Խոշորացման կարգավորումներ"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Խոշորացում դյուրանցման միջոցով"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Խոշորացնել դյուրանցման կամ եռակի հպելու օգնությամբ"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"«<xliff:g id="SERVICE">%1$s</xliff:g>» ծառայության մասին"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ոչ թափանցիկ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Բարձր կոնտրաստի տեքստ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Փոխեք տեքստի գույնը սևի կամ սպիտակի, որպեսզի ֆոնի հետ կոնտրասն առավելագույնի հասցվի։"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Ավելացրեք տեքստի կոնտրաստը"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Փոխեք տեքստի գույնը սևի կամ սպիտակի, որպեսզի ֆոնի հետ կոնտրաստն ավելանա։"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ավտոմատ թարմացնել էկրանի խոշորությունը"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Թարմացնել էկրանի խոշորությունը ծրագրի տարանցումների վրա"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Սնուցման կոճակը ավարտում է զանգը"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Սեղմած պահել ձայնի ուժգնության ստեղները"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Եռակի հպեք էկրանին"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Հատուկ կարգավորումների դյուրանցումների փոփոխում"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Ընտրեք դյուրանցում հետևյալ գործառույթների համար՝ %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Շարունակել"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Լսողական սարքեր"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Կարգավորեք և կառավարեք ASHA-ի և LE Audio-ի աջակցմամբ լսողական սարքերը, կոխլեար իմպլանտները և ձայնն ուժեղացնող այլ սարքեր"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Միացված լսողական սարքեր չկան"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Ավելացնել լսողական ապարատ"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Լսողական սարքի զուգակցում"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Լսողական սարքի համատեղելիություն"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Բարելավում է համատեղելիությունը լսողական սարքերի հետ և նվազեցնում անցանկալի աղմուկը"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Լսողական սարքերի մասին"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA-ի կամ LE Audio-ի կողմից չաջակցվող այլ լսողական սարքեր գտնելու համար հպեք "<b>"Զուգակցել նոր սարք"</b>" &gt; "<b>"Այլ սարքեր"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Լսողական սարքի զուգակցում"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Այս էջում կարող եք զուգակցել ASHA և LE Audio լսողական սարքերը։ Համոզվեք, որ ձեր լսողական սարքը միացված է և պատրաստ զուգակցման:"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Հասանելի լսողական սարքեր"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS-ներ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Ավտոմատ անցում բջջ․ ինտերնետին"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Օգտագործեք բջջային ինտերնետ ցանկացած SIM քարտից՝ կախված ծածկույթից և հասանելիությունից"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Միայն բջջային ինտերնետ"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Կարգավորել"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Հաջորդը"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Օգնում է որոշել այն մոտակա սարքերի հարաբերական դիրքավորումը, որոնք աջակցում են UWB տեխնոլոգիան"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Անջատել ավիառեժիմը՝ UWB-ն օգտագործելու համար"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB-ն անհասանելի է ընթացիկ տեղադրությունում"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Խելացի տան անխափան աշխատանքի համար Thread-ի միջոցով միացեք աջակցվող սարքերի"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Անջատել ավիառեժիմը՝ Thread-ն օգտագործելու համար"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Տեսախցիկն օգտագործելու թույլտվություն"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Խոսափողն օգտագործելու թույլտվություն"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Հավելվածների և ծառայությունների համար"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Չեղարկել"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Կոնտրաստ"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Սովորական"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Կանխադրված"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Միջին"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Բարձր"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Այս հավելվածը հնարավոր է բացել միայն մեկ պատուհանում"</string>
diff --git a/res/values-in/arrays.xml b/res/values-in/arrays.xml
index 15ec935..7cac682 100644
--- a/res/values-in/arrays.xml
+++ b/res/values-in/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Perlakukan sebagai berkuota"</item>
     <item msgid="2047166446768045816">"Perlakukan sebagai tanpa kuota"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Gunakan MAC acak (default)"</item>
-    <item msgid="741680937828608749">"Gunakan MAC perangkat"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Tidak"</item>
     <item msgid="2163015208097377388">"Ya"</item>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index b0e2e8d..b2ea1b0 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Sambungkan ke telinga kanan"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Sambungkan ke telinga kiri"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Untuk semua alat bantu dengar yang tersedia"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Setelan alat bantu dengar lainnya"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Ubah setelan lintas perangkat seperti pintasan, dan kontrol telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Untuk perangkat ini"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Output audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Tentang output audio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Menyiapkan ruang pribadi…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Notifikasi dari aplikasi ruang privasi disembunyikan saat ruang privasi dikunci"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Pelajari setelan ruang privasi untuk menyembunyikan ruang privasi dan menyiapkan penguncian otomatis"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Aplikasi yang diperlukan sudah diinstal di ruang privasi"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Tidak dapat menyiapkan ruang privasi"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Coba Lagi"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Gunakan kunci layar untuk membuka ruang pribadi?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikasi dan notifikasi"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notifikasi sensitif di layar kunci"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Menampilkan konten sensitif saat ruang privasi tidak terkunci"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Buat Akun Google untuk membantu menjaga privasi data Anda"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Di layar berikutnya, Anda dapat login ke akun yang akan digunakan dengan ruang privasi"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Buat akun khusus untuk membantu mencegah data muncul di luar ruang privasi, seperti:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Foto, file, email, kontak, acara kalender, dan data lainnya yang disinkronkan"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Rekomendasi dan histori download aplikasi"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Histori penjelajahan, bookmark, dan sandi tersimpan"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Konten yang disarankan terkait aktivitas Anda di aplikasi ruang privasi"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Oke"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Anda dapat menambahkan maksimal <xliff:g id="COUNT">%d</xliff:g> sidik jari"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Anda telah menambahkan jumlah maksimum sidik jari"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Tidak dapat menambahkan sidik jari lagi"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operator Anda tidak mengizinkan Anda terhubung ke jaringan ini karena jaringan tersebut menggunakan protokol keamanan lama yang kurang aman"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Izinkan WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Tutup"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Putuskan koneksi dengan <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Anda terhubung ke jaringan WEP. Jika Anda memblokir jaringan ini, koneksi jaringan Anda akan terputus."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opsi lanjutan"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Menu drop-down Opsi Lanjutan"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"luaskan"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Gunakan <xliff:g id="NEW_APP">%s</xliff:g> untuk mengelola koneksi jaringan?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Permintaan lokasi terbaru"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokasi untuk profil kerja"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Izin akses lokasi aplikasi"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokasi nonaktif"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# dari {total} aplikasi memiliki akses ke lokasi}other{# dari {total} aplikasi memiliki akses ke lokasi}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Gunakan keyboard virtual"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Biarkan di layar meski keyboard fisik aktif"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Tombol Pantul"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Keyboard mengabaikan penekanan tombol yang sama secara berulang dan cepat dalam <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> md"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Tombol lambat"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Menyesuaikan waktu yang diperlukan agar penekanan tombol aktif ke <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> md"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Tombol Lekat"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Tekan satu tombol pada satu waktu untuk mengaktifkan pintasan, bukan menekan tombol secara bersamaan"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Pintasan keyboard"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Tampilkan daftar pintasan"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Keyboard &amp; fitur profil kerja"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Reset"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Pilih tombol pengubah"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Pilih tombol baru untuk <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Tata letak <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Default"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Otomatis: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Dipilih pengguna: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Ucapan"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Kecepatan kursor"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Pengendali Game"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Anda dapat menyesuaikan perangkat ini sesuai kebutuhan. Fitur aksesibilitas ini dapat diubah nanti di Setelan."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Ubah ukuran font"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Pembaca layar"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opsi keyboard fisik"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Teks"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Umum"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Tampilan"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Warna dan gerakan"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kontras warna"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Kontras yang lebih tinggi membuat teks, tombol, dan ikon tampak lebih jelas. Pilih kontras yang paling sesuai bagi Anda."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Beberapa aplikasi mungkin tidak mendukung semua setelan kontras teks dan warna"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Sesuaikan tampilan warna dan teks dengan warna latar belakang layar"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Pratinjau"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 hari lalu"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Tindak lanjuti?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Laporan perjalanan bisnis"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Untuk mendapatkan bantuan lebih lanjut, hubungi \nsaya atau Helen. Laporan ini kan"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Pengeluaran Klien"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Buat layar lebih gelap"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrol interaksi"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrol waktu"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Tetap lanjutkan"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Batal"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Setelan pembesaran"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Perbesar dengan pintasan"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Perbesar dengan pintasan &amp; ketuk tiga kali"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Tentang <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Tidak transparan"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Teks kontras tinggi"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Ubah warna teks ke hitam atau putih. Memaksimalkan kontras dengan latar belakang."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimalkan kontras teks"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Ubah warna teks menjadi hitam atau putih untuk meningkatkan kontras dengan latar belakang."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Perbarui otomatis pembesaran layar"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Perbarui pembesaran layar di transisi aplikasi"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Tombol daya untuk tutup telepon"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Tahan tombol volume"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Ketuk layar tiga kali"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edit pintasan aksesibilitas"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Pilih pintasan Anda untuk %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Lanjutkan"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Alat bantu dengar"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Siapkan dan kelola alat bantu dengar, implan koklea, dan perangkat amplifikasi lainnya yang mendukung ASHA dan LE Audio"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Tidak ada alat bantu dengar yang terhubung"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Tambahkan alat bantu dengar"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Sambungkan ke alat bantu dengar"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilitas alat bantu dengar"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Meningkatkan kompatibilitas dengan telecoil dan mengurangi kebisingan yang tidak diinginkan"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Tentang alat bantu dengar"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Untuk menemukan alat bantu dengar lain yang tidak didukung oleh ASHA atau LE Audio, ketuk "<b>"Sambungkan perangkat baru"</b>" &gt; "<b>"Lihat perangkat lainnya"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Sambungkan alat"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Anda dapat menyambungkan alat bantu dengar LE Audio dan ASHA di halaman ini. Pastikan alat bantu dengar Anda telah diaktifkan dan siap disambungkan."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Alat bantu dengar yang tersedia"</string>
@@ -4169,7 +4147,7 @@
     <string name="run_backup_tasks_title" msgid="8572480651659803275">"Menjalankan tugas pencadangan di latar belakang"</string>
     <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Izinkan aplikasi menjalankan tugas latar belakang terkait pencadangan"</string>
     <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Menunjukkan bahwa aplikasi ini memiliki kasus penggunaan besar yang memerlukan pencadangan atau sinkronisasi konten. Pemberian izin ini memungkinkan aplikasi untuk berjalan di latar belakang dengan waktu yang sedikit lebih lama, guna menyelesaikan tugas terkait pencadangan. \n\nJika izin ini ditolak, sistem tidak akan memberikan pengecualian khusus ke aplikasi ini untuk menyelesaikan tugas terkait pencadangan di latar belakang."</string>
-    <string name="keywords_run_backup_tasks" msgid="632219905465766211">"mencadangkan tugas, mencadangkan tugas"</string>
+    <string name="keywords_run_backup_tasks" msgid="632219905465766211">"mencadangkan tugas, mencadangkan pekerjaan"</string>
     <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Reset pembatasan frekuensi ShortcutManager"</string>
     <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Pembatasan kecepatan PengelolaPintasan telah direset"</string>
     <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrol info di layar kunci"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Pesan teks"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Pengalihan data otomatis"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Gunakan data dari salah satu SIM tergantung pada cakupan dan ketersediaan"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Khusus data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Siapkan"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Berikutnya"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Membantu mengidentifikasi posisi relatif perangkat di sekitar yang memiliki UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Nonaktifkan mode pesawat untuk menggunakan UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB tidak tersedia di lokasi saat ini"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Menghubungkan ke perangkat yang kompatibel menggunakan Thread untuk pengalaman smart home yang lancar"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Nonaktifkan mode pesawat untuk menggunakan Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Akses kamera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Akses mikrofon"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Untuk aplikasi dan layanan"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Batal"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontras"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standar"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Default"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Sedang"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Tinggi"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Aplikasi ini hanya dapat dibuka di 1 jendela"</string>
diff --git a/res/values-is/arrays.xml b/res/values-is/arrays.xml
index 7919fe8..fab4ca9 100644
--- a/res/values-is/arrays.xml
+++ b/res/values-is/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Meðhöndla sem mælt"</item>
     <item msgid="2047166446768045816">"Meðhöndla sem ótakmarkað"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Nota MAC-vistfang af handahófi (sjálfgefið)"</item>
-    <item msgid="741680937828608749">"Nota MAC-vistfang tækis"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nei"</item>
     <item msgid="2163015208097377388">"Já"</item>
diff --git a/res/values-is/strings.xml b/res/values-is/strings.xml
index 5991419..e480c03 100644
--- a/res/values-is/strings.xml
+++ b/res/values-is/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Para hægra eyra"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Para vinstra eyra"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Fyrir öll heyrnartæki sem eru í boði"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Fleiri stillingar heyrnartækis"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Breyttu stillingum á milli tækja, s.s. stýringum flýtileiða og tónmöskvaspólu."</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Fyrir þetta tæki"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Hljóðúttak"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Um hljóðúttak"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Setur upp einkarými…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Tilkynningar frá forritum í leynirými eru faldar þegar rýmið er læst"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Skoðaðu stillingar leynirýmis til að fela það og setja upp sjálfvirka læsingu"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Áskilin forrit eru þegar sett upp í leynirýminu"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Ekki tókst að setja upp leynirými"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Reyna aftur"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Nota skjálás til að taka einkarýmið úr lás?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Forrit og tilkynnignar"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Viðkvæmar tilkynningar á lásskjá"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Sýna viðkvæmt efni þegar leynirými er ólæst"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Stofnaðu Google-reikning til að hjálpa til við að halda gögnunum þínum lokuðum"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Á næstu síðu geturðu skráð þig inn á reikninginn sem þú vilt nota fyrir leynirýmið"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Stofnaðu þar til gerðan reikning til að hjálpa til við að koma í veg fyrir að gögnin þín birtist utan leynirýmis, s.s:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Samstilltar myndir, skrár, tölvupóstar, tengiliðir, dagatalsviðburðir og önnur gögn"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Niðurhalsferill og tillögur forrita"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Vafraferill, bókamerki og vistuð aðgangsorð"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Tillögur að efni sem tengist virkni þinni í forritum í leynirýminu"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Ég skil"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Þú getur bætt við allt að <xliff:g id="COUNT">%d</xliff:g> fingraförum"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Þú hefur bætt við hámarksfjölda fingrafara"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Ekki er hægt að bæta fleiri fingraförum við"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Símafyrirtækið þitt leyfir þér ekki að tengjast þessu netkerfi vegna þess að það notar eldri öryggissamskiptareglu sem er ekki eins örugg"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Leyfa WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Loka"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Viltu aftengjast frá <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Þú ert tengd(ur) við WEP netkerfi. Ef þú lokar á þessi netkerfi verður þú aftengd(ur)."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Ítarlegri valkostir"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Ítarlegir valkostir fellilista"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"Opna"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Nota <xliff:g id="NEW_APP">%s</xliff:g> til að stjórna nettengingunum þínum?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nýlegar staðsetningarbeiðnir"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Staðsetning vinnusniðs"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Staðsetningarheimildir forrits"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Slökkt á staðsetningu"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# af {total} forritum hefur aðgang að staðsetningu}one{# af {total} forritum hefur aðgang að staðsetningu}other{# af {total} forritum hafa aðgang að staðsetningu}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Nota skjályklaborð"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Haltu því á skjánum meðan vélbúnaðarlyklaborðið er virkt"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Endurkastslyklar"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Lyklaborðið hunsar snöggan endurtekinn innslátt á sama lykilinn innan <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Hægir lyklar"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Stillir tímann sem það tekur lyklainnslátt að virka í <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Festilyklar"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Ýttu á einn lykil í einu fyrir flýtilykla í staðinn fyrir að halda lyklum saman niðri"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Flýtilyklar"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Sýna lista yfir flýtileiðir"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Lyklaborð og verkfæri vinnusniðs"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Endurstilla"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Velja breytilykil"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Veldu nýjan lykil fyrir <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Útlit: <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Sjálfgefið"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Sjálfvirkt: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Valið af notanda: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Tal"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Hraði bendils"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Leikjafjarstýring"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Þú getur sérsniðið þetta tæki eftir þínum þörfum. Þessum aðgengiseiginleikum má breyta síðar í stillingunum."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Breyta leturstærð"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Skjálesari"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Efnislegir valkostir lyklaborðs"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Skjátextar"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Hljóð"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Almennt"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Skjár"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Litur og hreyfing"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Birtuskil lita"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Aukin birtuskil gera texta, hnappa og tákn enn greinilegri. Veldu þau birtuskil sem henta þér best."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Sum forrit styðja hugsanlega ekki allar stillingar fyrir birtustig lita og texta"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Stilltu hvernig litir og textar birtast á bakgrunnslit skjásins"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Forskoða"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Fyrir 2 dögum"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Fylgja eftir?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Skýrsla um vinnuferð"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Hafðu samband við \nmig eða Helen ef þú þarft á frekari aðstoð að halda. Þessi skýrsla verður"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Kostnaður viðskiptavinar"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Dekkja skjáinn"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Gagnvirknistýringar"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Tímastýringar"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Halda samt áfram"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Hætta við"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Stillingar stækkunar"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Stækka með flýtilykli"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Stækka með flýtilykli og með því að ýta þrisvar"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Um þjónustuna „<xliff:g id="SERVICE">%1$s</xliff:g>“"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ógagnsætt"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texti með miklum birtuskilum"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Breyta textalit í svartan eða hvítan. Dregur fram birtuskil í bakgrunni."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Hámarkaðu birtuskil texta"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Breyttu lit á texta í svartan eða hvítan til að auka birtuskil miðað við bakgrunninn."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Uppfæra skjástækkun sjálfkrafa"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Uppfæra skjástækkun þegar skipt er milli forrita"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Aflrofi lýkur símtali"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Halda inni hljóðstyrkstökkum"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Ýta þrisvar á skjá"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Breyta aðgengisflýtileiðum"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Veldu flýtilykil fyrir %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Áfram"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Heyrnartæki"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Setja upp og stjórna hljóðstreymi fyrir heyrnartæki (ASHA) og LE-hljóðs-heyrnartæki, kuðungsígræðslur og önnur mögnunartæki"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Engin heyrnartæki eru tengd"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Bæta við heyrnartækjum"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Para heyrnartæki"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Samhæfi við heyrnartæki"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Bætir samhæfi við T-spólur og dregur úr óæskilegum hljóðum"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Um heyrnartæki"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Til að finna heyrnartæki sem eru ekki studd af hljóðstreymi fyrir heyrnartæki (ASHA) eða LE-hljóði skaltu ýta á "<b>"Para nýtt tæki"</b>" &gt; "<b>"Sjá fleiri tæki"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Para heyrnartæki"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Þú getur parað heyrnartæki með hljóðstreymi (ASHA) og LE-hljóð á þessari síðu. Gakktu úr skugga um að kveikt sé á heyrnartækjunum og þau tilbúin til pörunar."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Tiltæk heyrnartæki"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS-skilaboð"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Sjálfvirk gagnaskipting"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Nota gögn af öðru hvoru SIM-korti byggt á umfangi og tiltækileika"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Aðeins gögn"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Setja upp"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Áfram"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Hjálpar til við að auðkenna hlutfallslega staðsetningu nálægra tækja með ofurbreiðband (UWB)."</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Slökkva á flugstillingu til að nota ofurbreiðband (UWB)"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Ofurbreiðband (UWB) er ekki í boði á núverandi staðsetningu"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Tengdu við samhæf tæki sem nota Thread fyrir hnökralausa snjallheimilisupplifun"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Slökkva á flugstillingu til að nota Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Aðgangur að myndavél"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Aðgangur að hljóðnema"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Fyrir forrit og þjónustu"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Hætta við"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Birtuskil"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Staðlað"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Sjálfgefið"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Miðlungs"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Mikið"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Aðeins er hægt að opna þetta forrit í 1 glugga"</string>
diff --git a/res/values-it/arrays.xml b/res/values-it/arrays.xml
index 9679ba4..733de52 100644
--- a/res/values-it/arrays.xml
+++ b/res/values-it/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Considera a consumo"</item>
     <item msgid="2047166446768045816">"Considera non a consumo"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Usa MAC casuale (opzione predefinita)"</item>
-    <item msgid="741680937828608749">"Usa MAC del dispositivo"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"No"</item>
     <item msgid="2163015208097377388">"Sì"</item>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index 055c4d2..588d6dd 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Accoppia orecchio destro"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Accoppia orecchio destro"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Per tutte le protesi uditive disponibili"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Altre impostazioni delle protesi uditive"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Modifica le impostazioni cross-device, come scorciatoie e controlli telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Per questo dispositivo"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Uscita audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Informazioni su uscita audio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configurazione dello spazio privato in corso…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Le notifiche delle app nello spazio privato vengono nascoste quando quest\'ultimo è bloccato"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Esplora le impostazioni dello spazio privato per nasconderlo e configurare il blocco automatico"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Le app obbligatorie sono già installate nel tuo spazio privato"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Impossibile configurare uno spazio privato"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Riprova"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Usare blocco schermo per sbloccare spazio privato?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"App e notifiche"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notifiche sensibili sulla schermata di blocco"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Mostra contenuti sensibili quando lo spazio privato è sbloccato"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Crea un Account Google per mantenere privati i tuoi dati"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Nella schermata successiva puoi accedere a un account da usare con lo spazio privato"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Crea un account dedicato per impedire la visualizzazione dei dati al di fuori dello spazio privato, ad esempio:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Foto, file, contatti email, eventi nel calendario e altri dati sincronizzati"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Cronologia dei download delle app e consigli"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Cronologia di navigazione, preferiti e password salvate"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Contenuti suggeriti in base alla tua attività nelle app dello spazio privato"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Ok"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Puoi aggiungere fino a <xliff:g id="COUNT">%d</xliff:g> impronte digitali"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Hai aggiunto il numero massimo di impronte digitali"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Impossibile aggiungere ulteriori impronte digitali"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Il tuo operatore non consente la connessione a questa rete perché utilizza un protocollo di sicurezza meno recente e meno sicuro"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Consenti le reti WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Chiudi"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Disconnettersi da <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Hai eseguito la connessione a una rete WEP. Se blocchi queste reti, verrà eseguita la disconnessione."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opzioni avanzate"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Elenco a discesa Opzioni avanzate"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"espandi"</string>
@@ -1319,7 +1306,7 @@
     <string name="pin_failed" msgid="3726505565797352255">"Operazione con PIN della SIM non riuscita."</string>
     <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Aggiornamenti di sistema"</string>
     <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
-    <string name="firmware_version" msgid="1606901586501447275">"Versione di Android"</string>
+    <string name="firmware_version" msgid="1606901586501447275">"Versione Android"</string>
     <string name="security_patch" msgid="4071756145347865382">"Aggiornamento della sicurezza Android"</string>
     <string name="model_info" msgid="8997566254717810904">"Modello"</string>
     <string name="hardware_revision" msgid="3454709180861965025">"Versione hardware"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Utilizzare <xliff:g id="NEW_APP">%s</xliff:g> per gestire le connessioni di rete?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Richieste di posizione recenti"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Posizione per profilo di lavoro"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Autorizzazioni per la posizione"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"La geolocalizzazione non è attiva"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# app su {total} ha accesso alla posizione}other{# app su {total} hanno accesso alla posizione}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Usa tastiera sullo schermo"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Tienila sullo schermo quando è attiva la tastiera fisica"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Tasti rimbalzati"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"La tastiera ignora pressioni ripetute velocemente dello stesso tasto entro <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Tasti lenti"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Regola il tempo richiesto per l\'attivazione della pressione di un tasto su <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Tasti permanenti"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Premi un tasto alla volta per le scorciatoie invece di tenere premuti più tasti contemporaneamente"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Scorciatoie da tastiera"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostra l\'elenco di scorciatoie"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastiere e strumenti del profilo di lavoro"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Reimposta"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Scegli un tasto di modifica"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Scegli un nuovo tasto per <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Predefinito"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Voce"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Velocità del puntatore"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Controller di gioco"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Puoi personalizzare questo dispositivo in base alle tue esigenze. Queste funzioni di accessibilità possono essere modificate in un secondo momento nelle Impostazioni."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Cambia dimensioni carattere"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Screen reader"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opzioni tastiera fisica"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Sottotitoli codificati"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Generali"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Visualizzazione"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Colore e movimento"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contrasto di colore"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Un contrasto più elevato rende testi, pulsanti e icone più distinguibili. Scegli il contrasto più adatto a te."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Alcune app potrebbero non supportare tutte le impostazioni di contrasto di colore e del testo"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Regola l\'aspetto dei colori e del testo rispetto al colore dello sfondo del tuo schermo"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Anteprima"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 giorni fa"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Ricontattare?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Report della trasferta"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Per ulteriore assistenza, contatta \nme o Helen. Questo report sarà"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Spese del cliente"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Scurisci lo schermo"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Controlli di interazione"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Controlli basati sul tempo"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continua comunque"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Annulla"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Impostazioni ingrandimento"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ingrandisci con scorciatoia"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ingrandisci con scorciatoia e triplo tocco"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Informazioni su <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Non trasparente"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Testo ad alto contrasto"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Cambia il colore del testo in bianco o nero. Massimizza il contrasto con lo sfondo."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Massimizza il contrasto del testo"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Cambia il colore del testo in bianco o nero per aumentare il contrasto con lo sfondo."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Aggiorn. autom. ingrandim. schermo"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Aggiorna ingrandimento schermo per transizioni app"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Chiudi chiamata con tasto accensione"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Tieni premuti i tasti del volume"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tocca tre volte lo schermo"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Modificare le scorciatoie di accessibilità"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Scegli la scorciatoia per %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continua"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Protesi uditive"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configura e gestisci apparecchi acustici, impianti cocleari e altri dispositivi di amplificazione ASHA ed LE Audio"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nessuna protesi uditiva connessa"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Aggiungi apparecchi acustici"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Accoppia apparecchi acustici"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilità con apparecchi acustici"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Aumenta la compatibilità con telecoil e riduce i rumori indesiderati"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Informazioni sulle protesi uditive"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Per trovare altre protesi uditive non supportate da ASHA o LE Audio, tocca "<b>"Accoppia nuovo dispositivo"</b>" &gt; "<b>"Visualizza altri dispositivi"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Accoppia protesi uditiva"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"In questa pagina, puoi accoppiare le protesi uditive ASHA e LE audio. Assicurati che la tua protesi uditiva sia accesa e pronta per l\'accoppiamento."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Protesi uditive disponibili"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Passaggio dati automatico"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Utilizza i dati di entrambe le SIM in base alla copertura e alla disponibilità"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Solo dati"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configura"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Avanti"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Consente di identificare la posizione relativa dei dispositivi nelle vicinanze dotati di tecnologia UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Viene disattivata la modalità aereo per usare la tecnologia UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB non disponibile nella posizione corrente"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Connettiti a dispositivi compatibili usando Thread per un\'esperienza con la smart home senza interruzioni"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Disattiva la modalità aereo per usare Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Accesso alla fotocamera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Accesso al microfono"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Per app e servizi"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Annulla"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contrasto"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Valore predefinito"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Medio"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Alto"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Questa app può essere aperta soltanto in 1 finestra"</string>
diff --git a/res/values-iw/arrays.xml b/res/values-iw/arrays.xml
index 3419f7f..814f1f6 100644
--- a/res/values-iw/arrays.xml
+++ b/res/values-iw/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"יש להתייחס כרשת עם חיוב לפי שימוש בנתונים"</item>
     <item msgid="2047166446768045816">"יש להתייחס כרשת שבה החיוב הוא לא לפי שימוש בנתונים"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"‏שימוש בכתובת MAC אקראית (ברירת מחדל)"</item>
-    <item msgid="741680937828608749">"‏שימוש בכתובת ה-MAC של המכשיר"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"לא"</item>
     <item msgid="2163015208097377388">"כן"</item>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index 83c2a44..754d560 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"התאמה באוזן ימין"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"התאמה באוזן שמאל"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"לכל מכשירי השמיעה הזמינים"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"הגדרות נוספות של מכשיר השמיעה"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"‏שינוי הגדרות שמקושרות למכשיר אחר כמו אמצעי בקרה לקיצורי דרך ו-Telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"למכשיר הזה"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"פלט אודיו"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"מידע על פלט האודיו"</string>
@@ -588,25 +586,17 @@
     <string name="no_device_lock_cancel" msgid="4412602160321228863">"ביטול"</string>
     <string name="private_space_cancel_label" msgid="379259667396956886">"ביטול"</string>
     <string name="private_space_setup_button_label" msgid="2094882154623560585">"הגדרה"</string>
-    <!-- no translation found for private_space_setup_title (2272968244329821450) -->
-    <skip />
-    <!-- no translation found for private_space_hide_apps_summary (4418722947376042418) -->
-    <skip />
-    <!-- no translation found for private_space_setup_sub_header (5454598292017819146) -->
-    <skip />
-    <!-- no translation found for private_space_separate_account_text (4492251315012955548) -->
-    <skip />
-    <!-- no translation found for private_space_protected_lock_text (9123250938334372735) -->
-    <skip />
-    <!-- no translation found for private_space_install_apps_text (5693139160766464498) -->
-    <skip />
+    <string name="private_space_setup_title" msgid="2272968244329821450">"המרחב הפרטי"</string>
+    <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"‏הסתרה או נעילה של אפליקציות פרטיות במרחב נפרד. שימוש בחשבון Google ייעודי לאבטחה נוספת."</string>
+    <string name="private_space_setup_sub_header" msgid="5454598292017819146">"הגדרת המרחב הפרטי שלך"</string>
+    <string name="private_space_separate_account_text" msgid="4492251315012955548">"‏"<b>"בחירת חשבון Google לשימוש במרחב הפרטי"</b>\n"שימוש בחשבון ייעודי עוזר למנוע הופעה של קבצים, תמונות ואימיילים מסונכרנים מחוץ למרחב הפרטי"</string>
+    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"הגדרת נעילה"</b>\n"אפשר לנעול את המרחב הפרטי כדי למנוע מאנשים אחרים לפתוח אותו"</string>
+    <string name="private_space_install_apps_text" msgid="5693139160766464498">"‏"<b>"התקנת אפליקציות"</b>\n"למרחב הפרטי שלך יש חנות Play משלו כך שאפשר להתקין אפליקציות בקלות."</string>
     <string name="private_space_apps_permission_text" msgid="7030946025253366172">"אפליקציות במרחב הפרטי לא יופיעו בניהול ההרשאות, במרכז הבקרה להגדרות הפרטיות ובהגדרות אחרות כשהמרחב הפרטי נעול.\n\nלא ניתן להעביר את המרחב הפרטי למכשיר חדש. עליך להגדיר מרחב פרטי אחר אם ברצונך להשתמש בו במכשיר אחר.\n\nכל מי שיחבר את המכשיר שלך למחשב או יתקין אפליקציות מזיקות במכשיר שלך יוכל לגשת למרחב הפרטי שלך."</string>
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"הגדרת המרחב הפרטי מתבצעת…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ההתראות מהאפליקציות במרחב הפרטי מוסתרות כשהוא נעול"</string>
-    <!-- no translation found for private_space_explore_settings_title (1448128245941571654) -->
-    <skip />
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_explore_settings_title" msgid="1448128245941571654">"אפשר לבדוק את ההגדרות של המרחב הפרטי כדי להסתיר את המרחב הפרטי ולהגדיר נעילה אוטומטית"</string>
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"האפליקציות הנדרשות כבר מותקנות במרחב הפרטי שלך"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"לא ניתן להגדיר מרחב פרטי"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ניסיון נוסף"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"להשתמש בנעילת המסך כדי לבטל את נעילת המרחב הפרטי?"</string>
@@ -629,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"אפליקציות והתראות"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"התראות רגישות במסך הנעילה"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"הצגת תוכן רגיש כשהמרחב הפרטי פתוח"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"‏מומלץ ליצור חשבון Google כדי לשמור על פרטיות הנתונים"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"במסך הבא אפשר להיכנס לחשבון שישמש למרחב הפרטי"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"כדאי ליצור חשבון ייעודי כדי שנתונים לא יופיעו מחוץ למרחב הפרטי, למשל:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"תמונות מסונכרנות, קבצים, אימיילים, אנשי קשר, אירועים ביומן ונתונים אחרים"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"היסטוריית ההורדות של אפליקציות והמלצות"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"היסטוריית הגלישה, סימניות וסיסמאות שמורות"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"תוכן מוצע שקשור לפעילות שלך באפליקציות המרחב הפרטי"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"הבנתי"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"אפשר להוסיף עד <xliff:g id="COUNT">%d</xliff:g> טביעות אצבע"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"הוספת את המספר המרבי של טביעות אצבע."</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"לא ניתן להוסיף עוד טביעות אצבע"</string>
@@ -933,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"הספק שלך לא מאפשר לך להתחבר לרשת הזו כי היא משתמשת בפרוטוקול אבטחה ישן יותר ופחות מאובטח"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"‏הרשאה ל-WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"סגירה"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"להתנתק מ-<xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"‏התחברת לרשת WEP. אם הרשתות האלה ייחסמו, החשבון שלך יתנתק."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"אפשרויות מתקדמות"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"רשימה נפתחת של אפשרויות מתקדמות"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"הרחבה"</string>
@@ -969,14 +949,10 @@
     <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"‏עדיפות לתדר 5.0 GHz"</string>
     <string name="wifi_ip_settings" msgid="6420498748726599133">"‏הגדרות IP"</string>
     <string name="wifi_privacy_settings" msgid="3283946009000725698">"פרטיות"</string>
-    <!-- no translation found for wifi_privacy_mac_settings (3188060664478313363) -->
-    <skip />
-    <!-- no translation found for wifi_privacy_device_name_settings (3699130177041345275) -->
-    <skip />
-    <!-- no translation found for wifi_privacy_send_device_name_toggle_title (1228107313152880073) -->
-    <skip />
-    <!-- no translation found for wifi_privacy_send_device_name_toggle_summary (5995365836332817655) -->
-    <skip />
+    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"MAC"</string>
+    <string name="wifi_privacy_device_name_settings" msgid="3699130177041345275">"שם המכשיר"</string>
+    <string name="wifi_privacy_send_device_name_toggle_title" msgid="1228107313152880073">"שליחת שם המכשיר"</string>
+    <string name="wifi_privacy_send_device_name_toggle_summary" msgid="5995365836332817655">"שיתוף שם המכשיר הזה ברשת"</string>
     <string name="wifi_subscription" msgid="4432423938285430113">"מינוי"</string>
     <string name="wifi_subscription_summary" msgid="18802471063384598">"הצגה או שינוי של מינוי"</string>
     <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"‏כתובת MAC אקראית"</string>
@@ -1564,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"האם להשתמש ב-<xliff:g id="NEW_APP">%s</xliff:g> כדי לנהל את חיבורי הרשת שלך?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"בקשות של מיקומים אחרונים"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"מיקום עבור פרופיל עבודה"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"הרשאות מיקום של אפליקציות"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"תכונת המיקום כבויה"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{לאחת (#) מתוך {total} אפליקציות יש גישה למיקום}one{ל-# מתוך {total} אפליקציות יש גישה למיקום}two{ל-# מתוך {total} אפליקציות יש גישה למיקום}other{ל-# מתוך {total} אפליקציות יש גישה למיקום}}"</string>
@@ -1897,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"שימוש במקלדת שמופיעה במסך"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"תישאר במסך בזמן שהמקלדת הפיזית פעילה"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"מקשים חוזרים"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"המקלדת מתעלמת מלחיצות מהירות חוזרות על אותו המקש שנעשות תוך <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> אלפיות השנייה"</string>
     <string name="slow_keys" msgid="2891452895499690837">"מקשים איטיים"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"שינוי משך הזמן להפעלה של לחיצה על מקש ל-<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> אלפיות השנייה"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"מקשים \"דביקים\""</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"לוחצים על מקש אחד בכל פעם לקיצורי הדרך במקום ללחוץ על המקשים יחד"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"מקשי קיצור"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"הצגת רשימה של מקשי הקיצור"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"מקלדות וכלים בפרופיל העבודה"</string>
@@ -1958,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"איפוס"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"בחירת מקש צירוף"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"יש לבחור מפתח חדש עבור <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"פריסה של <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ברירת מחדל"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"אוטומטי: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"המשתמש שנבחר: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"דיבור"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"מהירות המצביע"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"בקר משחק"</string>
@@ -2014,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ניתן להתאים אישית את המכשיר הזה כך שיתאים לצרכים שלך. אפשר לשנות את תכונות הנגישות מאוחר יותר ב\'הגדרות\'."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"שינוי גודל הגופן"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"קורא מסך"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"אפשרויות של מקלדת פיזית"</string>
     <string name="captions_category_title" msgid="574490148949400274">"כתוביות"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"אודיו"</string>
     <string name="general_category_title" msgid="6298579528716834157">"הגדרות כלליות"</string>
     <string name="display_category_title" msgid="6638191682294461408">"תצוגה"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"צבע ותנועה"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"ניגודיות של צבעים"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"ניגודיות גבוהה יותר מבליטה את הטקסט, הלחצנים והסמלים. כדאי לבחור את הניגודיות שמתאימה לך."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"חלק מהאפליקציות לא תומכות בכל הגדרות הצבע והניגודיות של הטקסט"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"אפשר להתאים את מראה הצבעים והטקסט לצבע הרקע של המסך"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"תצוגה מקדימה"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"ציפורה, פנחס"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"לפני יומיים"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"להמשיך בטיפול?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"דוח על נסיעת העסקים"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"לסיוע נוסף, אפשר לפנות אליי\nאו לציפורה הדוח הזה יהיה"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"הוצאות הלקוח"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"הכהיית המסך"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"פקדי אינטראקציה"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"הגדרות תזמון"</string>
@@ -2092,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"אני רוצה להמשיך בכל זאת"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"ביטול"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"הגדרות ההגדלה"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"הגדלה בעזרת קיצור דרך"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"הגדלה בעזרת קיצור דרך והקשה שלוש פעמים"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"מידע על <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2179,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"לא שקוף"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"טקסט בניגודיות גבוהה"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"שינוי צבע הטקסט לשחור או לבן. ניגודיות מקסימלית לצבע הרקע."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"הגדלת הניגודיות של הטקסט למקסימום"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"ניתן לשנות את צבע הטקסט לשחור או לבן כדי להגביר את הניגודיות עם הרקע."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"עדכון אוטומטי של הגדלת מסך"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"עדכון הגדלת מסך במעבר בין אפליקציות"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"לחצן ההפעלה מסיים שיחה"</string>
@@ -2278,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"לחיצה ארוכה על לחצני עוצמת הקול"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"מסך של הקשה שלוש פעמים"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"עריכת קיצורי הדרך לנגישות"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"‏בחירת קיצור הדרך עבור %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"המשך"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"מכשירי שמיעה"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"‏הגדרה וניהול של מכשירי שמיעה של ASHA ו-LE Audio, שתלי שבלול ומכשירי הגברה אחרים"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"אין מכשירי שמיעה מחוברים"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"הוספת מכשירי שמיעה"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"התאמת מכשירי השמיעה"</string>
@@ -2301,11 +2269,9 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"תאימות למכשירי שמיעה"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"‏שיפור התאימות עם צימוד אינדוקטיבי (telecoil) והפחתת רעשים לא רצויים"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"מידע על מכשירי שמיעה"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"‏כדי למצוא מכשירי שמיעה אחרים שלא נתמכים על ידי ASHA או LE Audio, צריך להקיש על "<b>"התאמה של מכשיר חדש"</b>" &gt; "<b>"הצגת מכשירים נוספים"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"התאמה של מכשיר השמיעה"</string>
-    <!-- no translation found for accessibility_hearing_device_pairing_intro (7022201665808166517) -->
-    <skip />
+    <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"‏בעמוד הזה אפשר להתאים מכשירי שמיעה של ASHA ו-LE Audio. צריך לוודא שמכשיר השמיעה מופעל ומוכן להתאמה."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"מכשירי שמיעה זמינים"</string>
     <string name="accessibility_found_all_devices" msgid="7817834722148556520">"לא רואה את מכשיר השמיעה שלך?"</string>
     <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"הצגת מכשירים נוספים"</string>
@@ -4675,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"הודעות טקסט"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"מעבר אוטומטי בין חבילות גלישה"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"‏שימוש בחבילת הגלישה של אחד מכרטיסי ה-SIM, תלוי בכיסוי ובזמינות"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"נתונים בלבד"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"הגדרה"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"הבא"</string>
@@ -4954,12 +4926,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"‏עזרה בזיהוי המיקום היחסי של מכשירים עם תחום רחב סרט (UWB) בקרבת מקום"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"‏כיבוי מצב טיסה לשימוש בתחום רחב סרט (UWB)"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"‏UWB לא זמין במיקום הנוכחי"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"‏פרוטוקול Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"‏התחברות למכשירים תואמים באמצעות פרוטוקול Thread לחוויה חלקה של בית חכם"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"‏צריך להשבית את מצב הטיסה כדי להשתמש בפרוטוקול Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"גישה למצלמה"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"גישה למיקרופון"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"לאפליקציות ולשירותים"</string>
@@ -5136,8 +5105,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"ביטול"</string>
     <string name="contrast_title" msgid="6885768151336508075">"ניגודיות"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"רגילה"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ברירת המחדל"</string>
     <string name="contrast_medium" msgid="384414510709285811">"בינונית"</string>
     <string name="contrast_high" msgid="3988567609694797696">"גבוהה"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"ניתן לפתוח את האפליקציה הזו רק בחלון אחד"</string>
diff --git a/res/values-ja/arrays.xml b/res/values-ja/arrays.xml
index b81c77b..20f4229 100644
--- a/res/values-ja/arrays.xml
+++ b/res/values-ja/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"従量制として扱う"</item>
     <item msgid="2047166446768045816">"定額制として扱う"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ランダム MAC を使用（デフォルト）"</item>
-    <item msgid="741680937828608749">"デバイスの MAC を使用"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"いいえ"</item>
     <item msgid="2163015208097377388">"はい"</item>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 15bb7f4..158e7a2 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"このネットワークは安全性の低い旧式のセキュリティ プロトコルを使用しているため、ご利用の携帯通信会社では接続が許可されていません"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP を許可する"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"閉じる"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> との接続を解除しますか？"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP ネットワークに接続しました。これらのネットワークをブロックすると、接続が解除されます。"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"詳細設定"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"プルダウン リスト、詳細設定"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"展開"</string>
@@ -1542,6 +1540,7 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"ネットワーク接続の管理に<xliff:g id="NEW_APP">%s</xliff:g>を使用しますか？"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"最近の位置情報リクエスト"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"仕事用プロファイルで位置情報を使用"</string>
+    <string name="private_profile_location_switch_title" msgid="4127119143109855789">"プライベート スペースの場所"</string>
     <string name="location_app_level_permissions" msgid="907206607664629759">"アプリへの位置情報の利用許可"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"位置情報は OFF です"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} 個中 # 個のアプリに位置情報へのアクセスを許可しています}other{{total} 個中 # 個のアプリに位置情報へのアクセスを許可しています}}"</string>
@@ -1875,14 +1874,11 @@
     <string name="show_ime" msgid="4334255501724746849">"画面キーボードの使用"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"物理キーボードが有効になっていても画面に表示させます"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"バウンスキー"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ミリ秒以内にキーボードの同じキーが連続で押された場合は、その操作を無視します"</string>
     <string name="slow_keys" msgid="2891452895499690837">"スローキー"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"押されたキーが有効になるまでの時間を <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ミリ秒に設定します"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"固定キー"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"ショートカットで複数のキーを同時に押すのではなく 1 つずつ押します"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"キーボード ショートカット"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"ショートカットのリストを表示"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"仕事用プロファイルのキーボードとツール"</string>
@@ -1936,7 +1932,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"リセット"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"修飾キーを選択"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> の新しいキーを選択してください"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"レイアウト: <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"デフォルト"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"自動: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"ユーザーによる選択: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"読み上げ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"ポインタの速度"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"ゲーム用コントローラ"</string>
@@ -1992,8 +1991,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"このデバイスを必要に応じてカスタマイズできます。このユーザー補助機能は後から [設定] で変更できます。"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"フォントサイズを変更する"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"スクリーン リーダー"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"物理キーボードのオプション"</string>
     <string name="captions_category_title" msgid="574490148949400274">"字幕"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"音声"</string>
     <string name="general_category_title" msgid="6298579528716834157">"全般"</string>
@@ -2059,6 +2057,9 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"無視して続行"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"キャンセル"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"画面の拡大設定"</string>
+    <string name="accessibility_magnification_one_finger_panning_title" msgid="4503949739883092989">"指 1 本でのパン操作"</string>
+    <string name="accessibility_magnification_one_finger_panning_summary_on" msgid="9133125894310777539">"1 本の指でドラッグして拡大領域を移動します。"</string>
+    <string name="accessibility_magnification_one_finger_panning_summary_off" msgid="8979146350396559805">"2 本の指でドラッグして拡大領域を移動します。"</string>
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ショートカットで拡大"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ショートカットとトリプルタップで拡大"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>について"</string>
@@ -2243,12 +2244,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"音量ボタンを長押し"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"画面をトリプルタップ"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ユーザー補助のショートカットの編集"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s のショートカットの選択"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"続行"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"補聴器"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA や LE Audio に対応した補聴器や人工内耳などの聴覚補助器を設定、管理できます"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"補聴器が接続されていません"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"補聴器を追加する"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"補聴器のペア設定"</string>
@@ -2266,8 +2265,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"補聴器両立性"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"テレコイルとの両立性を改善し、不要なノイズを軽減できます"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"補聴器について"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA や LE Audio に対応していない他の補聴器を探すには、["<b>"新しいデバイスとペア設定"</b>"] &gt; ["<b>"他の機器を見る"</b>"] をタップします"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"補聴器とのペア設定"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"このページで ASHA と LE Audio 補聴器をペア設定できます。補聴器の電源が入っていて、ペア設定できる状態であることをご確認ください。"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"使用可能な補聴器"</string>
@@ -4639,6 +4637,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"テキスト メッセージ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"自動データ切り替え"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"サービスの対象エリアや提供状況に応じて、いずれかの SIM のデータを使用します"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"データのみ"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"設定"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"次へ"</string>
@@ -4917,12 +4921,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB を搭載した付近のデバイスの相対位置の特定に役立ちます"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB を使用するには機内モードを OFF にしてください"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"現在の場所では UWB は利用できません"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"対応デバイスに Thread で接続して、シームレスなスマートホームを実現できます"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread を使用するには機内モードを OFF にしてください"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"カメラへのアクセス"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"マイクへのアクセス"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"アプリとサービスによるアクセス"</string>
diff --git a/res/values-ka/arrays.xml b/res/values-ka/arrays.xml
index 1030cc0..234b65d 100644
--- a/res/values-ka/arrays.xml
+++ b/res/values-ka/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"ლიმიტირებულად ჩათვლა"</item>
     <item msgid="2047166446768045816">"არალიმიტირებულად ჩათვლა"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"შემთხვევითი MAC-ის გამოყენება (ნაგულ.)"</item>
-    <item msgid="741680937828608749">"მოწყობილობის MAC-მისამართის გამოყენება"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"არა"</item>
     <item msgid="2163015208097377388">"დიახ"</item>
diff --git a/res/values-ka/strings.xml b/res/values-ka/strings.xml
index ed6a29f..aed91cc 100644
--- a/res/values-ka/strings.xml
+++ b/res/values-ka/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"დააწყვილეთ მარჯვენა დინამიკი"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"მარცხენა დინამიკის დაკავშირება"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"სმენის ყველა ხელმისაწვდომი აპარატისთვის"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"სმენის აპარატის სხვა პარამეტრები"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"შეცვალეთ ისეთი მოწყობილობათაშორისი პარამეტრები, როგორიცაა მალსახმობები და ტელეკოილის კონტროლები"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"ამ მოწყობილობისთვის"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"გამომავალი აუდიო"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"აუდიოს გამოსატანის შესახებ"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"მიმდინარეობს პირადი სივრცის დაყენება…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"კერძო სივრცის აპების შეტყობინებები დამალულია, როცა ის ჩაკეტილია"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"გაეცანით კერძო სივრცის პარამეტრებს ავტომატური ჩაკეტვის დასაყენებლად და კერძო სივრცის დასამალად"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"მოთხოვნილი აპები უკვე დაინსტალირებულია თქვენს კერძო სივრცეში"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"კერძო სივრცის დაყენება ვერ მოხერხდა"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ხელახლა ცდა"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"გსურთ ეკრანის დაბლოკვის გამოყენება პირადი სივრცის განსაბლოკად?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"აპები და შეტყობინებები"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"სენსიტიური შეტყობინებები ჩაკეტილ ეკრანზე"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"სენსიტიური კონტენტის ჩვენება, როდესაც კერძო სივრცე განბლოკილია"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"შექმენით Google ანგარიში თქვენი მონაცემების კონფიდენციალურობის შენარჩუნებისთვის"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"შემდეგ ეკრანზე შეგიძლიათ შეხვიდეთ ანგარიშში, რათა გამოიყენოთ ის თქვენს კერძო სივრცესთან ერთად"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"შექმენით სპეციალური ანგარიში, რომელიც დაგეხმარებათ შეაჩეროთ თქვენი კერძო სივრცის გარეთ შემდეგი მონაცემების გამოჩენა:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"სინქრონიზებული ფოტოები, ელფოსტები, კონტაქტები, კალენდარის მოვლენები და სხვა ინფორმაცია"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"აპლიკაციების ჩამოტვირთვების ისტორია და რეკომენდაციები"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"დათვალიერების ისტორია, სანიშნეები და შენახული პაროლები"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"კერძო სივრცის აპლიკაციებში თქვენი აქტივობის შესაბამისი შემოთავაზებული კონტენტი"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"გასაგებია"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"შეგიძლიათ დაამატოთ მაქსიმუმ <xliff:g id="COUNT">%d</xliff:g> თითის ანაბეჭდი"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"თქვენ უკვე დაამატეთ თითის ანაბეჭდების მაქსიმალური რაოდენობა"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"მეტი თითის ანაბეჭდის დამატება ვერ ხერხდება"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"თქვენი ოპერატორი გიკრძალავთ ამ ქსელთან დაკავშირებას, რადგან ის იყენებს დაცვის შედარებით ძველ პროტოკოლს, რომელიც ნაკლებად დაცულია"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP-ს დაშვება"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"დახურვა"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"გსურთ <xliff:g id="NAME">%1$s</xliff:g>-თან კავშირის გათიშვა?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"თქვენ WEP ქსელთან ხართ დაკავშირებული. თუ ამ ქსელებს დაბლოკავთ, კავშირი გაწყდება."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"დამატებითი პარამეტრები"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ჩამოსაშლელი სიის დამატებითი პარამეტრები"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"გაფართოება"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"გსურთ ქსელის კავშირების სამართავად <xliff:g id="NEW_APP">%s</xliff:g>-ის გამოყენება?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"მდებარეობის ბოლო მოთხოვნები"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ადგილმდებარეობა სამუშაო პროფილისათვის"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"აპის მდებარეობის ნებართვები"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"მდებარეობა გამორთულია"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{მდებარეობაზე წვდომა აქვს {total}-დან # აპს}other{მდებარეობაზე წვდომა აქვს {total}-დან # აპს}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ეკრანული კლავიატურის გამოყენება"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"აქტიური ფიზიკური კლავიატურისას ეკრანზე შენარჩუნება"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"კლავიშების ასხლეტა"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"კლავიატურა აიგნორებს <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> მილიწამის განმავლობაში ერთსა და იმავე კლავიშზე სწრაფ, განმეორებით დაჭერებს"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ნელი კლავიშები"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"არეგულირებს დროს, რომელიც სჭირდება კლავიშის დაჭერას <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> მილიწამამდე აქტივაციისთვის"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"კლავიშების ფიქსაცია"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"მალსახმობებისთვის დააჭირეთ კლავიშებს ცალ-ცალკე და არა ერთდროულად"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"კლავიატურის მალსახმობები"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"მალსახმობების სიის ჩვენება"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"სამსახურის პროფილის კლავიატურა და ხელსაწყოები"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"გადაყენება"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"აირჩიეთ მოდიფიკატორი კლავიში"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"აირჩიეთ ახალი კლავიში <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>-ისთვის:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> განლაგება"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ნაგულისხმევი"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"ავტომატური: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"მომხმარებლის მიერ არჩეული: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"მეტყველება"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"მანიშნებლის სიჩქარე"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"თამაშის მეთვალყურე"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ამ მოწყობილობის მორგება თქვენი საჭიროებების შესაბამისად შეგიძლიათ. მარტივი წვდომის ამ პარამეტრების მოგვიანებით შეცვლა პარამეტრებიდან არის შესაძლებელი."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"შრიფტის ზომის შეცვლა"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"ეკრანის წამკითხველი"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ფიზიკური კლავიატურის ვარიანტები"</string>
     <string name="captions_category_title" msgid="574490148949400274">"სუბტიტრები"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"აუდიო"</string>
     <string name="general_category_title" msgid="6298579528716834157">"ზოგადი"</string>
     <string name="display_category_title" msgid="6638191682294461408">"ეკრანი"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"ფერი და მოძრაობა"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"ფერთა კონტრასტი"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"მაღალი კონტრასტი ტექსტს, ღილაკებსა და ხატულებს მეტად გამოკვეთს. აირჩიეთ თქვენთვის საუკეთესო კონტრასტი."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"ზოგიერთ აპს არ აქვს ყველა ფერისა და ტექსტის კონტრასტის პარამეტრების მხარდაჭერა"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"დაარეგულირეთ ფერები და ტექსტი თქვენი ეკრანის ფონის ფერთან მიმართებაში"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"გადახედვა"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"ჰელენ, ადამ"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 დღის წინ"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"გსურთ გაგრძელება?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"საქმიანი ვიზიტის ანგარიში"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"დამატებითი დახმარებისთვის მოგვმართეთ \nმე ან ჰელენს. ეს ანგარიში იქნება"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"კლიენტის ხარჯები"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"ეკრანის მუქი რეჟიმის ჩართვა"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ინტერაქციის მართვის საშუალებები"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"დროის მართვა"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"მაინც გაგრძელება"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"გაუქმება"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"გადიდების პარამეტრები"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"გადიდება მალსახმობით"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"გადიდება მალსახმობითა და სამმაგი შეხებით"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>-ის შესახებ"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"გაუმჭვირვალე"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"მაღალკონტრასტიანი ტექსტი"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"ტექსტის ფერის შავით ან თეთრით შეცვლა. აძლიერებს კონტრასტს ფონთან."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"ტექსტის კონტრასტის მაქსიმიზაცია"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"შეცვალეთ ტექსტის ფერი შავზე ან თეთრზე ფონის კონტრასტის გაზრდისთვის."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"ეკრანის მასშტაბის ავტომატური განახლება"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"ეკრანის მასშტაბის განახლება ერთი აპიდან მეორეზე გადასვლისას"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"ზარი შეწყდება ჩართვის ღილაკზე დაჭერით"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"ხანგრძლივად გეჭიროთ ხმის ღილაკები"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"სამმაგად შეეხეთ ეკრანს"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"მარტივი წვდომის მალსახმობების რედაქტირება"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"აირჩიეთ თქვენი მალსახმობი %1$s-ისთვის"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"გაგრძელება"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"სმენის აპარატები"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA-ს და LE-აუდიოს სმენის მოწყობილობების, კოხლეარული იმპლანტების და სხვა გამაძლიერებელი მოწყობილობების დაყენება და მართვა"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"სმენის აპარატი არ არის დაკავშირებული"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"სმენის მოწყობილობების დამატება"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"სმენის მოწყობილობასთან დაწყვილება"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"სმენის აპარატებთან თავსებადობა"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"აუმჯობესებს თავსებადობას გადამცემებთან და ამცირებს არასასურველ ხმაურს"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"სმენის მოწყობილობების შესახებ"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"სხვა ისეთი სმენის აპარატების საპოვნელად, რომლებიც ASHA-ს ან LE-აუდიოს მიერ არ არის მხარდაჭერილი, შეეხეთ: "<b>"ახალი მოწყობილობის დაწყვილება"</b>" და "<b>"მეტი მოწყობილობების ნახვა"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"დაწყვილებ. სმენის აპარატი"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ASHA და LE-აუდიო სმენის აპარატები შეგიძლიათ ამ გვერდზე დააწყვილოთ. დარწმუნდით, რომ თქვენი სმენის აპარატი ჩართულია და მზად არის დასაწყვილებლად."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ხელმისაწვდომი სმენის აპარატები"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ტექსტი"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"მონაცემთა ავტომატური გადართვა"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"დაფარვისა და ხელმისაწვდომობის მიხედვით მონაცემების გამოყენება ნებისმიერი SIM-იდან"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"მხოლოდ ინტერნეტისთვის"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"კონფიგურაცია"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"შემდეგი"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"გეხმარებათ UWB-ის მქონე ახლომახლო მოწყობილობების პირობითი მდებარეობის დადგენაში"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB-ის გამოსაყენებლად გამორთეთ თვითმფრინავის რეჟიმი"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB არ არის ხელმისაწვდომი მიმდინარე ადგილას"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"გონიერი სახლის უნაკლო გამოცდილების მისაღებად, Thread-ის გამოყენებით დაუკავშირდით თავსებად მოწყობილობებს"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread-ის გამოსაყენებლად გამორთეთ თვითმფრინავის რეჟიმი"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"კამერაზე წვდომა"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"მიკროფონზე წვდომა"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"აპებისა და სერვისებისთვის"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"გაუქმება"</string>
     <string name="contrast_title" msgid="6885768151336508075">"კონტრასტი"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"სტანდარტული"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ნაგულისხმევი"</string>
     <string name="contrast_medium" msgid="384414510709285811">"საშუალო"</string>
     <string name="contrast_high" msgid="3988567609694797696">"მაღალი"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"ამ აპის გახსნა შესაძლებელია მხოლოდ 1 ფანჯარაში"</string>
diff --git a/res/values-kk/arrays.xml b/res/values-kk/arrays.xml
index 84a063c..54d6e5d 100644
--- a/res/values-kk/arrays.xml
+++ b/res/values-kk/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Трафик саналады"</item>
     <item msgid="2047166446768045816">"Трафик саналмайды"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Кездейсоқ MAC мекенжайын пайдалану (әдепкі)"</item>
-    <item msgid="741680937828608749">"Құрылғының MAC мекенжайын пайдалану"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Жоқ"</item>
     <item msgid="2163015208097377388">"Иә"</item>
diff --git a/res/values-kk/strings.xml b/res/values-kk/strings.xml
index 2a61506..e30d628 100644
--- a/res/values-kk/strings.xml
+++ b/res/values-kk/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Оң құлақты жұптау"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Сол құлақты жұптау"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Барлық қолжетімді есту құрылғысына қатысты"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Есту құрылғысының тағы басқа параметрлері"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Белгіше, индукциялық катушка басқару элементтері сияқты аралық құрылғы параметрлерін өзгерту"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Осы құрылғыға қатысты"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аудио шығысы"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Аудио шығысы туралы"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Жеке бөлме реттеліп жатыр…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Құпия кеңістік құлыптаулы кезде, ондағы қолданбалардан келетін хабарландырулар жасырылады"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Құпия кеңістікті жасырып, автоматты құлыптау функциясын орнату үшін құпия кеңістік параметрлерін көріңіз"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Қажетті қолданбалар құпия кеңістікке орнатылып қойған"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Құпия кеңістікті реттеу мүмкін болмады"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Қайталау"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Жеке бөлмеңіздің құлпы экран құлпымен ашылсын ба?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Қолданбалар мен хабарландырулар"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Құлып экранындағы құпия хабарландырулар"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Құпия кеңістік құлпы ашылған кезде шетін контентті көрсету."</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Деректерді құпия ұстауға көмектесетін Google аккаунтын жасау"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Келесі экранда құпия кеңістікті пайдалану үшін аккаунтыңызға кіре аласыз."</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Деректердің құпия кеңістіктен шығып кетуінің алдын алу үшін арнайы аккаунт жасаңыз, мысалы:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Синхрондалған фотосуреттер, файлдар, электрондық хаттар, контактілер, күнтізбедегі іс-шаралар және тағы басқа деректер"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Қолданба жүктеп алу тарихы және ұсыныстар"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Браузерді қолдану тарихы, бетбелгілер және сақталған құпия сөздер"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Құпия кеңістік қолданбаларындағы әрекетке қатысты ұсынылған контент"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Түсінікті"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"<xliff:g id="COUNT">%d</xliff:g> саусақ ізіне дейін қосуға болады"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Саусақ іздерінің максималды саны енгізілді"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Қосымша саусақ іздері енгізілмейді"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Қауіпсіздік деңгейі төмен ескі қауіпсіздік протоколы пайдаланылатындықтан, операторыңыз бұл желіге қосылуға рұқсат бермейді."</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP протоколына рұқсат беру"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Жабу"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> желісінен ажыратылсын ба?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP желісіне қосылдыңыз. Бұл желілерді блоктасаңыз, сіз ажыратыласыз."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Қосымша опциялар"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Қосымша опциялардың ашылмалы тізімі"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"жаю"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Желілік байланыстарды басқару үшін <xliff:g id="NEW_APP">%s</xliff:g> қолданбасын пайдалану керек пе?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Соңғы орынды анықтау сұраулары"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Жұмыс профиліндегі локация"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Қолданбалардың локацияны пайдалануы"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Локация өшірулі"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{#/{total} қолданба локацияны пайдалана алады.}other{#/{total} қолданба локацияны пайдалана алады.}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Экрандағы пернетақтаны пайдалану"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Физикалық пернетақта қосулы кезде оны экранға шығару"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Қайтару пернелері"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Пернетақта перненің <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> мс ішінде жылдам қайталап басылғанын елемейді."</string>
     <string name="slow_keys" msgid="2891452895499690837">"Баяу пернелер"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Перненің <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> мс ішінде іске қосылуына қажетті уақытты реттейді."</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Бекітілген пернелер"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Жылдам пәрмендерді пайдалану үшін пернелерді бірге баспай-ақ, бір пернені бір рет бассаңыз болады."</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Перне тіркесімдері"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Жылдам пәрмендер тізімін көрсету"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Жұмыс профилі пернетақталары және құралдары"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Қайта орнату"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Өзгерткіш перне таңдау"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> жаңа пернесін таңдау:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> форматы"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Әдепкі"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Автоматты: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Пайдаланушы таңдаған: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Сөз"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Меңзер жылдамдығы"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Ойын бақылаушы"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Бұл құрылғыны қажеттіліктерге сай реттей аласыз. Бұл арнайы мүмкіндіктерді кейінірек \"Параметрлер\" тармағында өзгертуге болады."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Қаріп өлшемін өзгерту"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Экранды оқу құралы"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Пернетақта опциялары"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Субтитр"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Аудио"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Жалпы"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Дисплей"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Түс және қозғалыс"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Түс конрасты"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Жоғары контраст мәтінді, түймелерді және белгішелерді ерекшелейді. Өзіңізге ұнайтын контрасты таңдаңыз."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Кейбір қолданбалар барлық түс және мәтін контрасты параметрін қолдамауы мүмкін."</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Түстер мен мәтінді экран фонына сәйкестендіріп реттеу"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Алғы көрініс"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Хелен, Адам"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 күн бұрын"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Жазыласыз ба?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Іссапар туралы есеп"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Қосымша көмек алу үшін \nмаған немесе Хеленге хабарласыңыз. Бұл есеп"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Клиент шығындары"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Экранды қараңғылау"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Басқару элементтері"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Уақытты басқару элементтері"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Бәрібір жалғастыру"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Бас тарту"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Ұлғайту параметрлері"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Таңбашамен үлкейту"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Таңбашамен және үш рет түртіп үлкейту"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> туралы ақпарат"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Мөлдір емес"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Жоғары контрасты мәтін"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Мәтін түсін қараға немесе аққа өзгертеді. Фонмен арадағы контрасты арттырады."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Мәтін контрастын арттыру"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Мәтін түсін қараға немесе аққа өзгертеді. Фонмен арадағы контрасты арттырады."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Экранды ұлғайтуды авто жаңарту"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Қолданба ауысуларындағы экран ұлғайту функциясын жаңарту"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Қуат түймесі арқылы қоңырауды үзу"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Дыбыс деңгейі пернелерін басып тұру"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Экранды үш рет түрту"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Арнайы мүмкіндіктер жылдам пәрмендерін өзгерту"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s үшін жылдам пәрмен таңдаңыз."</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Жалғастыру"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Есту аппараттары"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA және LE Audio есту құрылғыларын, кохлеарлы импланттарды және тағы басқа күшейткіш құрылғыларды реттеңіз және басқарыңыз."</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Есту құрылғылары жалғанбаған."</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Есту аппараттарын енгізу"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Есту аппаратын жұптау"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Есту аппаратының үйлесімділігі"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Телешарғылармен үйлесімділік деңгейін арттырып, қажетсіз шуды азайтады."</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Есту аппараттары туралы"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA немесе LE Audio қолдау көрсетпейтін басқа да есту құрылғыларын табу үшін "<b>"Жаңа құрылғы жұптау"</b>" және "<b>"Тағы басқа құрылғыларды көру"</b>" түймелерін түртіңіз."</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Есту аппаратын жұптау"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Осы бетте ASHA және LE Audio есту құрылғыларын жұптай аласыз. Есту құрылғысы қосулы және жұптауға дайын екеніне көз жеткізіңіз."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Қолжетімді есту аппараттары"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Мәтіндік хабарлар"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Деректерді автоматты ауыстыру"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Қызмет аясына және байланыста болуына қарай қажетті SIM картасының деректерін пайдаланыңыз."</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Тек деректер"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Реттеу"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Келесі"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB технологиясын пайдаланатын маңайдағы құрылғылардың қатысты орнын анықтауға көмектеседі."</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB технологиясын пайдалану үшін ұшақ режимі өшіріледі."</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Қазіргі локацияда кеңжолақты байланыс жоқ."</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Тізбек"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Үздіксіз смарт үй тәжірибесі үшін Тізбек протоколы арқылы үйлесімді құрылғыларға қосылыңыз."</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Тізбек протоколын пайдалану үшін ұшақ режимі өшіріледі."</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Камераны пайдалану"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Микрофонды пайдалану"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Қолданбалар мен қызметтерге арналған."</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Бас тарту"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Контраст"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Стандартты режим"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Әдепкі"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Орташа"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Жоғары"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Бұл қолданбаны тек 1 терезеден ашуға болады."</string>
diff --git a/res/values-km/arrays.xml b/res/values-km/arrays.xml
index cdf25f7..7c58cc3 100644
--- a/res/values-km/arrays.xml
+++ b/res/values-km/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"ចាត់​ទុកថាផ្អែកតាមទិន្នន័យដែលប្រើ"</item>
     <item msgid="2047166446768045816">"​ចាត់​ទុកថាមិនផ្អែកតាមទិន្នន័យដែលប្រើ"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ប្រើ MAC ចៃដន្យ (លំនាំដើម)"</item>
-    <item msgid="741680937828608749">"ប្រើ MAC ឧបករណ៍"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"ទេ"</item>
     <item msgid="2163015208097377388">"បាទ/ចាស"</item>
diff --git a/res/values-km/strings.xml b/res/values-km/strings.xml
index 6b73313..8e71d7b 100644
--- a/res/values-km/strings.xml
+++ b/res/values-km/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"ផ្គូផ្គងឧបករណ៍ជំនួយការស្ដាប់ខាងស្ដាំ"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"ផ្គូផ្គងឧបករណ៍ជំនួយការស្ដាប់ខាងឆ្វេង"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"សម្រាប់ឧបករណ៍ស្ដាប់ដែលមានទាំងអស់"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"ការកំណត់ឧបករណ៍ជំនួយការស្ដាប់ច្រើនទៀត"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"ផ្លាស់ប្ដូរការកំណត់ឆ្លងកាត់ឧបករណ៍ដូចជា ការគ្រប់គ្រងផ្លូវកាត់ និងមុខងារកែលម្អការស្ដាប់ជាដើម"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"សម្រាប់​ឧបករណ៍​នេះ"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ឧបករណ៍បញ្ចេញសំឡេង"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"អំពីឧបករណ៍បញ្ចេញសំឡេង"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"កំពុងរៀបចំបន្ទប់ឯកជន…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ការជូនដំណឹងពីកម្មវិធីនៅក្នុងលំហឯកជនត្រូវបានលាក់ នៅពេលលំហនេះត្រូវបានចាក់សោ"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"រុករកការកំណត់លំហឯកជន ដើម្បីលាក់លំហឯកជន និងរៀបចំការចាក់សោស្វ័យប្រវត្តិ"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"កម្មវិធីដែលចាំបាច់ត្រូវបានដំឡើងរួចហើយនៅក្នុងលំហឯកជនរបស់អ្នក"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"មិនអាចរៀបចំលំហឯកជនបានទេ"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ព្យាយាមម្ដងទៀត"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"ប្រើមុខងារចាក់សោអេក្រង់ ដើម្បីដោះសោបន្ទប់ឯកជនឬ?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"កម្មវិធី និងការជូនដំណឹង"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"ការជូនដំណឹងរសើបលើអេក្រង់ចាក់សោ"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"បង្ហាញខ្លឹមសារ​រសើប ពេលលំហឯកជនត្រូវបានដោះសោ"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"បង្កើតគណនី Google ដើម្បីជួយរក្សាទិន្នន័យរបស់អ្នកឱ្យមានលក្ខណៈឯកជន"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"អ្នកអាចចូលគណនីណាមួយ ដើម្បីប្រើជាមួយលំហឯកជនរបស់អ្នកនៅលើអេក្រង់បន្ទាប់"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"បង្កើតគណនីដាច់ដោយឡែក ដើម្បីជួយបញ្ឈប់ទិន្នន័យមិនឱ្យបង្ហាញនៅខាងក្រៅលំហឯកជន ដូចជា៖"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"រូបថត ឯកសារ អ៊ីមែល ទំនាក់ទំនង ព្រឹត្តិការណ៍ក្នុងប្រតិទិន និងទិន្នន័យដែលបានធ្វើសមកាលកម្មផ្សេងទៀត"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"ការណែនាំ និងប្រវត្តិទាញយកកម្មវិធី"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ប្រវត្តិរុករកតាមអ៊ីនធឺណិត ចំណាំ និងពាក្យសម្ងាត់ដែលបានរក្សាទុក"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"ខ្លឹមសារដែលបានណែនាំពាក់ព័ន្ធនឹងសកម្មភាពរបស់អ្នកនៅក្នុងកម្មវិធីលំហឯកជន"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"យល់ហើយ"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"អ្នកអាចបញ្ចូលស្នាមម្រាមដៃបានត្រឹម <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"អ្នក​បាន​បញ្ចូល​ស្នាម​ម្រាមដៃ​ដល់​ចំនួន​អតិបរមា​ហើយ"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"មិន​អាច​បញ្ចូល​ស្នាម​ម្រាមដៃ​បាន​ទៀត​ទេ"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"ក្រុមហ៊ុន​សេវាទូរសព្ទរបស់អ្នកមិនអនុញ្ញាតឱ្យអ្នកភ្ជាប់ទៅបណ្ដាញនេះទេ ដោយសារវាប្រើប្រូតូកូលសុវត្ថិភាពចាស់ ដែលមិនសូវមានសុវត្ថិភាព"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"អនុញ្ញាត WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"បិទ"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"ផ្ដាច់ពី <xliff:g id="NAME">%1$s</xliff:g> ឬ?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"អ្នកបានភ្ជាប់ទៅបណ្ដាញ WEP។ ប្រសិនបើអ្នកទប់ស្កាត់បណ្ដាញទាំងនេះ អ្នកនឹងត្រូវបានផ្ដាច់។"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"ជម្រើស​កម្រិត​ខ្ពស់"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ជម្រើស​កម្រិតខ្ពស់​នៃបញ្ជីធ្លាក់ចុះ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ពង្រីក"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"ប្រើ <xliff:g id="NEW_APP">%s</xliff:g> ដើម្បី​គ្រប់គ្រង​ការ​ភ្ជាប់​បណ្ដាញ​របស់​អ្នក?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"សំណើ​ទីតាំង​ថ្មី"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ទីតាំងសម្រាប់កម្រងព័ត៌មានការងារ"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ការអនុញ្ញាតទីតាំងកម្មវិធី"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"ទីតាំង​បាន​បិទ"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{កម្មវិធី # នៃ {total} មានសិទ្ធិ​ចូលប្រើ​ទីតាំង}other{កម្មវិធី # នៃ {total} មានសិទ្ធិ​ចូលប្រើ​ទីតាំង}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ប្រើក្ដារចុច​លើអេក្រង់"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"រក្សា​នៅលើអេក្រង់ ពេលក្តារចុចរូបវ័ន្តកំពុងធ្វើ​​ប្រតិបត្តិការ"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"គ្រាប់ចុចលោត"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"ក្ដារចុចមិនអើពើនឹងការចុចដដែលៗយ៉ាងរហ័សនៃគ្រាប់ចុចដដែលក្នុងរយៈពេល <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> មិល្លីវិនាទី"</string>
     <string name="slow_keys" msgid="2891452895499690837">"គ្រាប់ចុចយឺត"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"កែតម្រូវរយៈពេលដែលប្រើសម្រាប់ការចុចគ្រាប់ចុច ដើម្បីបើកដំណើរការដល់ <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> មិល្លីវិនាទី"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"គ្រាប់ចុចស្អិត"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"ចុចគ្រាប់ចុចមួយក្នុងមួយលើកសម្រាប់ផ្លូវកាត់ជំនួសឱ្យការចុចគ្រាប់ចុចឱ្យជាប់រួមគ្នា"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"ផ្លូវកាត់ក្តារចុច"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"បង្ហាញបញ្ជីផ្លូវកាត់"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"ឧបករណ៍ និងក្ដារចុច​កម្រងព័ត៌មាន​ការងារ"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"កំណត់​ឡើងវិញ"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"ជ្រើសរើស​ប៊ូតុងឧបករណ៍កែសម្រួល"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"ជ្រើសរើសប៊ូតុងថ្មីសម្រាប់ <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>៖"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"លំនាំដើម"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"ការ​និយាយ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"ល្បឿន​ព្រួញ"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"កម្មវិធី​ពិនិត្យ​ល្បែង"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"អ្នកអាចកំណត់ឧបករណ៍នេះឲ្យស្របតាម​តម្រូវការរបស់អ្នក។ មុខងារភាព​ងាយស្រួលទាំងនេះអាចផ្លាស់​ប្តូរនៅពេលក្រោយបាននៅក្នុងការកំណត់។"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ប្ដូរ​ទំហំពុម្ពអក្សរ"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"កម្មវិធី​អាន​អេក្រង់"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ជម្រើសក្ដារចុចរូបវន្ត"</string>
     <string name="captions_category_title" msgid="574490148949400274">"អក្សររត់"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"សំឡេង"</string>
     <string name="general_category_title" msgid="6298579528716834157">"ទូទៅ"</string>
     <string name="display_category_title" msgid="6638191682294461408">"បង្ហាញ"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"ពណ៌ និងចលនា"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"កម្រិតពណ៌"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"កម្រិតពណ៌កាន់តែខ្ពស់ធ្វើឱ្យអក្សរ ប៊ូតុង និងរូបតំណាងកាន់តែលេចធ្លោ។ សូមជ្រើសរើសកម្រិតពណ៌ដែលមើលទៅល្អបំផុតសម្រាប់អ្នក។"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"កម្មវិធីមួយចំនួនប្រហែលជាមិនអាចប្រើការកំណត់កម្រិតពណ៌ និងកម្រិតពណ៌អក្សរទាំងអស់បានទេ"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"កែតម្រូវលក្ខណៈពណ៌ និងអក្សរធៀបនឹងពណ៌ផ្ទៃខាងក្រោយរបស់អេក្រង់អ្នក"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"មើលសាកល្បង"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 ថ្ងៃមុន"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ទាក់ទងបន្តឬ?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"របាយការណ៍អំពីការធ្វើដំណើរបែបធុរកិច្ច"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"សម្រាប់ជំនួយបន្ថែម សូមទាក់ទងមក\nខ្ញុំផ្ទាល់ ឬ Helen។ របាយការណ៍នេះនឹង"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Client Expenses"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"ធ្វើឱ្យអេក្រង់ងងឹតជាងមុន"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ការ​គ្រប់គ្រង​អន្តរកម្ម"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"ការគ្រប់គ្រងការកំណត់ពេល"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"មិនអីទេ បន្តចុះ"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"បោះបង់"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"ការកំណត់​ការពង្រីក"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ពង្រីកដោយប្រើផ្លូវកាត់"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ពង្រីកដោយប្រើផ្លូវកាត់ និងចុចបីដង"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"អំពី <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"មិនថ្លា"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"អក្សរពន្លឺបញ្ច្រាស​​កម្រិត​​ខ្ពស់"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"ប្ដូរពណ៌អក្សរទៅខ្មៅ ឬស។ បង្កើនពន្លឺបញ្ច្រាសក្នុងកម្រិតខ្ពស់បំផុតដោយប្រើផ្ទៃខាងក្រោយ។"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"បង្កើនកម្រិតពណ៌អក្សរ"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"ផ្លាស់ប្ដូរពណ៌អក្សរទៅខ្មៅឬស ដើម្បីបង្កើនកម្រិតពណ៌នៅផ្ទៃខាងក្រោយ។"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"ធ្វើ​បច្ចុប្បន្នភាព​ការ​ពង្រីក​អេក្រង់​ស្វ័យប្រវត្តិ"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"ធ្វើ​បច្ចុប្បន្ន​ភាព​ការ​ពង្រីក​អេក្រង់​ពេល​មាន​ដំណើរ​ផ្លាស់​ប្ដូរ​កម្មវិធី"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"ប៊ូតុងថាមពល​បញ្ចប់​ការ​ហៅ"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"សង្កត់គ្រាប់ចុច​កម្រិតសំឡេង​ឱ្យជាប់"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"ចុចអេក្រង់​បីដង"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"កែផ្លូវកាត់ភាពងាយស្រួល"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"ជ្រើសរើសផ្លូវកាត់របស់អ្នកសម្រាប់ %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"បន្ត"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"ឧបករណ៍ជំនួយការស្ដាប់"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"រៀបចំ និងគ្រប់គ្រងឧបករណ៍​ជំនួយការ​ស្ដាប់ ASHA និង LE Audio, ឧបករណ៍​អេឡិចត្រូនិក​ក្នុងខ្លួនមនុស្ស​សម្រាប់ជំនួយការស្ដាប់ និងឧបករណ៍បង្កើនសំឡេង"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"មិនបានភ្ជាប់ឧបករណ៍ជំនួយការស្ដាប់ទេ"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"បញ្ចូល​ឧបករណ៍​ជំនួយការ​ស្ដាប់"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"ផ្គូផ្គងឧបករណ៍ជំនួយការស្ដាប់"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"ភាពត្រូវគ្នាជាមួយនឹង​ឧបករណ៍​ជំនួយការ​ស្ដាប់"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"កែលម្អភាពត្រូវគ្នាជាមួយឧបករណ៍ទទួលសញ្ញា និងកាត់បន្ថយសំឡេងរំខានដែលមិនចង់បាន"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"អំពីឧបករណ៍ជំនួយការស្ដាប់"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ដើម្បីស្វែងរកឧបករណ៍ជំនួយការស្ដាប់ផ្សេងទៀតដែលមិនអាចប្រើជាមួយ ASHA ឬ LE Audio សូមចុច"<b>"ផ្គូផ្គងឧបករណ៍ថ្មី"</b>" &gt; "<b>"មើលឧបករណ៍ច្រើនទៀត"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"ផ្គូផ្គងឧបករណ៍ស្តាប់"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"អ្នកអាចផ្គូផ្គងឧបករណ៍ជំនួយការស្ដាប់ ASHA និង LE Audio នៅលើទំព័រនេះ។ ត្រូវប្រាកដថា ឧបករណ៍ជំនួយការស្ដាប់របស់អ្នកត្រូវបានបើក និងអាចផ្គូផ្គងបាន។"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ឧបករណ៍ជំនួយការស្ដាប់ដែលប្រើបាន"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"សារ​ជាអក្សរ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ការប្ដូរទិន្នន័យស្វ័យប្រវត្តិ"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"ប្រើទិន្នន័យពីស៊ីមណាមួយដោយផ្អែកលើដែនសេវា និងភាពអាចប្រើប្រាស់បាន"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ទិន្នន័យតែប៉ុណ្ណោះ"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"រៀបចំ"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"បន្ទាប់"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"ជួយ​កំណត់ចម្ងាយ​ពាក់ព័ន្ធនៃ​ឧបករណ៍នៅជិត​ដែលមាន UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"បិទមុខងារ​ពេលជិះយន្តហោះ ដើម្បីប្រើ UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"មិនអាចប្រើ UWB នៅក្នុងទីតាំងបច្ចុប្បន្នបានទេ"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"ភ្ជាប់ជាមួយឧបករណ៍ដែលត្រូវគ្នាដោយប្រើ Thread ដើម្បីទទួលបានបទពិសោធប្រើប្រាស់ផ្ទះឆ្លាតវៃរលូន"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"បិទមុខងារ​ពេល​ជិះ​យន្តហោះ ដើម្បីប្រើ Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"ការចូលប្រើ​កាមេរ៉ា"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"ការចូលប្រើ​មីក្រូហ្វូន"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"សម្រាប់កម្មវិធី និងសេវាកម្ម"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"បោះបង់"</string>
     <string name="contrast_title" msgid="6885768151336508075">"កម្រិត​រំលេចពណ៌"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"ស្តង់ដារ"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"លំនាំដើម"</string>
     <string name="contrast_medium" msgid="384414510709285811">"មធ្យម"</string>
     <string name="contrast_high" msgid="3988567609694797696">"ខ្ពស់"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"អាចបើកកម្មវិធីនេះបានតែក្នុងវិនដូ 1 ប៉ុណ្ណោះ"</string>
diff --git a/res/values-kn/arrays.xml b/res/values-kn/arrays.xml
index 8991e0f..a762ed7 100644
--- a/res/values-kn/arrays.xml
+++ b/res/values-kn/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"ಮೀಟರ್ ಮಾಡಿದೆ ಎಂದು ಪರಿಗಣಿಸಿ"</item>
     <item msgid="2047166446768045816">"ಮೀಟರ್ ಮಾಡಲಾಗಿಲ್ಲ ಎಂದು ಪರಿಗಣಿಸಿ"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ಯಾದೃಚ್ಛಿಕವಾದ MAC (ಡೀಫಾಲ್ಟ್) ಅನ್ನು ಬಳಸಿ"</item>
-    <item msgid="741680937828608749">"ಸಾಧನದ MAC ಬಳಸಿ"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"ಇಲ್ಲ"</item>
     <item msgid="2163015208097377388">"ಹೌದು"</item>
diff --git a/res/values-kn/strings.xml b/res/values-kn/strings.xml
index 952d2a5..f4ac6bb 100644
--- a/res/values-kn/strings.xml
+++ b/res/values-kn/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"ಬಲಕಿವಿಯ ಶ್ರವಣ ಸಾಧನವನ್ನು ಜೋಡಿಸಿ"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"ಎಡಕಿವಿಯ ಶ್ರವಣ ಸಾಧನವನ್ನು ಜೋಡಿಸಿ"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಶ್ರವಣ ಸಾಧನಗಳಿಗೆ"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"ಇನ್ನಷ್ಟು ಹಿಯರಿಂಗ್ ಸಾಧನದ ಸೆಟ್ಟಿಂಗ್‌ಗಳು"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"ಶಾರ್ಟ್‌ಕಟ್ ಮತ್ತು ಟೆಲಿಕಾಲ್ ನಿಯಂತ್ರಣಗಳಂತಹ ಕ್ರಾಸ್-ಸಾಧನದ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಿ"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"ಈ ಸಾಧನಕ್ಕಾಗಿ"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ಆಡಿಯೋ ಔಟ್‌ಪುಟ್"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ಆಡಿಯೋ ಔಟ್‌ಪುಟ್ ಕುರಿತು"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"ಖಾಸಗಿ ಸ್ಪೇಸ್ ಅನ್ನು ಸೆಟಪ್ ಮಾಡಲಾಗುತ್ತಿದೆ…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್ ಆ್ಯಪ್‌ಗಳು ಲಾಕ್ ಆಗಿರುವಾಗ ಅದರಲ್ಲಿರುವ ನೋಟಿಫಿಕೇಶನ್‌ಗಳನ್ನು ಮರೆಮಾಡಲಾಗುತ್ತದೆ"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್ ಅನ್ನು ಮರೆಮಾಡಲು ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಲಾಕಿಂಗ್ ಅನ್ನು ಸೆಟಪ್ ಮಾಡಲು ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಎಕ್ಸ್‌ಪ್ಲೋರ್ ಮಾಡಿ"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"ಅಗತ್ಯವಿರುವ ಆ್ಯಪ್‌ಗಳನ್ನು ಈಗಾಗಲೇ ನಿಮ್ಮ ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಲಾಗಿದೆ"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್ ಅನ್ನು ಸೆಟಪ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ಪುನಃ ಪ್ರಯತ್ನಿಸಿ"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"ಖಾಸಗಿ ಸ್ಪೇಸ್ ಅನ್‌ಲಾಕ್ ಮಾಡಲು ಸ್ಕ್ರೀನ್ ಲಾಕ್ ಬಳಸಬೇಕೇ?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"ಆ್ಯಪ್‌ಗಳು ಮತ್ತು ನೋಟಿಫಿಕೇಶನ್‌ಗಳು"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"ಲಾಕ್ ಸ್ಕ್ರೀನ್‌ನಲ್ಲಿ ಸೂಕ್ಷ್ಮವಾದ ನೋಟಿಫಿಕೇಶನ್‌ಗಳು"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್ ಅನ್‌ಲಾಕ್ ಆಗಿರುವಾಗ ಸೆನ್ಸಿಟಿವ್ ಕಂಟೆಂಟ್ ತೋರಿಸಿ"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಖಾಸಗಿಯಾಗಿಡುವುದಕ್ಕೆ ಸಹಾಯ ಮಾಡಲು Google ಖಾತೆಯನ್ನು ರಚಿಸಿ"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"ಮುಂದಿನ ಸ್ಕ್ರೀನ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್ ಮೂಲಕ ಬಳಸಲು ನೀವು ಖಾತೆಗೆ ಸೈನ್ ಇನ್ ಮಾಡಬಹುದು"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್‌ನ ಹೊರಗೆ ಡೇಟಾ ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ನಿಲ್ಲಿಸುವುದಕ್ಕೆ ಸಹಾಯ ಮಾಡಲು ಮೀಸಲಿರುವ ಖಾತೆಯನ್ನು ರಚಿಸಿ, ಉದಾಹರಣೆಗೆ:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"ಸಿಂಕ್ ಮಾಡಿದ ಫೋಟೋಗಳು, ಫೈಲ್‌ಗಳು, ಇಮೇಲ್‌ಗಳು, ಸಂಪರ್ಕಗಳು, ಕ್ಯಾಲೆಂಡರ್ ಈವೆಂಟ್‌ಗಳು ಮತ್ತು ಇತರ ಡೇಟಾ"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"ಆ್ಯಪ್ ಡೌನ್‌ಲೋಡ್ ಇತಿಹಾಸ ಮತ್ತು ಶಿಫಾರಸುಗಳು"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ಬ್ರೌಸಿಂಗ್ ಇತಿಹಾಸ, ಬುಕ್‌ಮಾರ್ಕ್‌ ಹಾಗೂ ಸೇವ್‌ ಮಾಡಿದ ಪಾಸ್‌ವರ್ಡ್‌"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"ಪ್ರೈವೆಟ್ ಸ್ಪೇಸ್ ಆ್ಯಪ್‌ಗಳಲ್ಲಿ ನಿಮ್ಮ ಚಟುವಟಿಕೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಸೂಚಿಸಲಾದ ಕಂಟೆಂಟ್‌"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"ಅರ್ಥವಾಯಿತು"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"ನೀವು ಗರಿಷ್ಠ <xliff:g id="COUNT">%d</xliff:g> ಫಿಂಗರ್‌ಪ್ರಿಂಟ್‌‌ಗಳನ್ನು ಸೇರಿಸಬಹುದು"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"ನೀವು ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಫಿಂಗರ್ ಪ್ರಿಂಟ್‌ಗಳನ್ನು ಸೇರಿಸಿರುವಿರಿ"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"ಹೆಚ್ಚಿನ ಫಿಂಗರ್ ಪ್ರಿಂಟ್‌ಗಳನ್ನು ಸೇರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"ನಿಮ್ಮ ವಾಹಕವು ಈ ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಕನೆಕ್ಟ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಅದು ಕಡಿಮೆ ಸುರಕ್ಷಿತವಾಗಿರುವ ಹಳೆಯ ಭದ್ರತಾ ಪ್ರೊಟೊಕಾಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP ಅನ್ನು ಅನುಮತಿಸಿ"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"ಮುಚ್ಚಿರಿ"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> ನಿಂದ ಡಿಸ್‌ಕನೆಕ್ಟ್ ಮಾಡುವುದೇ?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"ನೀವು WEP ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಕನೆಕ್ಟ್ ಆಗಿದ್ದೀರಿ. ನೀವು ಈ ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ನಿರ್ಬಂಧಿಸಿದರೆ, ನೀವು ಡಿಸ್‌ಕನೆಕ್ಟ್ ಆಗುತ್ತೀರಿ."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"ಸುಧಾರಿತ ಆಯ್ಕೆಗಳು"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ಡ್ರಾಪ್-ಡೌನ್ ಪಟ್ಟಿಯ ಸುಧಾರಿತ ಆಯ್ಕೆಗಳು"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ವಿಸ್ತರಿಸಿ"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"ನಿಮ್ಮ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕಗಳನ್ನು ನಿರ್ವಹಿಸಲು <xliff:g id="NEW_APP">%s</xliff:g> ಬಳಸುವುದೇ?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"ಇತ್ತೀಚಿನ ಸ್ಥಳ ವಿನಂತಿಗಳು"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ಕೆಲಸದ ಪ್ರೊಫೈಲ್‌ನ ಸ್ಥಳ"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ಆ್ಯಪ್ ಸ್ಥಳದ ಅನುಮತಿಗಳು"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"ಸ್ಥಳ ಆಫ್‌ ಆಗಿದೆ"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} ರಲ್ಲಿ # ಆ್ಯಪ್‌ಗಳು ಸ್ಥಳಕ್ಕೆ ಆ್ಯಕ್ಸೆಸ್ ಅನ್ನು ಹೊಂದಿವೆ}one{{total} ರಲ್ಲಿ # ಆ್ಯಪ್‌ಗಳು ಸ್ಥಳಕ್ಕೆ ಆ್ಯಕ್ಸೆಸ್ ಅನ್ನು ಹೊಂದಿವೆ}other{{total} ರಲ್ಲಿ # ಆ್ಯಪ್‌ಗಳು ಸ್ಥಳಕ್ಕೆ ಆ್ಯಕ್ಸೆಸ್ ಅನ್ನು ಹೊಂದಿವೆ}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ಆನ್-ಸ್ಕ್ರೀನ್ ಕೀಬೋರ್ಡ್ ಬಳಸಿ"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"ಭೌತಿಕ ಕೀಬೋರ್ಡ್ ಸಕ್ರಿಯವಾಗಿರುವಾಗ ಅದನ್ನು ಪರದೆಯ ಮೇಲೆ ಇರಿಸಿಕೊಳ್ಳಿ"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"ಬೌನ್ಸ್ ಕೀಗಳು"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ಮಿ.ಸೆ. ಒಳಗೆ ಒಂದೇ ಕೀಯ ಪುನರಾವರ್ತಿತ ಒತ್ತುವಿಕೆಗಳನ್ನು ಕೀಬೋರ್ಡ್ ತ್ವರಿತವಾಗಿ ನಿರ್ಲಕ್ಷಿಸುತ್ತದೆ"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ಸ್ಲೋ ಕೀಗಳು"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ಮಿ.ಸೆ. ಗೆ ಸಕ್ರಿಯಗೊಳಿಸಲು ಕೀ ಒತ್ತುವಿಕೆಗೆ ಇದು ತೆಗೆದುಕೊಳ್ಳುವ ಸಮಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ಸ್ಟಿಕಿ ಕೀಗಳು"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"ಕೀಗಳನ್ನು ಜೊತೆಯಾಗಿ ಕೆಳಗೆ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಬದಲಾಗಿ ಶಾರ್ಟ್‌ಕಟ್‌ಗಳಿಗಾಗಿ ಒಂದು ಬಾರಿ ಒಂದು ಕೀ ಅನ್ನು ಒತ್ತಿ"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"ಕೀಬೋರ್ಡ್ ಶಾರ್ಟ್‌ಕಟ್‌ಗಳು"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"ಶಾರ್ಟ್‌ಕಟ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ತೋರಿಸಿ"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"ಉದ್ಯೋಗ ಪ್ರೊಫೈಲ್ ಕೀಬೋರ್ಡ್‌ಗಳು ಮತ್ತು ಉಪಕರಣಗಳು"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ರೀಸೆಟ್ ಮಾಡಿ"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"ಮಾರ್ಪಡಿಸುವ ಕೀ ಆಯ್ಕೆಮಾಡಿ"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> ಗಾಗಿ ಹೊಸ ಕೀ ಆಯ್ಕೆಮಾಡಿ:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ಡಿಫಾಲ್ಟ್"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"ಧ್ವನಿ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"ಪಾಯಿಂಟರ್ ವೇಗ"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"ಆಟ ನಿಯಂತ್ರಕ"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ಈ ಸಾಧನವನ್ನು ನೀವು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು. ಈ ಆ್ಯಕ್ಸೆಸಿಬಿಲಿಟಿ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನಂತರ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ಫಾಂಟ್ ಗಾತ್ರ ಬದಲಿಸಿ"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"ಸ್ಕ್ರೀನ್ ರೀಡರ್"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ಭೌತಿಕ ಕೀಬೋರ್ಡ್ ಆಯ್ಕೆಗಳು"</string>
     <string name="captions_category_title" msgid="574490148949400274">"ಶೀರ್ಷಿಕೆಗಳು"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ಆಡಿಯೋ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"ಸಾಮಾನ್ಯ"</string>
     <string name="display_category_title" msgid="6638191682294461408">"ಡಿಸ್‌ಪ್ಲೇ"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"ಬಣ್ಣ ಮತ್ತು ಚಲನೆ"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"ಕಲರ್ ಕಾಂಟ್ರಾಸ್ಟ್‌‌"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"ಹೆಚ್ಚಿನ ಕಾಂಟ್ರಾಸ್ಟ್ ಪಠ್ಯ, ಬಟನ್‌ಗಳು ಮತ್ತು ಐಕಾನ್‌ಗಳನ್ನು ಎದ್ದು ಕಾಣುವಂತೆ ಮಾಡುತ್ತದೆ. ನಿಮಗೆ ಉತ್ತಮವಾಗಿ ಕಾಣುವ ಕಾಂಟ್ರಾಸ್ಟ್ ಅನ್ನು ಆರಿಸಿ."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"ಕೆಲವು ಆ್ಯಪ್‌ಗಳು ಎಲ್ಲಾ ಬಣ್ಣ ಮತ್ತು ಪಠ್ಯದ ಕಾಂಟ್ರಾಸ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸದೇ ಇರಬಹುದು"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"ನಿಮ್ಮ ಸ್ಕ್ರೀನ್‌ನ ಹಿನ್ನೆಲೆ ಬಣ್ಣಕ್ಕೆ ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಬಣ್ಣಗಳು ಮತ್ತು ಪಠ್ಯವು ಹೇಗೆ ಕಾಣಬೇಕು ಎಂಬುದನ್ನು ಅಡ್ಜಸ್ಟ್‌ ಮಾಡಿ"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"ಪೂರ್ವವೀಕ್ಷಿಸಿ"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"ಹೆಲೆನ್, ಆಡಮ್"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 ದಿನಗಳ ಹಿಂದೆ"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ಅನುಸರಿಸುವಿರಾ?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"ವ್ಯಾಪಾರ ಪ್ರವಾಸದ ವರದಿ"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"ಹೆಚ್ಚಿನ ಸಹಾಯಕ್ಕಾಗಿ, \nನನ್ನನ್ನು ಅಥವಾ ಹೆಲೆನ್ ಅವರನ್ನು ಸಂಪರ್ಕಿಸಿ. ಈ ವರದಿ ಹೀಗೆ ಇರಲಿದೆ"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"ಕ್ಲೈಂಟ್ ವೆಚ್ಚಗಳು"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"ಸ್ಕ್ರೀನ್ ಅನ್ನು ಇನ್ನಷ್ಟು ಡಾರ್ಕ್ ಆಗಿಸಿ"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ಸಂವಹನ ನಿಯಂತ್ರಣಗಳು"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"ಸಮಯ ನಿಯಂತ್ರಣಗಳು"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"ಹೇಗಾದರೂ ಮುಂದುವರಿಸಿ"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"ರದ್ದುಮಾಡಿ"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"ಹಿಗ್ಗಿಸುವಿಕೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳು"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ಶಾರ್ಟ್‌ಕಟ್ ಮೂಲಕ ಹಿಗ್ಗಿಸಿ"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ಶಾರ್ಟ್‌ಕಟ್ ಮತ್ತು ಮೂರು-ಟ್ಯಾಪ್ ಮೂಲಕ ಹಿಗ್ಗಿಸಿ"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> ಕುರಿತು"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"ಪಾರದರ್ಶಕವಲ್ಲದ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ಹೆಚ್ಚು ಕಾಂಟ್ರಾಸ್ಟ್‌ನ ಪಠ್ಯ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"ಪಠ್ಯದ ಬಣ್ಣವನ್ನು ಕಪ್ಪು ಅಥವಾ ಬಿಳಿ ಬಣ್ಣಕ್ಕೆ ಬದಲಾಯಿಸಿ. ಹಿನ್ನೆಲೆ ಬಣ್ಣದೊಂದಿಗೆ ಕಾಂಟ್ರಾಸ್ಟ್ ಅನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"ಪಠ್ಯದ ಕಾಂಟ್ರಾಸ್ಟ್ ಗರಿಷ್ಠಗೊಳಿಸಿ"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"ಹಿನ್ನೆಲೆಯ ಕಾಂಟ್ರಾಸ್ಟ್ ಅನ್ನು ಹೆಚ್ಚಿಸಲು ಪಠ್ಯದ ಬಣ್ಣವನ್ನು ಕಪ್ಪು ಅಥವಾ ಬಿಳಿಗೆ ಬದಲಾಯಿಸಿ."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"ಸ್ವಯಂ ಅಪ್‍ಡೇಟ್ ಸ್ಕ್ರೀನ್‌ ವರ್ಧನೆ"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"ಅಪ್ಲಿಕೇಶನ್‌ ಪರಿವರ್ತನೆಗಳಲ್ಲಿ ಸ್ಕ್ರೀನ್‌ ವರ್ಧಕವನ್ನು ಅಪ್‌ಡೇಟ್‌ ಮಾಡಿ"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"ಪವರ್ ಬಟನ್ ಕರೆಯನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"ವಾಲ್ಯೂಮ್ ಕೀಗಳನ್ನು ಹಿಡಿದುಕೊಳ್ಳಿ"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"ಸ್ಕ್ರೀನ್ ಮೇಲೆ ಮೂರು ಬಾರಿ ಟ್ಯಾಪ್ ಮಾಡಿ"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ಆ್ಯಕ್ಸೆಸಿಬಿಲಿಟಿ ಶಾರ್ಟ್‌ಕಟ್‌ಗಳನ್ನು ಎಡಿಟ್ ಮಾಡಿ"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s ಗಾಗಿ ನಿಮ್ಮ ಶಾರ್ಟ್‌ಕಟ್ ಆಯ್ಕೆಮಾಡಿ"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ಮುಂದುವರಿಸಿ"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"ಶ್ರವಣ ಸಾಧನಗಳು"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA ಮತ್ತು LE ಆಡಿಯೋ ಶ್ರವಣ ಸಾಧನಗಳು, ಕಾಕ್ಲಿಯರ್ ಇಂಪ್ಲಾಂಟ್‌ಗಳು ಮತ್ತು ಇತರ ಆಂಪ್ಲಿಫಿಕೇಶನ್ ಸಾಧನಗಳನ್ನು ಸೆಟಪ್ ಮಾಡಿ ಮತ್ತು ನಿರ್ವಹಿಸಿ"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"ಯಾವುದೇ ಶ್ರವಣ ಸಾಧನಗಳು ಕನೆಕ್ಟ್ ಆಗಿಲ್ಲ"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"ಶ್ರವಣ ಸಾಧನಗಳನ್ನು ಸೇರಿಸಿ"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"ಶ್ರವಣ ಸಾಧನಗಳನ್ನು ಜೋಡಿಸಿ"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"ಶ್ರವಣ ಸಾಧನ ಹೊಂದಾಣಿಕೆ"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ಟೆಲಿಕಾಯಿಲ್ ಮೂಲಕ ಹೊಂದಾಣಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು ಅನಗತ್ಯ ಶಬ್ದಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"ಶ್ರವಣ ಸಾಧನಗಳ ಕುರಿತು"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA ಅಥವಾ LE ಆಡಿಯೋ ಮೂಲಕ ಬೆಂಬಲಿಸದಿರುವ ಇತರ ಹಿಯರಿಂಗ್ ಸಾಧನಗಳನ್ನು ಹುಡುಕಲು, "<b>"ಹೊಸ ಸಾಧನವನ್ನು ಜೋಡಿಸಿ"</b>" ಎಂಬುದನ್ನು ಟ್ಯಾಪ್ ಮಾಡಿ ಮತ್ತು "<b>"ಇನ್ನಷ್ಟು ಸಾಧನಗಳನ್ನು ನೋಡಿ"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"ಶ್ರವಣ ಸಾಧನವನ್ನು ಪೇರ್ ಮಾಡಿ"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ನೀವು ಈ ಪುಟದಲ್ಲಿ ASHA ಮತ್ತು LE ಆಡಿಯೋ ಹಿಯರಿಂಗ್ ಸಾಧನಗಳನ್ನು ಪೇರ್ ಮಾಡಬಹುದು. ನಿಮ್ಮ ಹಿಯರಿಂಗ್ ಸಾಧನವನ್ನು ಆನ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಪೇರ್ ಮಾಡಲು ಸಿದ್ಧವಾಗಿದೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ಲಭ್ಯವಿರುವ ಶ್ರವಣ ಸಾಧನಗಳು"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ಪಠ್ಯ ಸಂದೇಶಗಳು"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ಸ್ವಯಂಚಾಲಿತ ಡೇಟಾ ಬದಲಿಸುವಿಕೆ"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"ಕವರೇಜ್ ಮತ್ತು ಲಭ್ಯತೆಯನ್ನು ಆಧರಿಸಿ ಎರಡರಲ್ಲಿ ಒಂದು SIM ನಲ್ಲಿನ ಡೇಟಾ ಬಳಸಿ"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ಡೇಟಾ ಮಾತ್ರ"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"ಸೆಟಪ್ ಮಾಡಿ"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"ಮುಂದಿನದು"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB ಹೊಂದಿರುವ ಸಮೀಪದ ಸಾಧನಗಳ ಸಂಬಂಧಿತ ಸ್ಥಾನವನ್ನು ಗುರುತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB ಬಳಸಲು ಏರ್‌ಪ್ಲೇನ್ ಮೋಡ್ ಅನ್ನು ಆಫ್ ಮಾಡಿ"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"ಪ್ರಸ್ತುತ ಸ್ಥಳದಲ್ಲಿ UWB ಲಭ್ಯವಿಲ್ಲ"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"ಥ್ರೆಡ್"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"ತಡೆರಹಿತ ಸ್ಮಾರ್ಟ್ ಹೋಮ್ ಅನುಭವಕ್ಕಾಗಿ ಥ್ರೆಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಂದಾಣಿಕೆಯಾಗುವ ಸಾಧನಗಳಿಗೆ ಕನೆಕ್ಟ್ ಮಾಡಿ"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"ಥ್ರೆಡ್ ಬಳಸಲು ಏರ್‌ಪ್ಲೇನ್ ಮೋಡ್ ಅನ್ನು ಆಫ್ ಮಾಡಿ"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"ಕ್ಯಾಮರಾ ಪ್ರವೇಶದ ಅನುಮತಿ"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"ಮೈಕ್ರೊಫೋನ್‌ ಪ್ರವೇಶದ ಅನುಮತಿ"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ಆ್ಯಪ್‌ಗಳು ಮತ್ತು ಸೇವೆಗಳಿಗಾಗಿ"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"ರದ್ದುಮಾಡಿ"</string>
     <string name="contrast_title" msgid="6885768151336508075">"ಕಾಂಟ್ರಾಸ್ಟ್‌‌"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"ಪ್ರಮಾಣಿತ"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ಡೀಫಾಲ್ಟ್"</string>
     <string name="contrast_medium" msgid="384414510709285811">"ಮಧ್ಯಮ"</string>
     <string name="contrast_high" msgid="3988567609694797696">"ಹೆಚ್ಚು"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"ಈ ಆ್ಯಪ್ ಅನ್ನು 1 ವಿಂಡೋದಲ್ಲಿ ಮಾತ್ರ ತೆರೆಯಬಹುದು"</string>
diff --git a/res/values-ko/arrays.xml b/res/values-ko/arrays.xml
index 8602611..ee51e4c 100644
--- a/res/values-ko/arrays.xml
+++ b/res/values-ko/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"제한이 있는 Wi-Fi로 취급"</item>
     <item msgid="2047166446768045816">"무제한 Wi-Fi로 취급"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"무작위 MAC 사용(기본값)"</item>
-    <item msgid="741680937828608749">"기기 MAC 사용"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"아니요"</item>
     <item msgid="2163015208097377388">"예"</item>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index 1315551..a3f680b 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"오른쪽 보청기 페어링"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"왼쪽 보청기 페어링"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"사용 가능한 모든 보청기"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"청각 보조 기기 설정 더보기"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"단축키, 텔레코일 제어와 같은 교차 기기 설정을 변경합니다."</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"이 기기에 적용"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"오디오 출력"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"오디오 출력 정보"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"비공개 스페이스 설정 중…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"비공개 스페이스가 잠겨 있으면 비공개 스페이스 앱에서 보내는 알림이 표시되지 않음"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"비공개 스페이스를 숨기고 자동 잠금을 설정하려면 비공개 스페이스 설정을 살펴보세요"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"필수 앱이 이미 비공개 스페이스에 설치되어 있습니다"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"비공개 스페이스를 설정할 수 없음"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"다시 시도"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"화면 잠금을 사용하여 비공개 스페이스를 잠금 해제하시겠습니까?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"앱 및 알림"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"잠금 화면의 민감한 알림"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"비공개 스페이스가 잠금 해제될 때 민감한 콘텐츠를 표시합니다."</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"데이터를 보호하기 위해 Google 계정 만들기"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"다음 화면에서 비공개 스페이스에서 사용할 계정에 로그인할 수 있습니다."</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"비공개 스페이스 외부로 데이터가 표시되지 않도록 전용 계정을 만드세요. (예:"</b>")"</string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"동기화된 사진, 파일, 이메일, 연락처, 캘린더 일정, 기타 데이터"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"앱 다운로드 기록 및 추천"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"방문 기록, 북마크, 저장된 비밀번호"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"비공개 스페이스 앱 내 활동과 관련하여 추천된 콘텐츠"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"확인"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"지문을 <xliff:g id="COUNT">%d</xliff:g>개까지 추가할 수 있습니다."</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"최대 개수의 지문을 추가했습니다."</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"지문을 추가할 수 없습니다."</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"사용 중인 이동통신사에서는 이 네트워크가 오래되어서 안전성이 낮은 보안 프로토콜을 사용하기 때문에 해당 네트워크에 대한 연결을 허용하지 않습니다"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP 허용"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"닫기"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g>에서 연결 해제하시겠습니까?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP 네트워크에 연결되어 있습니다. 이 네트워크를 차단하면 연결이 해제됩니다."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"고급 옵션"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"드롭다운 목록 고급 옵션"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"펼치기"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"<xliff:g id="NEW_APP">%s</xliff:g>을(를) 사용하여 네트워크 연결을 관리하시겠습니까?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"최근 위치 요청"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"직장 프로필 위치"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"앱 위치 정보 액세스 권한"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"위치 서비스 사용 안함"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total}개 중 #개의 앱이 위치에 액세스할 수 있음}other{{total}개 중 #개의 앱이 위치에 액세스할 수 있음}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"터치 키보드 사용"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"물리적 키보드가 활성 상태인 경우 화면에 켜 둠"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"바운스 키"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g>밀리초 이내에 동일한 키를 빠르게 반복해서 누를 시 키보드에서 이를 무시합니다."</string>
     <string name="slow_keys" msgid="2891452895499690837">"느린 키"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"키를 누를 때 활성화하기까지 걸리는 시간을 <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g>밀리초로 조정합니다."</string>
     <string name="sticky_keys" msgid="7317317044898161747">"고정키"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"단축키를 사용할 때 키를 함께 누르지 않고 한 번에 하나씩 누릅니다"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"단축키"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"단축키 목록을 표시합니다."</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"직장 프로필 키보드 및 도구"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"초기화"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"특수키 선택"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>의 새 키 선택:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> 레이아웃"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"기본"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"자동: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"사용자 선택: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"음성"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"포인터 속도"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"게임 컨트롤러"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"필요에 따라 기기를 맞춤설정할 수 있습니다. 다음 접근성 기능은 언제든지 설정에서 변경할 수 있습니다."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"글꼴 크기 변경"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"스크린 리더"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"실제 키보드 옵션"</string>
     <string name="captions_category_title" msgid="574490148949400274">"자막"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"오디오"</string>
     <string name="general_category_title" msgid="6298579528716834157">"일반"</string>
     <string name="display_category_title" msgid="6638191682294461408">"디스플레이"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"색상 및 모션"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"색상 대비"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"고대비를 사용하면 텍스트, 버튼, 아이콘이 더 선명하게 보입니다. 자신에게 가장 괜찮아 보이는 대비를 선택하세요."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"일부 앱에서는 모든 색상 및 텍스트 대조 설정을 지원하지 않습니다."</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"화면의 배경 색상과 대조하여 색상과 텍스트를 어떻게 표시할지 조정합니다."</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"미리보기"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"헬렌, 아담"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2일 전"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"후속 조치를 하시겠습니까?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"출장 보고서"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"도움이 더 필요하시면 \n저나 헬렌에게 문의하세요. 이 보고서는"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"클라이언트 비용"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"화면 어둡게"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"상호작용 관리"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"타이밍 제어"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"무시하고 계속하기"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"취소"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"확대 설정"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"바로가기를 사용하여 확대"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"바로가기 및 세 번 탭으로 확대"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> 정보"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"불투명"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"고대비 텍스트"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"텍스트 색상을 검은색 또는 흰색으로 변경하여 배경과의 대비를 극대화합니다."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"텍스트 대조 극대화"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"배경과의 대비를 높이기 위해 텍스트 색상을 검은색 또는 흰색으로 변경합니다."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"화면 확대 자동 업데이트"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"앱 전환 시 화면 확대 업데이트"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"전원 버튼으로 통화 종료"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"볼륨 키를 길게 누르세요."</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"세 번 탭하세요."</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"접근성 바로가기 수정"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s의 단축키를 선택하세요"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"계속"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"청각 보조 기기"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"보청기용 오디오 스트리밍 및 LE 오디오 보청기, 인공 와우, 기타 증폭기를 설정하고 관리하세요."</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"연결된 청각 보조 기기 없음"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"보청기 추가"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"보청기 페어링"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"보청기 호환성"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"텔레코일과의 호환성을 개선하고 원치 않는 소음을 줄이세요."</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"보청기 정보"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"보청기용 오디오 스트리밍 또는 LE 오디오에서 지원되지 않는 다른 청각 보조 기기를 찾으려면 "<b>"새 기기와 페어링"</b>" &gt; "<b>"기기 더보기"</b>"를 탭하세요"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"보청기 페어링"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"이 페이지에서 보청기용 오디오 스트리밍 및 LE 오디오 청각 보조 기기를 페어링할 수 있습니다. 청각 보조 기기의 전원이 켜져 있으며 페어링할 준비가 되어 있는지 확인하세요"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"사응 가능한 보청기"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"문자 메시지"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"자동 데이터 전환"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"서비스 범위 및 지원 여부에 따라 SIM 중 하나의 데이터를 사용하세요."</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"데이터 전용"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"설정"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"다음"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB를 지원하는 근처 기기의 상대적인 위치를 파악할 수 있도록 돕습니다."</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB를 사용하려면 비행기 모드를 사용 중지하세요."</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"현재 위치에서는 UWB를 사용할 수 없습니다."</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"스레드"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"원활한 스마트 홈 환경을 위해 스레드를 사용해 호환되는 기기에 연결하세요"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"스레드를 사용하려면 비행기 모드를 사용 중지하세요"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"카메라 액세스"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"마이크 액세스"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"앱 및 서비스에 적용"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"취소"</string>
     <string name="contrast_title" msgid="6885768151336508075">"대비"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"표준"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"기본값"</string>
     <string name="contrast_medium" msgid="384414510709285811">"보통"</string>
     <string name="contrast_high" msgid="3988567609694797696">"높음"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"이 앱은 창 1개에서만 열 수 있습니다."</string>
diff --git a/res/values-ky/arrays.xml b/res/values-ky/arrays.xml
index a0bca87..bfbc0cd 100644
--- a/res/values-ky/arrays.xml
+++ b/res/values-ky/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Ченелет"</item>
     <item msgid="2047166446768045816">"Ченелбейт"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Туш келди MAC дарек колдонулат (демейки)"</item>
-    <item msgid="741680937828608749">"MAC түзмөгү колдонулат"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Жок"</item>
     <item msgid="2163015208097377388">"Ооба"</item>
diff --git a/res/values-ky/strings.xml b/res/values-ky/strings.xml
index 5499851..40130e0 100644
--- a/res/values-ky/strings.xml
+++ b/res/values-ky/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Оң кулакты жупташтыруу"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Сол кулакты жупташтыруу"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Бардык жеткиликтүү угуу апараттары үчүн"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Угуу аппаратынын башка параметрлери"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Түзмөктөр аралык параметрлерди, мисалы, ыкчам баскычты жана индукциялык түрмөктүн башкаруу элементтерин өзгөртүңүз"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Ушул түзмөктө гана"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аудио түзмөк"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Аудио түзмөк жөнүндө"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Жеке чөйрө туураланууда…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Жеке мейкиндиктеги колдонмолордун билдирмелери ал кулпуланганда жашырылат"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Жеке мейкиндик параметрлеринде аны жашырып жана автоматтык кулпулоону тууралоого болот"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Керектүү колдонмолор жеке мейкиндигиңизге орнотулган"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Жеке мейкиндик туураланган жок"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Кайталоо"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Жеке чөйрөнүн кулпусун ачуу үчүн экран кулпусу колдонулсунбу?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Колдонмолор жана билдирмелер"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Купуя билдирмелерди кулпуланган экранда көрсөтүү"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Жеке мейкиндиктин кулпусу ачык болгондо купуя контентти көрсөтүү"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Маалыматыңызды купуя сактоо үчүн Google аккаунтун түзүңүз"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Кийинки экранда жеке мейкиндигиңизде колдонула турган аккаунтка кире аласыз"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Маалыматтар жеке мейкиндиктен тышкары жерде көрүнбөшү үчүн, өзүнчө аккаунтту түзүңүз:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Шайкештирилген сүрөттөр, файлдар, каттар, байланыштар, жылнаамадагы иш-чаралар ж.б."</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Жүктөлүп алынган колдонмолордун таржымалы жана сунуштар"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Көрүлгөн вебсайттар, кыстармалар жана сакталган сырсөздөр"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Жеке мейкиндиктеги колдонмолордо жасаган аракеттериңиздин негизинде сунушталган контент"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Түшүндүм"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"<xliff:g id="COUNT">%d</xliff:g> чейин манжа изин кошсоңуз болот"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Кошулган манжа издеринин саны жогорку чегине жетти"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Дагы манжа издерин кошуу мүмкүн эмес"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Бул тармак коопсуздук деңгээли төмөн болгон эски коопсуздук протоколун колдонгондуктан, байланыш операторуңуз ага туташууга тыюу салат"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP тармагына уруксат берүү"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Жабуу"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> тармагынан ажыратылсынбы?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP тармагына туташып турасыз. Эгер бул тармактарды бөгөттөсөңүз, алардан ажыратыласыз."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Өркүндөтүлгөн параметрлер"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Өркүндөтүлгөн параметрлердин ылдый түшүүчү тизмеси"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"жайып көрсөтүү"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Тармактык туташууларыңызды башкаруу үчүн <xliff:g id="NEW_APP">%s</xliff:g> колдоносузбу?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Жакында изделген жерлер"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Жумуш профилинин жери"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Жайгашкан жерди көргөн колдонмолор"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Жайгашкан жерди аныктоо өчүрүлгөн"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} ичинен # колдонмо жайгашкан жерди көрө алат}other{{total} ичинен # колдонмо жайгашкан жерди көрө алат}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Экрандагы баскычтопту колдонуу"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Баскычтоп иштетилгенде экранда көрүнүп турат"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Кайтаруу баскычтары"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> мсек. ичинде баскыч катары менен тез басылса, баскычтоп аны этибарга албайт"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Жай баскычтар"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> мсек. ичинде басылган баскычты иштетүү үчүн убакытты тууралаңыз"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Жабышма баскычтар"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Баскычтарды чогуу басып туруунун ордуна ыкчам баскычтарды бирден басыңыз"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Ыкчам баскычтар"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Ыкчам баскычтардын тизмесин көрсөтүү"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Жумуш профилинин баскычтоптору жана куралдары"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Кайра коюу"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Өзгөртүүчү баскычты тандаңыз"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> үчүн жаңы ачкыч тандаңыз:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> калыбы"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Демейки"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Автоматтык: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Колдонуучу тандаган: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Кеп"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Көрсөткүчтүн ылдамдыгы"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Оюн контроллери"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Түзмөктү өзүңүзгө карап ыңгайлаштырып алыңыз. Бул атайын мүмкүнчүлүктөрдүн параметрлерин кийинчерээк өзгөртсөңүз болот."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Арип өлчөмүн өзгөртө аласыз"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Экрандагыны окугуч"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Аппараттык баскычтоптун параметрлери"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Коштомо жазуулар"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Аудио"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Жалпы"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Экран"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Түс жана кыймыл"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Түс контрасты"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Контраст жогору болсо, текст, баскычтар жана сүрөтчөлөр жакшыраак көрүнөт. Өзүңүзгө ылайыктуу контрастты тандаңыз."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Айрым колдонмолордо түс жана тексттин контрасты боюнча айрым параметрлер колдоого алынбашы мүмкүн"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Текстти жана түстөрдү экрандын фонуна жараша тууралаңыз"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Алдын ала көрүү"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Хелен, Адам"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 күн мурун"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Көз саласызбы?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Иш сапар тууралуу отчёт"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Кошумча жардам керек болсо, \nмага же Хеленге кайрылыңыз. Бул отчёт"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Кардардын чыгымдары"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Экранды караңгылатуу"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Башкаруу элементтери"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Убакытты көзөмөлдөө"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Баары бир улантуу"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Жок"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Чоңойтуу параметрлери"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ыкчам баскыч менен чоңойтуу"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ыкчам баскыч жана үч жолу таптоо менен чоңойтуу"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> жөнүндө"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Тунук эмес"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Жогорку контрасттагы текст"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Текст жакшыраак көрүнүшү үчүн аны кара же ак түскө өзгөртүңүз."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Тексттин контрастын жогорулатуу"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Текст жакшыраак көрүнүшү үчүн аны кара же ак түскө өзгөртүңүз."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Экрандын чоңойтуусун авто жаңыртуу"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Колдонмо кубулган сайын, экрандын чоңойтуусун жаңыртуу"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Чалууну кубат баскычы бүтүрөт"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Үндү катуулатуу/акырындатуу баскычтарын басуу"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Экрнады үч жолу басуу"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Атайын мүмкүнчүлүктөрдүн ыкчам баскычтарын түзөтүңүз"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s үчүн ыкчам баскычты тандаңыз"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Улантуу"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Угуу аппараттары"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA жана LE Audio угуу аппараттарын, кохлеардык имплантаттарды жана үндү күчөтүүчү башка түзмөктөрдү тууралап жана тескеңиз"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Бир да угуу аппараты туташкан эмес"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Угуу аппараттарын кошуу"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Аппараттарды туташтыруу"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Угуу аппаратынын шайкештиги"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Телекатушка менен шайкештикти жакшыртып, ызы-чууну азайтат"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Угуу аппараттары жөнүндө"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA же LE Audio колдоого албаган башка угуу аппараттарын табуу үчүн "<b>"Жаңы түзмөктү жупташтыруу"</b>" жана "<b>"Дагы башка түзмөктөрдү көрүү"</b>" баскычын таптап коюңуз"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Угуу аппаратын жупташтыруу"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Бул бетте ASHA жана LE Audio угуу аппараттарын жупташтыра аласыз. Угуу аппараты күйгүзүлүп, жупташтырууга даяр экенин текшериңиз."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Жеткиликтүү угуу аппараттары"</string>
@@ -3437,7 +3415,7 @@
     <string name="notification_pulse_title" msgid="8013178454646671529">"Жарык индикатору"</string>
     <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Купуялык"</string>
     <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Экран кулпуcун өткөрүп жиберүү"</string>
-    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Кулпусу ачылгандан кийин акыркы ачылган экранга өтөсүз. Билдирмелер кулпуланган экранда көрүнбөйт. Аларды көрүү үчүн экранды ылдый сүрүңүз."</string>
+    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Кулпусу ачылгандан кийин акыркы көргөн экранга өтөсүз. Билдирмелер кулпуланган экранда көрүнбөйт. Аларды көрүү үчүн экранды ылдый сүрүңүз."</string>
     <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Кулпуланган экран, кулпу экраны, өткөрүп жиберүү, айланып өтүү"</string>
     <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Жумуш профили кулпуланганда"</string>
     <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Кулпуланган экранда жаңы билдирмелерди гана көрсөтүү"</string>
@@ -4168,7 +4146,7 @@
     <string name="keywords_long_background_tasks" msgid="5788956269136054574">"узак мөөнөттүү жумуштар, маалыматтарды өткөрүү, фондогу тапшырмалар"</string>
     <string name="run_backup_tasks_title" msgid="8572480651659803275">"Камдык көчүрмөнү фондо сактоо"</string>
     <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Колдонмого камдык көчүрмөнү фондо сактоого уруксат берүү"</string>
-    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Бул колдонмо камдык көчүрмөнү сактап же контентти шайкештиргендин ордуна аны колдонуп жатат. Бул уруксатты берсеңиз, камдык көчүрмөнү сактоо үчүн бул колдонмо бир аз көбүрөөк иштейт. \n\nЭгер бул уруксат берилбесе, тутум колдонмого камдык көчүрмөнү фондо сактоого мүмкүндүк бербейт."</string>
+    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Бул колдонмо камдык көчүрмөнү сактоо же контентти шайкештирүү үчүн көпкө иштеп жатат. Бул уруксатты берсеңиз, камдык көчүрмөнү сактоо үчүн бул колдонмо бир аз көбүрөөк иштейт. \n\nЭгер бул уруксат берилбесе, тутум колдонмого камдык көчүрмөнү фондо сактоого мүмкүндүк бербейт."</string>
     <string name="keywords_run_backup_tasks" msgid="632219905465766211">"камдык көчүрмөнү сактоо тапшырмалары, камдык көчүрмөнү сактоо иштери"</string>
     <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"ShortcutManager эсептегичтерин баштапкы абалга келтирүү"</string>
     <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"ShortcutManager ылдамдыкты чектөө баштапкы абалга келтирилди"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS жөнөтүү"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Дайындарды автоматтык түрдө которуу"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Иштөө аймагы жана жеткиликтүүлүгүнө жараша каалаган SIM картанын дайындарын колдонуңуз"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Дайындар гана"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Тууралоо"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Кийинки"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB технологиясы менен иштеген жакын жердеги түзмөктөрдүн болжолдуу ордун аныктоого жардам берет"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB\'ни колдонуу үчүн учак режимин өчүрүңүз"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB учурдагы жерде жеткиликсиз"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Thread\'дин жардамы менен шайкеш түзмөктөргө туташтырып, акылдуу үйдү оңой тескеңиз"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread\'ди колдонуу үчүн учак режимин өчүрүңүз"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Камераны колдонуу"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Микрофонду колдонуу"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Колдонмолор жана кызматтар үчүн"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Жок"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Контраст"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Кадимки"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Демейки"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Орточо"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Жогору"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Бул колдонмону 1 терезеде гана ачууга болот"</string>
diff --git a/res/values-lo/arrays.xml b/res/values-lo/arrays.xml
index 09f0bb1..fe9a151 100644
--- a/res/values-lo/arrays.xml
+++ b/res/values-lo/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"ໃຊ້ແບບວັດແທກປະລິມານ"</item>
     <item msgid="2047166446768045816">"ໃຊ້ແບບບໍ່ວັດແທກປະລິມານ"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ໃຊ້ MAC ແບບສຸ່ມ (ຄ່າເລີ່ມຕົ້ນ)"</item>
-    <item msgid="741680937828608749">"ໃຊ້ MAC ອຸປະກອນ"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"ບໍ່"</item>
     <item msgid="2163015208097377388">"ແມ່ນ"</item>
diff --git a/res/values-lo/strings.xml b/res/values-lo/strings.xml
index 88fe992..3623073 100644
--- a/res/values-lo/strings.xml
+++ b/res/values-lo/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"ຜູ້ໃຫ້ບໍລິການຂອງທ່ານບໍ່ອະນຸຍາດໃຫ້ທ່ານເຊື່ອມຕໍ່ກັບເຄືອຂ່າຍນີ້ ເພາະວ່າມັນໃຊ້ໂປຣໂຕຄໍຄວາມປອດໄພແບບເກົ່າທີ່ປອດໄພໜ້ອຍກວ່າ"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"ອະນຸຍາດ WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"ປິດ"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"ຕັດການເຊື່ອມຕໍ່ຈາກ <xliff:g id="NAME">%1$s</xliff:g> ບໍ?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"ທ່ານເຊື່ອມຕໍ່ຫາເຄືອຂ່າຍ WEP ແລ້ວ. ຫາກທ່ານບລັອກເຄືອຂ່າຍເຫຼົ່ານີ້, ທ່ານຈະຖືກຕັດການເຊື່ອມຕໍ່."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"​ໂຕ​ເລືອກ​ຂັ້ນ​ສູງ"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ລາຍຊື່ແບບລົງລຸ່ມຕົວເລືອກຂັ້ນສູງ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ຂະ​ຫຍາຍ"</string>
@@ -1542,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"ໃຊ້ <xliff:g id="NEW_APP">%s</xliff:g> ເພື່ອ​ຈັດ​ການ​ການ​ເຊື່ອມ​ຕໍ່​ເຄືອ​ຂ່າຍ​ຂອງ​ທ່ານ​ບໍ?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"ການຮ້ອງຂໍຂໍ້ມູນສະຖານທີ່ຫຼ້າສຸດ"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ສະຖານທີ່ສຳລັບໂປຣໄຟລ໌ບ່ອນເຮັດວຽກ"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ການອະນຸຍາດສະຖານທີ່ແອັບ"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"ປິດສະຖານທີ່ແລ້ວ"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# ຈາກທັງໝົດ {total} ແອັບມີສິດເຂົ້າເຖິງສະຖານທີ່}other{# ຈາກທັງໝົດ {total} ແອັບມີສິດເຂົ້າເຖິງສະຖານທີ່}}"</string>
@@ -1875,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ໃຊ້ແປ້ນພິມຢູ່ໜ້າຈໍ"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"ປະມັນໄວ້ໃນໜ້າຈໍເມື່ອໃຊ້ແປ້ນພິມພາຍນອກ."</string>
     <string name="bounce_keys" msgid="7419450970351743904">"ປຸ່ມດີດກັບ"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"ແປ້ນພິມຈະລະເວັ້ນການກົດປຸ່ມດຽວຊ້ຳໆຢ່າງວ່ອງໄວພາຍໃນ <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ເພີ່ມໄລຍະເວລາໃນການກົດປຸ່ມ"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"ປັບເວລາທີ່ມັນໃຊ້ສໍາລັບການກົດປຸ່ມເພື່ອເປີດໃຊ້ເປັນ <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ປຸ່ມກົດຄ້າງ"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"ກົດເທື່ອລະປຸ່ມເພື່ອທາງລັດແທນການກົດປຸ່ມຄ້າງໄວ້ຮ່ວມກັນ"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"ປຸ່ມລັດແປ້ນພິມ"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"ສະແດງລາຍຊື່ຂອງທາງລັດ"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"ແປ້ນພິມໂປຣໄຟລ໌ວຽກ ແລະ ເຄື່ອງມື"</string>
@@ -1936,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ຣີເຊັດ"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"ເລືອກປຸ່ມຕົວດັດແປງ"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"ເລືອກປຸ່ມໃໝ່ສຳລັບ <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"ໂຄງຮ່າງ <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ຄ່າເລີ່ມຕົ້ນ"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"ອັດຕະໂນມັດ: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"ຜູ້ໃຊ້ໄດ້ເລືອກ: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"ສຽງເວົ້າ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"ຄວາມໄວລູກສອນ"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"ມືເກມ"</string>
@@ -1992,8 +1992,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ທ່ານສາມາດປັບແຕ່ງອຸປະກອນນີ້ໃຫ້ເໝາະສົມກັບຄວາມຕ້ອງການຂອງທ່ານ. ຄຸນສົມບັດຊ່ວຍເຂົ້າເຖິງເຫຼົ່ານີ້ສາມາດຖືກປ່ຽນແປງໄດ້ໃນພາຍຫຼັງໃນການຕັ້ງຄ່າ."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ປ່ຽນຂະໜາດຟອນ"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"ໂປຣແກຣມອ່ານໜ້າຈໍ"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ຕົວເລືອກແປ້ນພິມແທ້"</string>
     <string name="captions_category_title" msgid="574490148949400274">"ຄຳບັນຍາຍ"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ສຽງ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"ທົ່ວໄປ"</string>
@@ -2059,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"ຢືນຢັນດຳເນີນການຕໍ່"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"ຍົກເລີກ"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"ການຕັ້ງຄ່າການຂະຫຍາຍ"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ຂະຫຍາຍດ້ວຍທາງລັດ"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ຂະຫຍາຍດ້ວຍທາງລັດ ແລະ ການແຕະສາມເທື່ອ"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"ກ່ຽວກັບ <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2243,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"ກົດປຸ່ມລະດັບສຽງຄ້າງໄວ້"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"ແຕະໃສ່ໜ້າຈໍສາມເທື່ອ"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ແກ້ໄຂທາງລັດການຊ່ວຍເຂົ້າເຖິງ"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"ເລືອກທາງລັດຂອງທ່ານສຳລັບ %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ສືບຕໍ່"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"ອຸປະກອນຊ່ວຍຟັງ"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ຕັ້ງຄ່າ ແລະ ຈັດການເຄື່ອງຊ່ວຍຟັງສຽງ ASHA ແລະ ສຽງ LE, ປະສາດຫູທຽມ ແລະ ອຸປະກອນຂະຫຍາຍສຽງອື່ນໆ"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"ບໍ່ໄດ້ເຊື່ອມຕໍ່ອຸປະກອນຊ່ວຍຟັງໄວ້"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"ເພີ່ມອຸປະກອນຊ່ວຍຟັງ"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"ຈັບຄູ່ເຄື່ອງຊ່ວຍຟັງ"</string>
@@ -2266,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"ການໃຊ້ຮ່ວມກັນໄດ້ຂອງເຄື່ອງຊ່ວຍຟັງ"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ປັບປຸງຄວາມເຂົ້າກັນໄດ້ດ້ວຍ telecoil ແລະ ຫຼຸດສຽງລົບກວນທີ່ບໍ່ຕ້ອງການ"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"ກ່ຽວກັບອຸປະກອນຊ່ວຍຟັງ"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ເພື່ອຊອກຫາອຸປະກອນຊ່ວຍຟັງອື່ນໆທີ່ບໍ່ຮອງຮັບໂດຍ ASHA ຫຼື ສຽງ LE, ໃຫ້ແຕະ "<b>"ຈັບຄູ່ອຸປະກອນໃໝ່"</b>" &gt; "<b>"ເບິ່ງອຸປະກອນເພີ່ມເຕີມ"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"ຈັບຄູ່ອຸປະກອນຊ່ວຍຟັງ"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ທ່ານສາມາດຈັບຄູ່ອຸປະກອນຊ່ວຍຟັງສຽງ ASHA ແລະ ສຽງ LE ຢູ່ໜ້ານີ້ໄດ້. ກວດສອບໃຫ້ໝັ້ນໃຈວ່າອຸປະກອນຊ່ວຍຟັງຂອງທ່ານເປີດຢູ່ ແລະ ພ້ອມຈັບຄູ່ແລ້ວ."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ອຸປະກອນຊ່ວຍຟັງທີ່ພ້ອມໃຫ້ນຳໃຊ້"</string>
@@ -4639,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ຂໍ້ຄວາມ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ການສະຫຼັບການເຊື່ອມຕໍ່ອິນເຕີເນັດອັດຕະໂນມັດ"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"ໃຊ້ການເຊື່ອມຕໍ່ອິນເຕີເນັດຈາກຊິມໃດກໍໄດ້ໂດຍຂຶ້ນຢູ່ກັບພື້ນທີ່ຄອບຄຸມ ແລະ ຄວາມພ້ອມໃຫ້ນຳໃຊ້"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ໃຊ້ເຊື່ອມຕໍ່ອິນເຕີເນັດເທົ່ານັ້ນ"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"ຕັ້ງຄ່າ"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"ຕໍ່ໄປ"</string>
@@ -4671,7 +4679,7 @@
     <string name="erase_sim_fail_title" msgid="1445700500168357303">"ບໍ່ສາມາດລຶບ eSIM ໄດ້"</string>
     <string name="erase_sim_fail_text" msgid="6898841004987411547">"ມີບາງຢ່າງຜິດພາດເກີດຂຶ້ນ ແລະ ບໍ່ສາມາດລຶບ eSIM ນີ້ໄດ້.\n\nກະລຸນາຣີສະຕາດອຸປະກອນຂອງທ່ານ ແລ້ວລອງໃໝ່."</string>
     <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"ເຊື່ອມຕໍ່ຫາ Wi‑Fi ກ່ອນລຶບ"</string>
-    <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"ສິ່ງນີ້ເຮັດໃຫ້ມັນງ່າຍຂຶ້ນໃນການໃຊ້ eSIM ຂອງທ່ານອີກຄັ້ງໃນອະນາຄົດໂດຍບໍ່ຈໍາເປັນຕ້ອງຕິດຕໍ່ກັບຜູ້ໃຫ້ບໍລິການຂອງທ່ານ"</string>
+    <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"ສິ່ງນີ້ເຮັດໃຫ້ມັນງ່າຍຂຶ້ນໃນການໃຊ້ eSIM ຂອງທ່ານຄືນໃໝ່ໃນອະນາຄົດໂດຍບໍ່ຈໍາເປັນຕ້ອງຕິດຕໍ່ກັບຜູ້ໃຫ້ບໍລິການຂອງທ່ານ"</string>
     <string name="wifi_warning_continue_button" msgid="8171574741789688214">"ແນວໃດກໍລຶບ"</string>
     <string name="wifi_warning_return_button" msgid="6226063181583906340">"ຕົກລົງ"</string>
     <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"ເຊື່ອມຕໍ່ຫາອຸປະກອນ"</string>
@@ -4917,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"ຊ່ວຍລະບຸຕຳແໜ່ງທີ່ສຳພັນກັນຂອງອຸປະກອນທີ່ຢູ່ໃກ້ຄຽງທີ່ມີ UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"ປິດໂໝດຢູ່ໃນຍົນເພື່ອໃຊ້ UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB ບໍ່ພ້ອມໃຫ້ນຳໃຊ້ໃນສະຖານທີ່ປັດຈຸບັນ"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"ເຊື່ອມຕໍ່ຫາອຸປະກອນທີ່ເຂົ້າກັນໄດ້ໂດຍໃຊ້ Thread ສໍາລັບປະສົບການສະມາດໂຮມທີ່ບໍ່ສະດຸດ"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"ປິດໂໝດຢູ່ໃນຍົນເພື່ອໃຊ້ Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"ການເຂົ້າເຖິງກ້ອງຖ່າຍຮູບ"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"ການເຂົ້າເຖິງໄມໂຄຣໂຟນ"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ສຳລັບແອັບ ແລະ ບໍລິການ"</string>
diff --git a/res/values-lt/arrays.xml b/res/values-lt/arrays.xml
index 450a3f7..d0c396d 100644
--- a/res/values-lt/arrays.xml
+++ b/res/values-lt/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Laikyti matuojamu"</item>
     <item msgid="2047166446768045816">"Laikyti nematuojamu"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Atsitiktinai parinktas MAC (numatyta)"</item>
-    <item msgid="741680937828608749">"Naudoti įrenginio MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ne"</item>
     <item msgid="2163015208097377388">"Taip"</item>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index 657442a..e13d83a 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Susieti dešinę ausį"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Susieti kairę ausį"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Visuose pasiekiamuose klausos įrenginiuose"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Daugiau klausos įrenginio nustatymų"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Keiskite nustatymus keliuose įrenginiuose, pvz., sparčiųjų klavišų ir indukcinės prijungiamos ritės valdiklius"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Šiame įrenginyje"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Garso išvestis"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Apie garso išvestį"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Nustatoma privati erdvė…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Pranešimai iš privačios erdvės programų slepiami, kai ji užrakinta"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Peržiūrėkite privačios erdvės nustatymus, jei norite paslėpti privačią erdvę ir nustatyti automatinį užrakinimą"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Būtinos programos jau įdiegtos privačioje erdvėje"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Nepavyko nustatyti privačios erdvės"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Bandyti dar kartą"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Naudoti ekrano užraktą privačiai erdvei atrakinti?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Programos ir pranešimai"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Neskelbtini pranešimai užrakinimo ekrane"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Rodyti visuomenę jaudinantį turinį, kai privati erdvė užrakinta"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Kurkite „Google“ paskyrą ir apsaugokite duomenų privatumą"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Kitame ekrane galite prisijungti prie paskyros, kurią norite naudoti su privačia erdve"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Sukurkite specialiai tam skirtą paskyrą, kuri apsaugos, kad duomenys neišeitų iš privačios erdvės, pvz.:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinchronizuotos nuotraukos, failai, el. laiškai, kontaktai, kalendoriaus įvykiai ir kiti duomenys"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Programų atsisiuntimo istorija ir rekomendacijos"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Naršymo istorija, žymės ir išsaugoti slaptažodžiai"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Siūlomas turinys susijęs su jūsų veikla privačios erdvės programose"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Supratau"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Galite pridėti iki <xliff:g id="COUNT">%d</xliff:g> piršto ats."</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Pridėjote maksimalų skaičių kontrolinių kodų"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Negalima pridėti daugiau kontrolinių kodų"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Jūsų operatorius neleidžia prisijungti prie šio tinklo, nes jame naudojamas senesnis ir mažiau saugus saugos protokolas"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Leisti WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Uždaryti"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Atjungti nuo „<xliff:g id="NAME">%1$s</xliff:g>“?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Esate prisijungę prie WEP tinklo. Jei užblokuosite šiuos tinklus, būsite atjungti."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Išplėstinės parinktys"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Išskleidžiamojo sąrašo išplėstinės parinktys"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"išskleisti"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Naudoti <xliff:g id="NEW_APP">%s</xliff:g> tinklo ryšiams tvarkyti?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Pastarosios vietovės užklausos"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Darbo profilio vieta"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Programų leidimai pasiekti vietovės duomenis"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Vietovė išjungta"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Vietovę gali pasiekti # programa iš {total}}one{Vietovę gali pasiekti # programa iš {total}}few{Vietovę gali pasiekti # programos iš {total}}many{Vietovę gali pasiekti # programos iš {total}}other{Vietovę gali pasiekti # programų iš {total}}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Ekrano klaviatūros naudojimas"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Palikti ekrane, kol fizinė klaviatūra aktyvi"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Peradresavimo klavišai"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Klaviatūra nepaiso greitai kartojamų to paties klavišo paspaudimų <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> milisek."</string>
     <string name="slow_keys" msgid="2891452895499690837">"Lėtieji klavišai"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Laikas, per kurį aktyvinamas klavišo paspaudimas, koreguojamas į <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> milisek."</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Atmenieji klavišai"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Norėdami naudoti spartųjį klavišą, vienu metu paspauskite vieną klavišą, užuot laikę nuspaudę kelis klavišus"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Spartieji klavišai"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Rodyti sparčiųjų klavišų sąrašą"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Darbo profilio klaviatūros ir įrankiai"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Nust. iš naujo"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Pasirinkite modifikavimo klavišą"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Pasirinkite naują „<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>“ slaptažodį:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"„<xliff:g id="IME_LABEL">%s</xliff:g>“ išdėstymas"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Numatytasis"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatinis: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Pasirinktas naudotojo: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Kalba"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Žymiklio greitis"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Žaidimų valdiklis"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Galite tinkinti šį įrenginį pagal savo poreikius. Vėliau šias pritaikymo neįgaliesiems funkcijas galite pakeisti nustatymuose."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Pakeisti šrifto dydį"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekrano skaitytuvas"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Fizinės klaviatūros parinktys"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtitrai"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Garsas"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Bendrieji"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Ekranas"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Spalva ir judesys"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Spalvų kontrastas"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Naudojant didesnį kontrastą, tekstas, mygtukai ir piktogramos išsiskiria labiau. Pasirinkite jūsų akiai patraukliausią kontrastą."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Kai kuriose programose gali būti palaikomos ne visos spalvos ir teksto kontrasto nustatymai"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Reguliuokite, kaip spalvos ir tekstas atrodo pasirinktos spalvos ekrano fone"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Peržiūra"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helena, Adamas"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Prieš 2 dienas"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Tęsti toliau?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Verslo kelionės ataskaita"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Jei reikia daugiau pagalbos, susisiekite su\nmanimi arba Helena. Ši ataskaita bus"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Kliento išlaidos"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekrano tamsinimas"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Sąveikos valdikliai"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Laiko valdikliai"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Vis tiek tęsti"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Atšaukti"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Didinimo nustatymai"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Didinimas naudojant spart. klavišą"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Didinti naud. spart. klav. ir palietus tris kartus"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Apie „<xliff:g id="SERVICE">%1$s</xliff:g>“"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Neskaidrus"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Didelio kontrasto tekstas"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Keiskite teksto spalvą į juodą arba baltą. Nustatykite didžiausią kontrastą su fonu."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Padidinti teksto kontrastą"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Keiskite teksto spalvą į juodą arba baltą, didindami kontrastą su fonu."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automat. atnaujinti ekrano didinimą"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Atnaujinti ekrano didinimą perkeliant programas"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Maitinimo mygt. baig. skamb."</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Laikyti garsumo klavišus"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Triskart paliesti ekraną"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Pritaikomumo šaukinių redagavimas"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Pasirinkite „%1$s“ spartųjį klavišą"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Tęsti"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Klausos įrenginiai"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Nustatykite ir tvarkykite ASHA ir „LE Audio“ klausos aparatus, vidinės ausies implantus ir kitus garso stiprinimo įrenginius"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Prijungtų klausos įrenginių nėra"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Pridėti klausos aparatų"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Klausos apar. susiejimas"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Klausos aparato suderinamumas"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Pagerinamas suderinamumas su teleritėmis ir sumažinamas nepageidaujamas triukšmas"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Apie klausos įrenginius"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Jei norite rasti kitus klausos įrenginius, kurių nepalaiko ASHA ar „LE Audio“, palieskite "<b>"„Susieti naują įrenginį“"</b>" &gt; "<b>"„Daugiau įrenginių“"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Klausos įrenginio susiejimas"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Šiame puslapyje galite susieti ASHA ir „LE Audio“ klausos įrenginius. Įsitikinkite, kad klausos įrenginys įjungtas ir paruoštas susieti."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Pasiekiami klausos įrenginiai"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Teksto pranešimai"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatinis duomenų perjungimas"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Naudoti duomenis iš bet kurios SIM kortelės, atsižvelgiant į aprėptį ir pasiekiamumą"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Tik duomenys"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Nustatyti"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Kitas"</string>
@@ -4943,12 +4927,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Padeda nustatyti santykinį atstumą nuo netoliese esančių įrenginių su UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Norėdami naudoti UWB, išjunkite lėktuvo režimą"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB ryšys nepasiekiamas dabartinėje vietovėje"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Susiekite su suderinamais įrenginiais naudodami „Thread“ ir mėgaukitės sklandžiomis išmaniųjų namų funkcijomis"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Jei norite naudoti „Thread“, išjunkite lėktuvo režimą"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Prieiga prie fotoaparato"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Prieiga prie mikrofono"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Programos ir paslaugos"</string>
@@ -5125,8 +5106,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Atšaukti"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrastas"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Įprastas"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Numatytasis"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Vidutinis"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Aukštas"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Šią programą galima atidaryti tik viename lange"</string>
diff --git a/res/values-lv/arrays.xml b/res/values-lv/arrays.xml
index 3d9322f..a050ce4 100644
--- a/res/values-lv/arrays.xml
+++ b/res/values-lv/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Maksas"</item>
     <item msgid="2047166446768045816">"Bezmaksas"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Nejauša MAC adrese (noklusējums)"</item>
-    <item msgid="741680937828608749">"Izmantot ierīces MAC adresi"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nē"</item>
     <item msgid="2163015208097377388">"Jā"</item>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index 9dc5b1c..4ee68e5 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Savienot pārī labo"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Savienot pārī kreiso"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Visiem pieejamajiem dzirdes aparātiem"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Citi dzirdes aparāta iestatījumi"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Varat mainīt vairākās ierīcēs izmantojamus iestatījumus, piemēram, saīsnes un indukcijas spoles vadīklas."</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Šai ierīcei"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio izeja"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Par audio izvadi"</string>
@@ -588,25 +586,17 @@
     <string name="no_device_lock_cancel" msgid="4412602160321228863">"Atcelt"</string>
     <string name="private_space_cancel_label" msgid="379259667396956886">"Atcelt"</string>
     <string name="private_space_setup_button_label" msgid="2094882154623560585">"Iestatīt"</string>
-    <!-- no translation found for private_space_setup_title (2272968244329821450) -->
-    <skip />
-    <!-- no translation found for private_space_hide_apps_summary (4418722947376042418) -->
-    <skip />
-    <!-- no translation found for private_space_setup_sub_header (5454598292017819146) -->
-    <skip />
-    <!-- no translation found for private_space_separate_account_text (4492251315012955548) -->
-    <skip />
-    <!-- no translation found for private_space_protected_lock_text (9123250938334372735) -->
-    <skip />
-    <!-- no translation found for private_space_install_apps_text (5693139160766464498) -->
-    <skip />
+    <string name="private_space_setup_title" msgid="2272968244329821450">"Privātā telpa"</string>
+    <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Varat paslēpt vai bloķēt privātās lietotnes atsevišķā vietā. Papildu drošībai varat izmantot atsevišķu Google kontu."</string>
+    <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Iestatiet privāto telpu"</string>
+    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Google konta izvēle privātajai telpai"</b>\n"Ja izmantojat īpašu kontu, tas palīdz gādāt, lai sinhronizētie faili, fotoattēli un e-pasta ziņojumi netiktu rādīti ārpus privātās telpas."</string>
+    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Bloķēšanas iestatīšana"</b>\n"Varat bloķēt privāto telpu, lai citi nevarētu to atvērt."</string>
+    <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Lietotņu instalēšana"</b>\n"Privātajā telpā ir atsevišķa piekļuve Play veikalam, tāpēc varat ērti instalēt lietotnes."</string>
     <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Kamēr privātā telpa būs bloķēta, tajā ievietotās lietotnes netiks rādītas atļauju pārvaldniekā, konfidencialitātes informācijas panelī un citos iestatījumos.\n\nPrivāto telpu nevar pārvietot uz citu ierīci. Ja vēlēsieties to izmantot citā ierīcē, privātā telpa būs jāiestata vēlreiz.\n\nIkviena persona, kas pievienos jūsu ierīci datoram vai instalēs ierīcē kaitīgas lietotnes, iespējams, varēs piekļūt jūsu privātajai telpai."</string>
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Notiek privātās telpas iestatīšana…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Kamēr privātā telpa ir bloķēta, tās lietotņu paziņojumi tiek slēpti"</string>
-    <!-- no translation found for private_space_explore_settings_title (1448128245941571654) -->
-    <skip />
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Izpētiet privātās telpas iestatījumus, kas ļauj paslēpt privāto telpu un iestatīt automātisku bloķēšanu"</string>
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Jūsu privātajā telpā jau ir instalētas nepieciešamās lietotnes"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Nevarēja izveidot privāto telpu"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Mēģināt vēlreiz"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Vai lietot ekrāna bloķēšanu privātās telpas atbloķēšanai?"</string>
@@ -629,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Lietotnes un paziņojumi"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Sensitīvi paziņojumi bloķēšanas ekrānā"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Rādīt sensitīvu saturu, ja privātā telpa ir atbloķēta"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Izveidojiet Google kontu, lai aizsargātu datu konfidencialitāti"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Nākamajā ekrānā varēsiet pierakstīties kontā, ko vēlaties izmantot privātajai telpai."</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Varat izveidot īpašu kontu, lai ierobežotu datu rādīšanu ārpus privātās telpas (tālāk ir sniegti piemēri)"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinhronizētie fotoattēli, faili, e-pasta ziņojumi, kontaktpersonas, pasākumi u. c. dati"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Lietotņu lejupielādes vēsture un ieteikumi"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Pārlūkošanas vēsture, grāmatzīmes un saglabātās paroles"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Satura ieteikumi, kas saistīti ar jūsu darbībām privātās telpas lietotnēs"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Labi"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Varat pievienot līdz <xliff:g id="COUNT">%d</xliff:g> pirkstu nospiedumiem."</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Jūs esat pievienojis maksimālo pirkstu nospiedumu skaitu."</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nevar pievienot citus pirkstu nospiedumus."</string>
@@ -933,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Jūsu mobilo sakaru operators neatļauj jums izveidot savienojumu ar šo tīklu, jo šis tīkls izmanto vecāku drošības protokolu, kas ir mazāk drošs."</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Atļaut WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Aizvērt"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Vai pārtraukt savienojumu ar <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Jūs esat izveidojis savienojumu ar WEP tīklu. Ja bloķēsiet šos tīklus, savienojums tiks pārtraukts."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Papildu opcijas"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Nolaižamais saraksts “Papildu opcijas”"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"izvērst"</string>
@@ -969,14 +949,10 @@
     <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Ieteicama 5,0 GHz josla"</string>
     <string name="wifi_ip_settings" msgid="6420498748726599133">"IP iestatījumi"</string>
     <string name="wifi_privacy_settings" msgid="3283946009000725698">"Konfidencialitāte"</string>
-    <!-- no translation found for wifi_privacy_mac_settings (3188060664478313363) -->
-    <skip />
-    <!-- no translation found for wifi_privacy_device_name_settings (3699130177041345275) -->
-    <skip />
-    <!-- no translation found for wifi_privacy_send_device_name_toggle_title (1228107313152880073) -->
-    <skip />
-    <!-- no translation found for wifi_privacy_send_device_name_toggle_summary (5995365836332817655) -->
-    <skip />
+    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"MAC"</string>
+    <string name="wifi_privacy_device_name_settings" msgid="3699130177041345275">"Ierīces nosaukums"</string>
+    <string name="wifi_privacy_send_device_name_toggle_title" msgid="1228107313152880073">"Nosūtīt ierīces nosaukumu"</string>
+    <string name="wifi_privacy_send_device_name_toggle_summary" msgid="5995365836332817655">"Kopīgot šīs ierīces nosaukumu ar tīklu"</string>
     <string name="wifi_subscription" msgid="4432423938285430113">"Abonements"</string>
     <string name="wifi_subscription_summary" msgid="18802471063384598">"Skatīt vai mainīt abonementu"</string>
     <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Nejauši atlasīta MAC adr."</string>
@@ -1263,10 +1239,8 @@
     <string name="dark_ui_text" msgid="4392646155331126666">"Tumšajā motīvā tiek izmantots melns fons noteiktos ekrānos, lai paildzinātu akumulatora darbību. Turklāt jūs varat iestatīt, kad ieslēgt un izslēgt tumšo motīvu."</string>
     <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tumšā motīva pamatā pašlaik ir jūsu gulēšanas režīma grafiks."</string>
     <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Gulēšanas režīma iestatījumi"</string>
-    <!-- no translation found for even_dimmer_display_title (8589063452814896327) -->
-    <skip />
-    <!-- no translation found for even_dimmer_display_summary (120301078873242172) -->
-    <skip />
+    <string name="even_dimmer_display_title" msgid="8589063452814896327">"Aptumšot papildus"</string>
+    <string name="even_dimmer_display_summary" msgid="120301078873242172">"Varat atļaut aptumšot ierīci vairāk nekā parasti."</string>
     <string name="screen_timeout" msgid="7709947617767439410">"Ekrāna noildze"</string>
     <string name="screen_timeout_summary" msgid="5558778019594643427">"Pēc <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivitātes"</string>
     <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nav iestatīts"</string>
@@ -1566,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Vai tīkla savienojumu pārvaldībai izmantot lietotni <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Neseni vietu pieprasījumi"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Darba profila atrašanās vieta"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Lietotņu atraš. vietu atļaujas"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Atrašanās vieta ir izslēgta"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# lietotnei no {total} ir piekļuve atrašanās vietai}zero{# lietotnēm no {total} ir piekļuve atrašanās vietai}one{# lietotnei no {total} ir piekļuve atrašanās vietai}other{# lietotnēm no {total} ir piekļuve atrašanās vietai}}"</string>
@@ -1899,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Izmantot ekrāna tastatūru"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Paturēt ekrānā, kamēr ir aktīva fiziskā tastatūra"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Atlēcienu taustiņi"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tastatūra ignorē ātru taustiņa nospiešanu vairākas reizes, ja tas tiek atkārtoti nospiests <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms laikā."</string>
     <string name="slow_keys" msgid="2891452895499690837">"Lēnie taustiņi"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Laiks, kas nepieciešams, lai aktivizētu nospiestu taustiņu, tiek pielāgots uz <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms."</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Taustiņu ķēde"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Izmantojot īsinājumtaustiņus, vienlaikus nospiediet tikai vienu taustiņu, nevis turiet nospiestus vairākus taustiņus."</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Īsinājumtaustiņi"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Rādīt īsinājumtaustiņu sarakstu"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatūras un rīki darba profilā"</string>
@@ -1960,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Atiestatīt"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Modificētājtaustiņa izvēle"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Izvēlieties jaunu taustiņu — <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Noklusējums"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Runa"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Rādītāja ātrums"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Spēļu vadība"</string>
@@ -2016,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Varat pielāgot šo ierīci savām vajadzībām. Šīs pieejamības funkcijas var mainīt vēlāk sadaļā Iestatījumi."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Mainīt fonta lielumu"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekrāna lasītājs"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Fiziskās tastatūras opcijas"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtitri"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Vispārīgi"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Attēlojums"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Krāsa un kustība"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Krāsu kontrasts"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Lielākā kontrastā teksts, pogas un ikonas skaidrāk izceļas. Izvēlieties kontrastu, kas, jūsuprāt, izskatās vislabāk."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Iespējams, dažās lietotnēs netiks atbalstīti visi krāsu un teksta kontrasta iestatījumi."</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Varat pielāgot, kā jāizskatās krāsām un tekstam salīdzinājumā ar ekrāna fona krāsu."</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Priekšskatījums"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helēna, Ādams"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Pirms 2 dienām"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Vai atgādināt?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Pārskats par komandējumu"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Ja vajadzīga turpmāka palīdzība, lūdzu, \nsazinieties ar mani vai Helēnu. Šis pārskats būs"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Klientu izdevumi"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekrāna aptumšošana"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Mijiedarbības vadīklas"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Laika vadīklas"</string>
@@ -2094,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Tomēr turpināt"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Atcelt"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Palielināšanas iestatījumi"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Palielināšana ar saīsni"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Palieliniet, lietojot saīsni un trīskāršu skārienu"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Par pakalpojumu <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2181,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Necaurspīdīga"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Liela kontrasta teksts"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mainīt teksta krāsu uz melnu vai baltu, lai palielinātu kontrastu ar fonu."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimāls teksta kontrasts"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Varat mainīt teksta krāsu uz melnu vai baltu, lai palielinātu kontrastu ar fonu."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ekrāna palielinājuma autom. atjaun."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Atjaunināt ekrāna palielinājumu lietotņu pārejās"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Barošanas poga beidz zvanu"</string>
@@ -2279,14 +2250,11 @@
     <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Velciet augšup ar diviem pirkstiem no apakšdaļas"</string>
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Turēt nospiestas skaļuma pogas"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trīsreiz pieskarieties ekrānam"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_title (4494142067760961499) -->
-    <skip />
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Pieejamības saīšņu rediģēšana"</string>
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Izvēlieties saīsni funkcijai %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Turpināt"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Dzirdes aparāti"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Iestatiet un pārvaldiet ASHA un LE Audio dzirdes aparātus, kohleāros implantus un citas skaņas pastiprināšanas ierīces."</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nav pievienots neviens dzirdes aparāts"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Pievienot dzirdes aparātus"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Dzirdes aparātu sav. pārī"</string>
@@ -2304,11 +2272,9 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Saderība ar dzirdes aparātiem"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Uzlabo saderību ar indukcijas spolēm un samazina nevēlamo trokšņu skaļumu"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Par dzirdes aparātiem"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Lai atrastu citus dzirdes aparātus, ko neatbalsta ASHA vai LE Audio, pieskarieties vienumam "<b>"Savienot pārī ar jaunu ierīci"</b>" &gt; "<b>"Skatīt citas ierīces"</b>"."</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Savienošana pārī"</string>
-    <!-- no translation found for accessibility_hearing_device_pairing_intro (7022201665808166517) -->
-    <skip />
+    <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Šajā lapā varat veidot savienojumus pārī ar ASHA un LE Audio dzirdes aparātiem. Dzirdes aparātam jābūt ieslēgtam un gatavam izveidot savienojumu pārī."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Pieejamie dzirdes aparāti"</string>
     <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Vai neredzat savu dzirdes aparātu?"</string>
     <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Skatiet citas ierīces"</string>
@@ -4678,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Īsziņas"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automātiska datu pārslēgšana"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Izmantojiet jebkuras SIM kartes nodrošinātos datus — atkarībā no pārklājuma un pieejamības."</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Tikai dati"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Iestatīt"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Tālāk"</string>
@@ -4709,14 +4681,10 @@
     <string name="erasing_sim" msgid="4237180547590463930">"Notiek eSIM kartes dzēšana…"</string>
     <string name="erase_sim_fail_title" msgid="1445700500168357303">"Nevar izdzēst eSIM karti"</string>
     <string name="erase_sim_fail_text" msgid="6898841004987411547">"Radās problēma, un šī eSIM karte netika dzēsta.\n\nRestartējiet ierīci un mēģiniet vēlreiz."</string>
-    <!-- no translation found for wifi_warning_dialog_title (7328515476966592390) -->
-    <skip />
-    <!-- no translation found for wifi_warning_dialog_text (6584060137703953174) -->
-    <skip />
-    <!-- no translation found for wifi_warning_continue_button (8171574741789688214) -->
-    <skip />
-    <!-- no translation found for wifi_warning_return_button (6226063181583906340) -->
-    <skip />
+    <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"Pirms dzēšanas izveidojiet Wi-Fi savienojumu"</string>
+    <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"Tādējādi vēlāk varēsiet ērtāk atkal izmantot eSIM, nesazinoties ar mobilo sakaru operatoru."</string>
+    <string name="wifi_warning_continue_button" msgid="8171574741789688214">"Tomēr izdzēst"</string>
+    <string name="wifi_warning_return_button" msgid="6226063181583906340">"Labi"</string>
     <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Savienojuma izveide ar ierīci"</string>
     <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Lietotne <xliff:g id="APPNAME">%1$s</xliff:g> vēlas izmantot pagaidu Wi‑Fi tīklu, lai izveidotu savienojumu ar jūsu ierīci."</string>
     <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nav atrasta neviena ierīce. Ierīcēm ir jābūt ieslēgtām un pieejamām savienojuma izveidei."</string>
@@ -4961,12 +4929,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Palīdz noteikt tuvumā esošo ierīču relatīvo pozīciju, ja šīs ierīces izmanto UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Izslēdziet lidojuma režīmu, lai izmantotu UWB."</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB nav pieejama pašreizējā atrašanās vietā."</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Izveidojiet savienojumu ar saderīgām ierīcēm, izmantojot protokolu Thread, lai mājas viedierīču lietošanas pieredze būtu nevainojama."</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Izslēdziet lidojuma režīmu, lai varētu izmantot protokolu Thread."</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Piekļuve kamerai"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Piekļuve mikrofonam"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Lietotnēm un pakalpojumiem"</string>
@@ -5143,8 +5108,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Atcelt"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrasts"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standarta"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Noklusējums"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Vidējs"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Augsts"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Šo lietotni var atvērt tikai vienā logā"</string>
diff --git a/res/values-mk/arrays.xml b/res/values-mk/arrays.xml
index 4e01fd7..f732a31 100644
--- a/res/values-mk/arrays.xml
+++ b/res/values-mk/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Сметај како ограничена мрежа"</item>
     <item msgid="2047166446768045816">"Сметај како неограничена мрежа"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Користи рандомизирана MAC-адреса (стандардно)"</item>
-    <item msgid="741680937828608749">"Користи ја MAC-адресата на уредот"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Не"</item>
     <item msgid="2163015208097377388">"Да"</item>
diff --git a/res/values-mk/strings.xml b/res/values-mk/strings.xml
index 66e6cce..47d89d7 100644
--- a/res/values-mk/strings.xml
+++ b/res/values-mk/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Спари го десното уво"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Спари го левото уво"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"За сите достапни слушни апарати"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Повеќе поставки на слушен апарат"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Променете ги поставките на повеќе уреди, како што се контролите на кратенките и телекалемите"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"За овој уред"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аудиоизлез"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"За аудио-излезот"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Се поставува „Приватен простор“…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Известувањата од апликациите во „Приватниот простор“ се скриени кога е заклучен"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Истражете ги поставките за „Приватен простор“ за да го скриете „Приватниот простор“ и да поставите автоматско заклучување"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Задолжителните апликации се веќе инсталирани во вашиот „Приватен простор“"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Не можеше да се постави „Приватен простор“"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Обиди се пак"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Да се користи закл. екран за откл. „Прив. прост.“?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Апликации и известувања"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Чувствителни известувања на заклучениот екран"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Прикажување на чувствителните содржини кога „Приватниот простор“ е отклучен"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Создајте сметка на Google за да ви помогне да ја зачувате приватноста на вашите податоци"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"На следниот екран, може да се најавите на сметка за да ја користите со вашиот „Приватен простор“"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Создајте посебна сметка за да спречите податоците да излезат од „Приватниот простор“, како:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Синхронизирани фотографии, датотеки, е-пораки, контакти, настани во календарот и друго"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Историја на преземање апликации и препораки"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Историја на прелистување, обележувачи и зачувани лозинки"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Предложени содржини поврзани со вашата активност во апликациите во „Приватниот простор“"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Сфатив"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Може да додадете до <xliff:g id="COUNT">%d</xliff:g> отпечатоци"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Додадовте максимален број на отпечатоци"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Не може да се додадат повеќе отпечатоци"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Вашиот оператор не ви дозволува да се поврзете на мрежава затоа што користи постар безбедносен протокол што не е толку безбеден"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Дозволете WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Затвори"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Да се прекине врската со <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Се поврзавте на мрежа со WEP. Ако ги блокирате мреживе, врската ќе се прекине."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Напредни опции"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Паѓачки список „Напредни опции“"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"прошири"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Да се користи <xliff:g id="NEW_APP">%s</xliff:g> за управување на вашите мрежни врски?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Последни барања за локација"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Локација за работен профил"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Дозволи за локација за апликации"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Локацијата е исклучена"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# од {total} апликации има пристап до локацијата}one{# од {total} апликации имаат пристап до локацијата}other{# од {total} апликации имаат пристап до локацијата}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Користете тастатура на екран"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Прикажувај ја на екранот додека е активна физичката тастатура"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Еластични копчиња"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Тастатурата игнорира брзи повторени притискања на истото копче во рок од <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Бавни копчиња"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Го приспособува времето потребно за активирање едно притискање на копче на <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Лепливи копчиња"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Притискајте ги копчињата за кратенки едно по едно наместо да ги држите копчињата притиснати заедно"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Кратенки на тастатурата"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Прикажи список со кратенки"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Тастатури и алатки за работниот профил"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Ресетирај"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Изберете го копчето модификатор"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Изберете ново копче за <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Стандардно"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Говор"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Брзина на покажувач"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Контролор на игра"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Може да го приспособувате уредот според вашите потреби. Овие функции за пристапност може да ги менувате подоцна во „Поставки“."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Променете ја големината на фонтот"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Читач на екран"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Опции за физичка тастатура"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Титлови"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Аудио"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Општи"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Приказ"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Боја и движење"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Контраст на бои"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Повисокиот контраст прави текстот, копчињата и иконите да се истакнуваат повеќе. Изберете го контрастот што ви изгледа најдобро."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Некои апликации можеби не ги поддржуваат сите поставки за контраст на бои и текст"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Приспособете како да изгледаат боите и текстот во однос на бојата на заднината на вашиот екран"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Преглед"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Хелен, Адам"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Пред 2 дена"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Ќе проверите?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Извештај за бизнис патувањето"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"За дополнителна помош, контактирајте со \nмене или Хелен. Извештајов ќе биде"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Трошоци на клиентот"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Затемнете го екранот"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Контроли за интеракција"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Контроли за тајминг"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Сепак продолжи"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Откажи"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Поставки за зголемување"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Зголемување со кратенка"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Зголемете со кратенка и троен допир"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"За <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Непровидно"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Текст со висок контраст"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Променете ја бојата на текстот во црна или бела. Го максимизира контрастот со заднината."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Максимиз. го контрастот на текстот"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Променете ја бојата на текстот во црна или бела за да го зголемите контрастот со заднината."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Автоматско ажурирање на зголемување на екран"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ажурирај зголемување екран при премини меѓу аплик."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Прекини повик со копче за вклучување"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Задржете ги копчињата за јачина на звук"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Троен допир на екранот"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Изменување на кратенките за пристапност"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Изберете ја вашата кратенка за %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Продолжи"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Слушни помагала"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Поставете ги и управувајте со слушните помагала, кохлеарните импланти и другите уреди за засилување со ASHA и LE Audio"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Не се поврзани слушни помагала"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Додајте слушни помагала"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Спарување слушни помагала"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Компатибилност со слушни помагала"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Ја подобрува компатибилноста со телекалемите и го намалува несаканиот шум"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"За слушните помагала"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"За да најдете други слушни апарати што не се поддржани од ASHA или LE Audio, допрете „"<b>"Спарете нов уред"</b>" &gt; "<b>"Видете повеќе уреди"</b>"“"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Спарете слушно помагало"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"На страницава може да ги спарите слушните апарати ASHA и LE Audio. Погрижете се вашиот слушен апарат да биде вклучен и подготвен за спарување."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Достапни слушни помагала"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Пораки"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Автоматско префрлање интернет"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Користете интернет од која било SIM-картичка зависно од покриеноста и достапноста"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Само за интернет"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Поставете"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Следно"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Помага да се идентификува релативната положба на уредите во близина што имаат UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Исклучете „Авионски режим“ за да користите UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB е недостапен на тековната локација"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"За беспрекорно доживување со паметен дом, поврзувајте се со компатибилни уреди со Thread"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Исклучете „Авионски режим“ за да користите Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Пристап до камерата"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Пристап до микрофонот"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"За апликации и услуги"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Откажи"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Контраст"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Стандарден"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Стандардно"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Среден"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Висок"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Апликацијава може да се отвори само во еден прозорец"</string>
diff --git a/res/values-ml/arrays.xml b/res/values-ml/arrays.xml
index b858617..a857fd9 100644
--- a/res/values-ml/arrays.xml
+++ b/res/values-ml/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"മീറ്റർ ചെയ്തതായി കണക്കാക്കുക"</item>
     <item msgid="2047166446768045816">"മീറ്റർ ചെയ്യാത്തതായി കണക്കാക്കുക"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ക്രമരഹിതമാക്കിയ MAC (ഡിഫോൾട്ട്)"</item>
-    <item msgid="741680937828608749">"ഉപകരണ MAC ഉപയോഗിക്കുക"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"ഇല്ല"</item>
     <item msgid="2163015208097377388">"ഉണ്ട്"</item>
diff --git a/res/values-ml/strings.xml b/res/values-ml/strings.xml
index a4d9c18..a8515b3 100644
--- a/res/values-ml/strings.xml
+++ b/res/values-ml/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"സുരക്ഷിതമല്ലാത്ത പഴയ സുരക്ഷാ പ്രോട്ടോക്കോൾ ഉപയോഗിക്കുന്നതിനാൽ ഈ നെറ്റ്‌വർക്കിലേക്ക് കണക്റ്റ് ചെയ്യാൻ നിങ്ങളുടെ സേവനദാതാവ് നിങ്ങളെ അനുവദിക്കുന്നില്ല"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP അനുവദിക്കുക"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"അടയ്ക്കുക"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> എന്നതിൽ നിന്ന് വിച്ഛേദിക്കണോ?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"നിങ്ങൾ ഒരു WEP നെറ്റ്‌വർക്കിലേക്ക് കണക്റ്റ് ചെയ്തിരിക്കുന്നു. ഈ നെറ്റ്‌വർക്കുകൾ ബ്ലോക്ക് ചെയ്താൽ, നിങ്ങൾ വിച്ഛേദിക്കപ്പെടും."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"വിപുലമായ ഓപ്ഷനുകൾ"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ഡ്രോപ്പ് ഡൗൺ പട്ടികയുടെ വിപുലമായ ഓപ്‌ഷനുകൾ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"വികസിപ്പിക്കുക"</string>
@@ -1542,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"നിങ്ങളുടെ നെറ്റ്‌വർക്ക് കണക്ഷനുകൾ നിയന്ത്രിക്കാൻ <xliff:g id="NEW_APP">%s</xliff:g> ആണോ ഉപയോഗിക്കുന്നത്?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"പുതിയ ലൊക്കേഷൻ അഭ്യർത്ഥനകൾ"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ഔദ്യോഗിക പ്രൊഫൈലിനായുള്ള ലൊക്കേഷൻ"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ആപ്പ് ലൊക്കേഷൻ അനുമതികൾ"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"ലൊക്കേഷൻ ഓഫാണ്"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} ആപ്പുകളിൽ # എണ്ണത്തിന് ലൊക്കേഷനിലേക്ക് ആക്‌സ‌സ് ഉണ്ട്}other{{total} ആപ്പുകളിൽ # എണ്ണത്തിന് ലൊക്കേഷനിലേക്ക് ആക്‌സ‌സ് ഉണ്ട്}}"</string>
@@ -1875,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ഓൺ-സ്‌ക്രീൻ കീബോർഡ് ഉപയോഗിക്കുക"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"ഫിസിക്കൽ കീബോർഡ് സജീവമായിരിക്കുമ്പോൾ സ്ക്രീനിൽ നിലനിർത്തുക"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"ബൗൺസ് കീകൾ"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> മില്ലിസെക്കൻഡിനുള്ളിൽ ഒരേ കീ അതിവേഗം ആവർത്തിച്ച് അമർത്തുന്നത് കീബോർഡ് അവഗണിക്കും"</string>
     <string name="slow_keys" msgid="2891452895499690837">"സ്ലോ കീകൾ"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"കീ പ്രസ്സ് പ്രവർത്തിക്കാൻ എടുക്കുന്ന സമയം <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> മില്ലിസെക്കൻഡ് ആയി ക്രമീകരിക്കും"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"സ്‌റ്റിക്കി കീകൾ"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"കുറുക്കുവഴികൾക്കായി, കീകൾ ഒരുമിച്ച് അമർത്തിപ്പിടിക്കുന്നതിന് പകരം ഒരു സമയം ഒരു കീ അമർത്തുക"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"കീബോഡ് കുറുക്കുവഴികൾ"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"കുറുക്കുവഴികളുടെ ലിസ്റ്റ് കാണിക്കുക"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"ഔദ്യോഗിക പ്രൊഫൈൽ കീബോർഡുകളും ടൂളുകളും"</string>
@@ -1936,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"റീസെറ്റ് ചെയ്യൂ"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"മോഡിഫയർ കീ തിരഞ്ഞെടുക്കുക"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> എന്നതിനായി പുതിയ കീ തിരഞ്ഞെടുക്കൂ:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> ലേഔട്ട്"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ഡിഫോൾട്ട്"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"സ്വയമേവ: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"തിരഞ്ഞെടുത്ത ഉപയോക്താവ്: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"സംഭാഷണം"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"പോയിന്റർ വേഗത"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"ഗെയിം കൺട്രോളർ"</string>
@@ -1992,8 +1992,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ആവശ്യങ്ങൾക്ക് അനുസരിച്ച് നിങ്ങൾക്ക് ഈ ഉപകരണം ഇഷ്ടാനുസൃതമാക്കാം. ഈ ഉപയോഗസഹായി ഫീച്ചറുകൾ പിന്നീട് ക്രമീകരണത്തിൽ മാറ്റാവുന്നതാണ്."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ഫോണ്ട് വലുപ്പം മാറ്റുക"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"സ്‌ക്രീൻ റീഡർ"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ഫിസിക്കൽ കീബോർഡ് ഓപ്ഷനുകൾ"</string>
     <string name="captions_category_title" msgid="574490148949400274">"സബ്ടൈറ്റിലുകൾ"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ഓഡിയോ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"പൊതുവായവ"</string>
@@ -2059,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"എന്തായാലും തുടരുക"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"റദ്ദാക്കുക"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"മാഗ്നിഫിക്കേഷൻ ക്രമീകരണം"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"കുറുക്കുവഴിയിലൂടെ മാഗ്നിഫൈ ചെയ്യൂ"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"കുറുക്കുവഴി, മൂന്ന് തവണ ടാപ്പ് എന്നിവയിലൂടെ മാഗ്നിഫൈ ചെയ്യൂ"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> എന്നതിനെ കുറിച്ച്"</string>
@@ -2243,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"വോളിയം കീകൾ അമർത്തിപ്പിടിക്കുക"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"സ്ക്രീൻ മൂന്ന് തവണ ടാപ്പ് ചെയ്യുക"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ഉപയോഗസഹായി കുറുക്കുവഴികൾ എഡിറ്റ് ചെയ്യുക"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s എന്നതിനുള്ള നിങ്ങളുടെ കുറുക്കുവഴി തിരഞ്ഞെടുക്കുക"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"തുടരുക"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"ശ്രവണ ഉപകരണങ്ങൾ"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA, LE ഓഡിയോ ശ്രവണ സഹായികളും കോക്ലിയർ ഇംപ്ലാന്റുകളും മറ്റ് ആംപ്ലിഫിക്കേഷൻ ഉപകരണങ്ങളും സജ്ജീകരിച്ച് മാനേജ് ചെയ്യുക"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"ശ്രവണ ഉപകരണങ്ങളൊന്നും കണക്‌റ്റ് ചെയ്‌തിട്ടില്ല"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"ശ്രവണ സഹായികൾ ചേർക്കുക"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"ശ്രവണ സഹായികൾ ജോടിയാക്കുക"</string>
@@ -2266,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"ശ്രവണ സഹായ അനുയോജ്യത"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ടെലികോയിലുകളുമായുള്ള അനുയോജ്യത മെച്ചപ്പെടുത്തുകയും അനാവശ്യ ശബ്ദം കുറയ്ക്കുകയും ചെയ്യുന്നു"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"ശ്രവണസഹായ ഉപകരണങ്ങളെ കുറിച്ച്"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA അല്ലെങ്കിൽ LE ഓഡിയോ പിന്തുണയ്ക്കാത്ത മറ്റ് ശ്രവണ ഉപകരണങ്ങൾ കണ്ടെത്താൻ, "<b>"പുതിയ ഉപകരണം ജോടിയാക്കുക"</b>" &gt; "<b>"കൂടുതൽ ഉപകരണങ്ങൾ കാണുക"</b>" ടാപ്പ് ചെയ്യുക"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"ശ്രവണ ഉപകരണം ജോടിയാക്കുക"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ഈ പേജിൽ ASHA, LE ഓഡിയോ എന്നീ കേൾവിക്കുള്ള ഉപകരണങ്ങൾ നിങ്ങൾക്ക് ജോടിയാക്കാം. കേൾവിക്കുള്ള ഉപകരണം ഓണാണെന്നും ജോടിയാക്കാൻ തയ്യാറാണെന്നും ഉറപ്പാക്കുക."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ലഭ്യമായ ശ്രവണ ഉപകരണങ്ങൾ"</string>
@@ -4639,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ടെക്‌സ്റ്റുകൾ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"സ്വയമേവയുള്ള ഡാറ്റാ മാറ്റം"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"കവറേജും ലഭ്യതയും അനുസരിച്ച് ഏതെങ്കിലും സിമ്മിൽ നിന്നുള്ള ഡാറ്റ ഉപയോഗിക്കുക"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ഡാറ്റ മാത്രം"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"സജ്ജീകരിക്കുക"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"അടുത്തത്"</string>
@@ -4917,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB ഉള്ള സമീപമുള്ള ഉപകരണങ്ങളുടെ ആപേക്ഷിക സ്ഥാനം തിരിച്ചറിയാൻ സഹായിക്കുന്നു"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB ഉപയോഗിക്കാൻ ഫ്ലൈറ്റ് മോഡ് ഓഫാക്കുക"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"നിലവിലെ ലൊക്കേഷനിൽ UWB ലഭ്യമല്ല"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"സുഗമമായ സ്മാർട്ട് ഹോം അനുഭവത്തിന്, Thread ഉപയോഗിച്ച് അനുയോജ്യമായ ഉപകരണങ്ങളിലേക്ക് കണക്റ്റ് ചെയ്യുക"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread ഉപയോഗിക്കാൻ ഫ്ലൈറ്റ് മോഡ് ഓഫാക്കുക"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"ക്യാമറ ആക്‌സസ്"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"മൈക്രോഫോൺ ആക്‌സസ്"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ആപ്പുകൾക്കും സേവനങ്ങൾക്കും"</string>
diff --git a/res/values-mn/arrays.xml b/res/values-mn/arrays.xml
index 62e884d..007d8d0 100644
--- a/res/values-mn/arrays.xml
+++ b/res/values-mn/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Хязгаартайгаар тохируулах"</item>
     <item msgid="2047166446768045816">"Хязгааргүйгээр тохируулах"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Санамсаргүй үүссэн MAC-г ашиглах (өгөгдмөл)"</item>
-    <item msgid="741680937828608749">"Төхөөрөмжийн MAC-г ашиглах"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Үгүй"</item>
     <item msgid="2163015208097377388">"Тийм"</item>
diff --git a/res/values-mn/strings.xml b/res/values-mn/strings.xml
index b3ab556..863ca24 100644
--- a/res/values-mn/strings.xml
+++ b/res/values-mn/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Баруун чих хослуулах"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Зүүн чих хослуулах"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Сонсголын бүх боломжтой төхөөрөмжид"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Сонсголын төхөөрөмжийн бусад тохиргоо"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Товчлол болон цахилгааны ороомог зэрэг төхөөрөмж хоорондын тохиргоог өөрчилнө үү"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Энэ төхөөрөмжид"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аудио гаралт"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Аудио оролтын тухай"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Хувийн орон зайг тохируулж байна…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Үүнийг түгжсэн үед хаалттай орон зайн аппуудын мэдэгдлийг нуудаг"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Хаалттай орон зайг нууж, автоматаар түгжихийг тохируулахын тулд хаалттай орон зайн тохиргоог судална уу"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Шаардлагатай аппуудыг таны хаалттай орон зайд аль хэдийн суулгасан"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Хаалттай орон зайг тохируулж чадсангүй"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Дахин оролдох"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Хувийн орон зайн түгжээг тайлахад дэлгэцийн түгжээг ашиглах уу?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Апп болон мэдэгдлүүд"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Түгжээтэй дэлгэц дээрх эмзэг мэдэгдлүүд"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Хаалттай орон зайн түгжээг тайлсан үед эмзэг контент харуулна уу"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Өгөгдлөө хувийн байлгахад туслахын тулд Google Бүртгэл үүсгэх"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Дараагийн дэлгэц дээр та хаалттай орон зайтайгаа ашиглах бүртгэлд нэвтрэх боломжтой"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Өгөгдлийг хаалттай орон зайнаас гадуур гарч ирэхийг зогсооход туслахын тулд зориулалтын бүртгэл үүсгэнэ үү. Жишээлбэл:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Синк хийсэн зураг, файл, имэйл, харилцагч, календарийн үйл явдал болон бусад өгөгдөл"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Аппын таталтын түүх болон зөвлөмжүүд"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Хөтчийн түүх, хавчуурга болон хадгалсан нууц үгнүүд"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Таны хаалттай орон зайн аппуудын үйл ажиллагаатай холбоотой санал болгосон контент"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Ойлголоо"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Та <xliff:g id="COUNT">%d</xliff:g> хүртэлх хурууны хээ нэмж болно"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Таны зөвшөөрөгдсөн хурууны хээний тоо гүйцсэн байна"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Өөр хурууны хээ нэмэх боломжгүй байна"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Энэ сүлжээ хамгаалалт багатай аюулгүй байдлын хуучин протокол ашигладаг тул таны оператор компани танд үүнтэй холбогдохыг зөвшөөрдөггүй"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP-г зөвшөөрөх"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Хаах"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g>-с салгах уу?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Та WEP сүлжээнд холбогдсон. Та эдгээр сүлжээг блоклосон тохиолдолд таныг салгана."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Дэлгэрэнгүй сонголтууд"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Дэлгэрэнгүй сонголтын эвхмэл жагсаалт"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"дэлгэх"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Сүлжээний холболтуудыг удирдахад <xliff:g id="NEW_APP">%s</xliff:g>-г ашиглах уу?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Саяхны байршлын хүсэлтүүд"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ажлын профайлын байршил"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Аппын байршлын зөвшөөрлүүд"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Байршил унтраалттай байна"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} аппын # нь байршилд хандах боломжтой}other{{total} аппын # нь байршилд хандах боломжтой}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Дэлгэц дээрх гарыг ашиглах"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Биет гар идэвхтэй үед үүнийг дэлгэцэд харуулна уу"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Ойх түлхүүрүүд"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Гар нь <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> мс доторх нэг товчлуурын шуурхай давтагдсан даралтыг үл хэрэгсэнэ"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Удаан товчнууд"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Товчлуур даралт идэвхжихэд зарцуулах хугацааг <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> мс болгож тохируулна"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Бэхэлсэн түлхүүрүүд"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Товчлолд товчлууруудыг хамтад нь удаан дарахын оронд нэг удаад нэг товчлуур дарна уу"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Гарын товчлол"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Товчлолын жагсаалтыг харуулах"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Ажлын профайлын гар &amp; хэрэгсэл"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Шинэчлэх"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Тохируулагч товч сонгох"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>-н шинэ товч сонгоно уу:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> бүдүүвч"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Өгөгдмөл"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Автомат: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Хэрэглэгчийн сонгосон: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Яриа"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Заагчийн хурд"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Тоглоом Контроллер"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Та энэ төхөөрөмжийг өөрийнхөө шаардлагад нийцүүлэн тохируулах боломжтой. Эдгээр сонголтуудыг дараа нь Тохиргоо хэсэгт өөрчлөх боломжтой."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Фонтын хэмжээг өөрчлөх"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Дэлгэц уншигч"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Биет гарын сонголтууд"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Тайлбар"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Аудио"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Ерөнхий"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Дэлгэц"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Өнгө болон хөдөлгөөн"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Өнгөний ялгарал"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Илүү өндөр ялгарал нь текст, товчлуур болон дүрс тэмдгийг илүү ялгаруулдаг. Танд хамгийн сайн тохирох ялгарлыг сонгоно уу."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Зарим апп бүх өнгө болон текстийн ялгарлын тохиргоог дэмжихгүй байж магадгүй"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Таны дэлгэцийн дэвсгэр өнгөний эсрэг өнгөнүүдийг болон текст хэрхэн харагдахыг тохируулна уу"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Урьдчилан үзэх"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Хелен, Адам"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 хоногийн өмнө"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Араас нь лавлах уу?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Бизнесийн аяллын тайлан"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Цааш нь тусламж авах бол \nнадтай эсвэл Хелентэй холбогдоно уу. Энэ тайлан нь дараах байх болно"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Клиентийн зардал"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Дэлгэцийг бараан болгох"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Харилцан үйлдлийн хяналт"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Цагийн тохиргооны хяналт"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Ямартай ч үргэлжлүүлэх"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Цуцлах"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Томруулах тохиргоо"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Товчлолоор томруулах"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Товчлол болон гурав товшилтоор томруулах"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>-н тухай"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Тунгалаг бус"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Өндөр ялгаралтай текст"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Текстийн өнгийг хар эсвэл цагаан болгож өөрчилнө үү. Дэвсгэрийн нягтралыг дээд зэргээр нэмэгдүүлнэ."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Текстийн ялгарлыг нэмэгдүүлэх"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Дэвсгэрээс ялгарах байдлыг нэмэгдүүлэхийн тулд текстийн өнгийг хар эсвэл цагаан болгож өөрчилнө үү."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Дэлгэц томруулахыг автоматаар шинэчлэх"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Апп шилжилт дээр дэлгэц томруулахыг шинэчлэх"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Асаах товч дуудлагыг тасална"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Дууны түвшний товчийг удаан дарах"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Дэлгэцийг гурав товших"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Хандалтын товчлолуудыг засах"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s-н товчлолоо сонгоно уу"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Үргэлжлүүлэх"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Сонсголын төхөөрөмжүүд"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA, LE Аудионы сонсголын төхөөрөмж, дунгийн суулгац болон бусад өсгөх төхөөрөмжийг тохируулж, удирдана уу"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ямар ч сонсголын төхөөрөмж холбогдоогүй"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Сонсголын төхөөрөмж нэмэх"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Сонсголын төхөөрөмж хослуулах"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Сонсголын төхөөрөмжийн зохицол"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Теле ороомогтой тохиромжтой байдлыг сайжруулж, хүсээгүй дуу чимээг багасгана"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Сонсголын төхөөрөмжүүдийн тухай"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA эсвэл LE Аудионоос дэмждэггүй сонсголын өөр төхөөрөмжийг олохын тулд "<b>"Шинэ төхөөрөмж хослуулах"</b>", "<b>"Бусад төхөөрөмжийг харах"</b>" дээр товшино уу"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Сонсголын төхөөрөмж хослуулах"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Та энэ хуудсан дээр ASHA болон LE Аудио сонсголын төхөөрөмжүүдийг хослуулах боломжтой. Таны сонсголын төхөөрөмж асаалттай бөгөөд хослуулахад бэлэн болохыг баталгаажуулна уу."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Боломжтой сонсголын төхөөрөмж"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Мессежүүд"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Автоматаар дата сэлгэх"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Хамрах хүрээ болон боломжтой байдлаас хамааран аль нэг SIM-н датаг ашиглана уу"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Зөвхөн дата"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Тохируулах"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Дараах"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB-тай ойролцоох төхөөрөмжүүдийн харгалзах байрлалыг тодорхойлоход тусална"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB-г ашиглахын тулд нислэгийн горимыг унтраах"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB нь одоогийн байршилд боломжгүй"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Дэд процесс"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Ухаалаг гэрийн саадгүй хэрэглээг авах бол Дэд процессыг ашиглан тохирох төхөөрөмжүүдэд холбогдоно уу"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Дэд процессыг ашиглахын тулд нислэгийн горимыг унтраана уу"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Камерын хандалт"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Микрофоны хандалт"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Апп болон үйлчилгээнд"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Цуцлах"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Ялгарал"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Стандарт"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Өгөгдмөл"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Дунд зэрэг"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Өндөр"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Энэ аппыг зөвхөн 1 цонхонд нээх боломжтой"</string>
diff --git a/res/values-mr/arrays.xml b/res/values-mr/arrays.xml
index ce2af9d..120f250 100644
--- a/res/values-mr/arrays.xml
+++ b/res/values-mr/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"मर्यादित डेटा वापराचे नेटवर्क"</item>
     <item msgid="2047166446768045816">"अमर्याद डेटा वापराचे नेटवर्क"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"रँडमाइझ केलेले MAC वापरा (डीफॉल्ट)"</item>
-    <item msgid="741680937828608749">"डिव्हाइस MAC वापरा"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"नाही"</item>
     <item msgid="2163015208097377388">"होय"</item>
diff --git a/res/values-mr/strings.xml b/res/values-mr/strings.xml
index 26bc13c..f75bf27 100644
--- a/res/values-mr/strings.xml
+++ b/res/values-mr/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"उजवा कान पेअर करा"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"डावा कान पेअर करा"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"उपलब्ध असणाऱ्या ऐकण्याच्या सर्व डिव्हाइससाठी"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"श्रवणयंत्रासंबंधित आणखी सेटिंग्ज"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"शॉर्टकट आणि टेलीकॉइल नियंत्रणे यांसारखी क्रॉस-डिव्हाइस सेटिंग्ज बदला"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"या डिव्‍हाइससाठी"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ऑडिओ आउटपुट"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ऑडिओ आउटपुटबद्दल"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"खाजगी स्पेस सेट करत आहे…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"खाजगी स्पेस लॉक केलेली असताना त्यामधील ॲप्ससंबंधित सूचना लपवल्या जातात"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"खाजगी स्पेस लपवण्यासाठी आणि आपोआप लॉक होणे सेट करण्यासाठी खाजगी स्पेसशी संबंधित सेटिंग्ज एक्सप्लोर करा"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"आवश्यक असलेली अ‍ॅप्स ही तुमच्या खाजगी स्पेसमध्ये आधीपासून इंस्टॉल केलेली आहेत"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"खाजगी स्पेस सेट करता आली नाही"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"पुन्हा प्रयत्न करा"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"खाजगी स्पेस अनलॉक करण्यासाठी स्क्रीन लॉक वापरायचे?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"अ‍ॅप्स आणि नोटिफिकेशन"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"लॉक स्‍क्रीनवरील संवेदनशील नोटिफिकेशन"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"खाजगी स्पेस अनलॉक केलेली असताना संवेदनशील आशय दाखवा"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"तुमचा डेटा खाजगी ठेवण्यात मदत व्हावी यासाठी एक Google खाते तयार करा"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"पुढील स्क्रीनवर तुम्ही तुमच्या खाजगी स्पेससोबत वापरण्यासाठी खात्यामध्ये साइन इन करू शकता"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"खाजगी स्पेसच्या बाहेर डेटा दिसण्यापासून थांबवण्यात मदत करण्यासाठी समर्पित खाते तयार करा, जसे की:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"सिंक केलेले फोटो, फाइल, ईमेल, संपर्क, कॅलेंडर इव्हेंट आणि इतर डेटा"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"ॲप डाउनलोड इतिहास आणि शिफारशी"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ब्राउझिंग इतिहास, बुकमार्क आणि सेव्ह केलेले पासवर्ड"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"खाजगी स्पेसच्या ॲप्समधील तुमच्या अ‍ॅक्टिव्हिटीशी संबंधित सुचवलेला आशय"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"समजले"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"तुम्ही <xliff:g id="COUNT">%d</xliff:g> पर्यंत फिंगरप्रिंट जोडू शकता"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"तुम्ही जास्तीत जास्त फिंगरप्रिंट जोडले आहेत"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"आणखी फिंगरप्रिंट जोडू शकत नाही"</string>
@@ -822,9 +811,9 @@
     <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"‍डिस्कनेक्ट करा"</string>
     <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"पेअर करा आणि कनेक्ट करा"</string>
     <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"ब्लूटूथ सुरू केल्यावर, डिव्हाइस हे जवळील ब्लूटूथ डिव्‍हाइसशी संवाद साधेल"</string>
-    <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"ब्लूटूथ सुरू केले असते तेव्हा, तुमचे डिव्हाइस जवळपासच्या इतर ब्लूटूथ डिव्हाइसशी संवाद साधू शकते. Quick Share, Find My Device यांसारखी वैशिष्ट्ये आणि डिव्हाइसचे स्थान ब्लूटूथ वापरतात."</string>
+    <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"ब्लूटूथ सुरू असताना, तुमचे डिव्हाइस जवळपासच्या इतर ब्लूटूथ डिव्हाइसशी संवाद साधू शकते. क्विक शेअर, Find My Device यांसारखी वैशिष्ट्ये आणि डिव्हाइसचे स्थान ब्लूटूथ वापरतात."</string>
     <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"ब्‍लूटूथ सुरू असते, तेव्हा तुमचे डिव्‍हाइस इतर जवळपासच्‍या ब्‍लूटूथ डिव्‍हाइसशी संवाद साधू शकते.\n\nडिव्‍हाइसच्या अनुभवामध्ये सुधारणा करण्‍यासाठी, ब्‍लूटूथ बंद असतानादेखील, अ‍ॅप्स आणि सेवा जवळपासची डिव्‍हाइस कधीही स्‍कॅन करू शकतात. उदाहरणार्थ, हे स्थानावर आधारित वैशिष्ट्ये आणि सेवांमध्ये सुधारणा करण्यासाठी वापरले जाऊ शकते. तुम्‍ही हे ब्लूटूथ स्‍कॅनिंग सेटिंग्‍जमध्‍ये जाऊन बदलू शकता."</string>
-    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"ब्लूटूथ सुरू केले असते तेव्हा, तुमचे डिव्हाइस जवळपासच्या इतर ब्लूटूथ डिव्हाइसशी संवाद साधू शकते. Quick Share, Find My Device यांसारखी वैशिष्ट्ये आणि डिव्हाइस स्थान ब्लूटूथ वापरतात.\n\nब्लूटूथ बंद असतानादेखील ॲप्स आणि सेवा या कधीही जवळपासच्या डिव्हाइससाठी तरीही स्कॅन करू शकतात. उदाहरणार्थ, स्थानावर आधारित वैशिष्ट्ये आणि सेवा यांमध्ये सुधारणा करण्यासाठी याचा वापर केला जाऊ शकतो. तुम्ही ब्लूटूथ स्कॅन करण्याशी संबंधित सेटिंग्जमध्ये हे बदलू शकता."</string>
+    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"ब्लूटूथ सुरू असताना, तुमचे डिव्हाइस जवळपासच्या इतर ब्लूटूथ डिव्हाइसशी संवाद साधू शकते. क्विक शेअर, Find My Device यांसारखी वैशिष्ट्ये आणि डिव्हाइसचे स्थान ब्लूटूथ वापरतात.\n\nब्लूटूथ बंद असतानादेखील ॲप्स आणि सेवा या कधीही जवळपासच्या डिव्हाइससाठी तरीही स्कॅन करू शकतात. उदाहरणार्थ, स्थानावर आधारित वैशिष्ट्ये आणि सेवा यांमध्ये सुधारणा करण्यासाठी याचा वापर केला जाऊ शकतो. तुम्ही ब्लूटूथ स्कॅन करण्याशी संबंधित सेटिंग्जमध्ये हे बदलू शकता."</string>
     <string name="bluetooth_scan_change" msgid="1744636222637390367">"बदला"</string>
     <string name="device_details_title" msgid="1155622417516195481">"डिव्हाइस तपशील"</string>
     <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"कीबोर्ड सेटिंग्ज"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"नेटवर्क कमी सुरक्षित असलेला जुना सुरक्षा प्रोटोकॉल वापरते, त्यामुळे तुमचा वाहक तुम्हाला या नेटवर्कशी कनेक्ट करण्याची अनुमती देत नाही"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP ला अनुमती द्या"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"बंद करा"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> वरून डिस्कनेक्ट करायचे आहे का?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"तुम्ही WEP नेटवर्कशी कनेक्ट केलेले आहे. तुम्ही ही नेटवर्क ब्लॉक केल्यास, तुम्हाला डिस्कनेक्ट केले जाईल."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"प्रगत पर्याय"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ड्रॉप-डाउन सूचीचे प्रगत पर्याय"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"विस्तार करा"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"तुमची नेटवर्क कनेक्शन व्यवस्थापित करण्यासाठी <xliff:g id="NEW_APP">%s</xliff:g> वापरायचा?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"अलीकडील स्थान विनंत्या"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"कार्य प्रोफाइलसाठी स्थान"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ॲपसाठी स्थानाच्या परवानग्या"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"स्‍थान बंद आहे"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} पैकी # अ‍ॅपला स्थानाचा अ‍ॅक्सेस आहे}other{{total} पैकी # अ‍ॅप्सना स्थानाचा अ‍ॅक्सेस आहे}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ऑन-स्क्रीन कीबोर्ड वापरा"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"वास्तविक कीबोर्ड अ‍ॅक्टिव्ह असताना त्यास स्क्रीनवर ठेवा"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"बाउन्स की"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"कीबोर्ड <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> मिसेमध्ये एकच की वारंवार प्रेस करण्याकडे दुर्लक्ष करतो"</string>
     <string name="slow_keys" msgid="2891452895499690837">"स्लो की"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> मिसेपर्यंत अ‍ॅक्टिव्हेट होण्यासाठी की प्रेसकरण्याकरिता लागणारा वेळ अ‍ॅडजस्ट करा"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"स्टिकी की"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"की एकत्र धरून ठेवण्याऐवजी शॉर्टकटसाठी एकावेळी एक की प्रेस करा"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"कीबोर्ड शॉर्टकट"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"शॉर्टकटची सूची दाखवा"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"कार्य प्रोफाइल कीबोर्ड आणि टूल"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"रीसेट करा"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"मॉडिफायर की निवडा"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> साठी नवीन की निवडा:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"डीफॉल्ट"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"भाषण"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"पॉइंटर वेग"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"गेम नियंत्रक"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"तुम्ही तुमच्या गरजेनुसार हे डिव्हाइस कस्टमाइझ करू शकता. ही अ‍ॅक्सेसिबिलिटी वैशिष्ट्ये नंतर सेटिंग्जमध्ये बदलता येतात."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"फाँटचा आकार बदला"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"स्क्रीन रीडर"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"वास्तविक कीबोर्ड पर्याय"</string>
     <string name="captions_category_title" msgid="574490148949400274">"कॅप्शन"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ऑडिओ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"सर्वसाधारण"</string>
     <string name="display_category_title" msgid="6638191682294461408">"डिस्प्ले"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"रंग आणि मोशन"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"रंग कॉंट्रास्ट"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"उच्च कॉंट्रास्ट असेल, तर मजकूर, बटणे आणि आयकन आणखी ठळकपणे दिसतात. तुम्हाला सर्वोत्तम वाटणारा कॉंट्रास्ट निवडा."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"काही ॲप्स ही रंग आणि मजकूर यांच्या कॉंट्रास्टसंबंधित सर्व सेटिंग्जना कदाचित सपोर्ट करणार नाहीत"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"तुमच्या स्क्रीनच्या बॅकग्राउंडच्या रंगाविरुद्ध, रंग आणि मजकूर कसे दिसतील हे अ‍ॅडजस्ट करा"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"पूर्वावलोकन"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"हेलन, ॲडम"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"२ दिवसांपूर्वी"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"फॉलोअप घ्यायचाय?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"व्यवसाय सहलीचा अहवाल"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"पुढील साहाय्यासाठी, कृपया \nमाझ्याशी किंवा हेलनशी संपर्क साधा. हा अहवाल असा असेल"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"क्लायंटसंबंधित खर्च"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"स्क्रीन आणखी गडद करा"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"संवाद नियंत्रणे"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"वेळ नियंत्रणे"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"तरीही पुढे सुरू ठेवा"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"रद्द करा"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"मॅग्निफिकेशन सेटिंग्ज"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"शॉर्टकटद्वारे मॅग्निफाय करा"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"शॉर्टकट वापरून आणि तीन वेळा टॅप करून मॅग्निफाय करा"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> बद्दल"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"पारदर्शक नाही"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"उच्च कॉंट्रास्ट मजकूर"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"मजकुराचा रंग काळा किंवा पांढरा यावर बदला. बॅकग्राउंड वापरून काँट्रास्ट वाढवते."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"मजकुराचा काँट्रास्ट वाढवा"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"बॅकग्राउंडसह काँट्रास्ट वाढवण्यासाठी मजकुराचा रंग बदलून काळा किंवा पांढरा करा."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"स्क्रीन विस्तृतीकरण स्वयं अद्ययावत करा"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"अ‍ॅप संक्रमणांवर स्क्रीन विस्तृतीकरण अद्ययावत करा"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"पॉवर बटण कॉल समाप्त करते"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"व्हॉल्यूम की प्रेस करून ठेवा"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"स्क्रीनवर तीन वेळा टॅप करा"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ॲक्सेसिबिलिटी शॉर्टकट संपादित करा"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s साठी तुमचा शॉर्टकट निवडा"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"सुरू ठेवा"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"श्रवणयंत्रे"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA आणि LE ऑडिओ श्रवणयंत्रे, कॉक्लियर इंप्लांट आणि इतर अँप्लिफिकेशन डिव्हाइस सेट करा व व्यवस्थापित करा"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"कोणतीही श्रवणयंत्रे कनेक्ट केलेली नाहीत"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"श्रवणयंत्रे जोडा"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"श्रवणयंत्रे पेअर करा"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"श्रवणयंत्राची कंपॅटिबिलिटी"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"टेलीकॉइलसह कंपॅटिबिलिटीमध्ये सुधारणा करते आणि नकोसा आवाज कमी करते"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"ऐकण्याच्या डिव्हाइसबद्दल"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA किंवा LE ऑडिओ सोपोर्ट करत नसलेली श्रवणयंत्रे शोधण्यासाठी, "<b>"नवीन डिव्हाइस पेअर करा"</b>" &gt; "<b>"आणखी डिव्हाइस पहा"</b>" वर टॅप करा"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"श्रवणयंत्र डिव्हाइस पेअर करा"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"तुम्ही या पेजवर ASHA आणि LE ऑडिओ श्रवणयंत्रे पेअर करू शकता. तुमचे श्रवणयंत्र सुरू केले असून, ते पेअर करण्यासाठी तयार असल्याची खात्री करा."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"उपलब्ध श्रवणयंत्रे"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"एसएमएस"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"डेटा आपोआप स्विच करणे"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"कव्हरेज आणि उपलब्धतेनुसार कोणत्याही एका सिममधील डेटा वापरा"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"फक्त डेटा"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"सेट करा"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"पुढील"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"जवळपासच्या UWB असलेल्या डिव्हाइसचे संबंधित स्थान ओळखण्यात मदत करते"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB वापरण्यासाठी विमान मोड बंद करा"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"सध्याच्या स्थानावर UWB उपलब्ध नाही"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"थ्रेड"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"विनाव्यत्यय स्‍मार्ट होम अनुभवासाठी थ्रेड वापरून कंपॅटिबल डिव्हाइसशी कनेक्ट करा"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"थ्रेड वापरण्यासाठी विमान मोड बंद करा"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"कॅमेराचा अ‍ॅक्सेस"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"मायक्रोफोनचा अ‍ॅक्सेस"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ॲप्स आणि सेवांसाठी"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"रद्द करा"</string>
     <string name="contrast_title" msgid="6885768151336508075">"कॉंट्रास्ट"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"साधारण"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"डीफॉल्ट"</string>
     <string name="contrast_medium" msgid="384414510709285811">"मध्यम"</string>
     <string name="contrast_high" msgid="3988567609694797696">"उच्च"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"हे अ‍ॅप फक्त एका विंडोमध्ये उघडले जाऊ शकते"</string>
diff --git a/res/values-ms/arrays.xml b/res/values-ms/arrays.xml
index dfd367e..4ee924f 100644
--- a/res/values-ms/arrays.xml
+++ b/res/values-ms/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Anggap sebagai bermeter"</item>
     <item msgid="2047166446768045816">"Anggap sebagai tidak bermeter"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Gunakan MAC terawak (lalai)"</item>
-    <item msgid="741680937828608749">"Gunakan MAC peranti"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Tidak"</item>
     <item msgid="2163015208097377388">"Ya"</item>
diff --git a/res/values-ms/strings.xml b/res/values-ms/strings.xml
index db7232a..c4440a9 100644
--- a/res/values-ms/strings.xml
+++ b/res/values-ms/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Gandingkan telinga kanan"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Gandingkan telinga kiri"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Untuk semua peranti pendengaran yang tersedia"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Lagi tetapan peranti pendengaran"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Ubah tetapan silang peranti seperti pintasan dan kawalan telegegelung"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Untuk peranti ini"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Output audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Perihal output audio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Menyediakan ruang peribadi…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Pemberitahuan daripada apl ruang peribadi disembunyikan apabila ruang peribadi dikunci"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Terokai tetapan ruang privasi untuk menyembunyikan ruang privasi dan menyediakan penguncian automatik"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Apl yang diperlukan telah dipasang dalam ruang privasi anda"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Tidak dapat menyediakan ruang peribadi"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Cuba Lagi"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Gunakan kunci skrin untuk membuka kunci ruang peribadi?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apl dan pemberitahuan"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Pemberitahuan sensitif pada skrin kunci"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Tunjukkan kandungan sensitif apabila ruang privasi tidak berkunci"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Buat Google Account untuk membantu kami memastikan data anda dirahsiakan"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Anda boleh log masuk ke akaun untuk digunakan dengan ruang peribadi anda pada skrin seterusnya"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Buat akaun khusus untuk membantu kami menghentikan data yang dipaparkan di luar ruang privasi, seperti:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Foto, fail, e-mel, kenalan, acara kalendar dan data lain yang disegerakkan"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Sejarah muat turun apl dan syor"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Sejarah penyemakan imbas, penanda halaman dan kata laluan yang disimpan"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Kandungan yang dicadangkan berkaitan dengan aktiviti anda pada apl ruang privasi"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Anda boleh menambah sehingga <xliff:g id="COUNT">%d</xliff:g> cap jari"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Anda telah menambahkan bilangan maksimum cap jari"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Tidak boleh menambahkan lagi cap jari"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Pembawa anda tidak membenarkan anda menyambung kepada rangkaian ini kerana rangkaian ini menggunakan protokol keselamatan lebih lama yang kurang selamat"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Benarkan WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Tutup"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Putuskan sambungan daripada <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Anda disambungkan kepada rangkaian WEP. Jika anda menyekat rangkaian ini, anda akan diputuskan sambungan."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Pilihan terperinci"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Pilihan Terperinci senarai lungsur"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"kembangkan"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Gunakan <xliff:g id="NEW_APP">%s</xliff:g> untuk mengurus sambungan rangkaian anda?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Permintaan lokasi terbaharu"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokasi untuk profil kerja"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Kebenaran lokasi apl"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokasi dimatikan"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# daripada {total} apl mempunyai akses kepada lokasi}other{# daripada {total} apl mempunyai akses kepada lokasi}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Gunakan papan kekunci pada skrin"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Pastikan papan kekunci itu pada skrin semasa papan kekunci fizikal aktif"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Kekunci Lantun"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Papan kekunci mengabaikan dengan cepat tekanan berulang bagi kekunci yang sama dalam masa <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Kekunci perlahan"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Melaraskan masa yang diambil untuk mengaktifkan tekanan kekunci kepada <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Kekunci Lekit"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Tekan satu kekunci pada satu-satu masa untuk membuat pintasan dan bukan menahan beberapa kekunci secara serentak"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Pintasan papan kekunci"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Tunjukkan senarai pintasan"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Papan kekunci &amp; alatan profil kerja"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Tetapkan semula"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Pilih kunci pengubah suai"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Pilih kunci baharu untuk <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Reka letak <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Lalai"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatik: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Pengguna dipilih: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Pertuturan"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Kelajuan penuding"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Pengawal Permainan"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Anda boleh menyesuaikan peranti ini mengikut keperluan anda. Ciri kebolehaksesan ini boleh diubah kemudian dalam Tetapan."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Tukar saiz fon"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Pembaca skrin"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Pilihan papan kekunci fizikal"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Sari kata"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Umum"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Paparan"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Warna dan gerakan"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kontras warna"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Kontras yang lebih tinggi menjadikan teks, butang dan ikon lebih menonjol. Pilih kontras yang paling sesuai untuk anda."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Sesetengah apl mungkin tidak menyokong semua tetapan kontras warna dan teks"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Laraskan warna dan teks dengan warna latar skrin anda"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Pratonton"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 hari yang lalu"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Buat susulan?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Laporan lawatan urusan perniagaan"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Untuk mendapatkan bantuan lanjut, sila hubungi \nsaya atau Helen. Laporan ini akan"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Perbelanjaan Klien"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Jadikan skrin lebih gelap"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Kawalan interaksi"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kawalan pemasaan"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Teruskan juga"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Batal"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Tetapan pembesaran"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Besarkan menggunakan pintasan"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Besarkan menggunakan pintasan &amp; tiga ketikan"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Perihal <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Bukan lut sinar"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Teks kontras tinggi"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Menukar warna teks kepada hitam atau putih. Memaksimumkan kontras dengan latar belakang."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimumkan kontras teks"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Ubah warna teks kepada hitam atau putih untuk meningkatkan kontras dengan latar."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Auto kemas kini pembesaran skrin"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Kemas kini pembesaran skrin pada peralihan apl"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Butang kuasa menamatkan panggilan"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Tahan kekunci kelantangan"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Ketik tiga kali pada skrin"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edit pintasan kebolehaksesan"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Pilih pintasan anda untuk %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Teruskan"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Peranti pendengaran"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Sediakan dan urus alat bantu pendengaran, implan koklea dan peranti penguatan ASHA dan LE Audio yang lain"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Tiada peranti pendengaran disambungkan"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Tambah alat bantu dengar"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Gandingkan alat bantu pendengaran"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Keserasian alat bantu pendengaran"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Meningkatkan keserasian dengan telegegelung dan mengurangkan hingar yang tidak diingini"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Perihal peranti pendengaran"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Untuk menemukan peranti pendengaran lain yang tidak disokong oleh ASHA atau LE Audio, ketik "<b>"Gandingkan peranti baharu"</b>" &gt; "<b>"Lihat lagi peranti"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Ganding peranti pendengaran"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Anda boleh menggandingkan peranti pendengaran ASHA dan LE Audio pada halaman ini. Pastikan peranti pendengaran anda dihidupkan dan sedia untuk digandingkan."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Peranti pendengaran yang tersedia"</string>
@@ -4168,7 +4146,7 @@
     <string name="keywords_long_background_tasks" msgid="5788956269136054574">"pekerjaan panjang, pemindahan data, tugas latar"</string>
     <string name="run_backup_tasks_title" msgid="8572480651659803275">"Melaksanakan tugas sandaran pada latar"</string>
     <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Benarkan apl untuk menjalankan tugas berkaitan sandaran pada latar"</string>
-    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Menunjukkan bahawa apl ini mengandungi kes penggunaan utama yang memerlukan apl ini untuk menyandarkan atau menyegerakkan kandungan. Memberikan kebenaran ini membolehkan apl dijalankan pada latar untuk tempoh masa yang lebih lama bagi menyelesaikan kerja berkaitan sandaran. \n\nJika kebenaran ini ditolak, sistem tidak akan memberikan sebarang pengecualian khusus kepada apl ini untuk menyelesaikan kerja berkaitan sandaran pada latar."</string>
+    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Menunjukkan bahawa apl ini mengandungi kes penggunaan utama yang memerlukan apl ini untuk menyandarkan atau menyegerakkan kandungan. Tindakan memberikan kebenaran ini membolehkan apl dijalankan pada latar untuk tempoh masa yang lebih lama bagi menyelesaikan kerja berkaitan sandaran. \n\nJika kebenaran ini ditolak, sistem tidak akan memberikan sebarang pengecualian khusus kepada apl ini untuk menyelesaikan kerja berkaitan sandaran pada latar."</string>
     <string name="keywords_run_backup_tasks" msgid="632219905465766211">"sandarkan tugasan, sandarkan kerja"</string>
     <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Tetapkan semula had kadar ShortcutManager"</string>
     <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Had kadar ShortcutManager telah ditetapkan semula"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Teks"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Penukaran data automatik"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Penggunaan data daripada mana-mana SIM bergantung pada liputan dan ketersediaan"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data sahaja"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Sediakan"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Seterusnya"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Membantu mengenal pasti penempatan relatif peranti berdekatan yang mempunyai UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Matikan mod pesawat untuk menggunakan UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB tidak tersedia di lokasi semasa"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Urutan"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Sambung kepada peranti yang serasi menggunakan Urutan untuk mendapatkan pengalaman kediaman pintar yang lancar"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Matikan mod pesawat untuk menggunakan Urutan"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Akses kamera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Akses mikrofon"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Untuk apl dan perkhidmatan"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Batal"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontras"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Lalai"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Sederhana"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Tinggi"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Apl ini hanya boleh dibuka dalam 1 tetingkap"</string>
diff --git a/res/values-my/arrays.xml b/res/values-my/arrays.xml
index 882b637..c16fdbb 100644
--- a/res/values-my/arrays.xml
+++ b/res/values-my/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"အခမဲ့မဟုတ်အဖြစ် သတ်မှတ်ရန်"</item>
     <item msgid="2047166446768045816">"အခမဲ့အဖြစ် သတ်မှတ်ရန်"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ကျပန်း MAC ကို အသုံးပြုရန် (မူရင်း)"</item>
-    <item msgid="741680937828608749">"စက်၏ MAC သုံးရန်"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"မရှိ"</item>
     <item msgid="2163015208097377388">"Yes"</item>
diff --git a/res/values-my/strings.xml b/res/values-my/strings.xml
index b03df29..17b54fa 100644
--- a/res/values-my/strings.xml
+++ b/res/values-my/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"ညာဘက် ချိတ်ဆက်ရန်"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"ဘယ်ဘက် ချိတ်ဆက်ရန်"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"ရနိုင်သော နားကြားကိရိယာအားလုံးအတွက်"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"နောက်ထပ် နားကြားကိရိယာ ဆင်တင်များ"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"ဖြတ်လမ်းလင့်ခ်၊ သံလိုက်ဖမ်းတိုင် သတ်မှတ်ချက်များကဲ့သို့ စက်များကြားသုံးနိုင်သော ဆက်တင်များကို ပြောင်းနိုင်သည်"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"ဤစက်ပစ္စည်းအတွက်"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"အသံထွက်မည့် ကိရိယာ"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"အသံထွက်မည့် ကိရိယာအကြောင်း"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"သီးသန့်နေရာကို စနစ်ထည့်သွင်းနေသည်…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"သီးသန့်နေရာ လော့ခ်ချထားချိန်တွင် ၎င်းရှိအက်ပ်များမှ အကြောင်းကြားချက်များကို ဖျောက်ထားသည်"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"သီးသန့်နေရာကို ဖျောက်ထားပြီး အလိုအလျောက် လော့ခ်ချခြင်းကို စနစ်ထည့်သွင်းရန် သီးသန့်နေရာ ဆက်တင်များကို လေ့လာခြင်း"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"လိုအပ်သော အက်ပ်များကို သင်၏သီးသန့်နေရာတွင် ထည့်သွင်းပြီးဖြစ်သည်"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"သီးသန့်နေရာကို စနစ်ထည့်သွင်း၍မရပါ"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ထပ်စမ်းရန်"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"သီးသန့်နေရာကို ဖွင့်ရန် ဖန်သားပြင်လော့ခ် သုံးမလား။"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"အက်ပ်နှင့် အကြောင်းကြားချက်"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"လော့ခ်မျက်နှာပြင်ရှိ သတိထားရမည့် အကြောင်းကြားချက်"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"သီးသန့်နေရာ ဖွင့်ထားစဉ် သတိထားရမည့် အကြောင်းအရာ ပြပါ"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"သင့်ဒေတာကို သီးသန့်ထားနိုင်ရန် Google Account ပြုလုပ်ပါ"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"နောက်ဖန်သားပြင်တွင် သင့်သီးသန့်နေရာဖြင့် သုံးရန် အကောင့်သို့ လက်မှတ်ထိုးဝင်နိုင်ပါသည်"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"သီးသန့်နေရာအပြင်ဘက်တွင် ဒေတာပေါ်နေခြင်းကို ရပ်တန့်နိုင်ရန် သီးသန့်အကောင့် ပြုလုပ်ပါ။ ဒေတာနမူနာ-"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"စင့်ခ်လုပ်ထားသော ဓာတ်ပုံ၊ ဖိုင်၊ အီးမေးလ်၊ အဆက်အသွယ်၊ ပြက္ခဒိန်အစီအစဉ်နှင့် အခြားဒေတာများ"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"အက်ပ်ဒေါင်းလုဒ်မှတ်တမ်းနှင့် အကြံပြုချက်များ"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ကြည့်ရှုမှုမှတ်တမ်း၊ လိပ်စာနှင့် သိမ်းထားသောစကားဝှက်များ"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"သီးသန့်နေရာ အက်ပ်များရှိ သင့်လုပ်ဆောင်ချက်နှင့် သက်ဆိုင်သော အကြံပြုထားသည့် အကြောင်းအရာ"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"နားလည်ပြီ"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"လက်ဗွေ <xliff:g id="COUNT">%d</xliff:g> ခု အထိ ထည့်နိုင်သည်"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"အများဆုံးထည့်နိုင်သည့် လက်ဗွေရာအရေအတွက်အထိ ထည့်သွင်းပြီးဖြစ်သည်"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"နောက်ထပ်လက်ဗွေရာများ ထည့်၍မရတော့ပါ"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"ဤကွန်ရက်သည် သိပ်မလုံခြုံသော လုံခြုံရေးပရိုတိုကောအဟောင်းကို အသုံးပြုထားသဖြင့် သင့်ဖုန်းကုမ္ပဏီသည် သင့်အား ဤကွန်ရက်နှင့် ချိတ်ဆက်ခွင့်မပြုပါ"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP ခွင့်ပြုရန်"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"ပိတ်ရန်"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> နှင့် ချိတ်ဆက်မှုဖြုတ်မလား။"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP ကွန်ရက်သို့ ချိတ်ဆက်ထားသည်။ ဤကွန်ရက်များကို ပိတ်ပါက ချိတ်ဆက်မှု ပြတ်တောက်ပါမည်။"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"အဆင့်မြင့် ရွေးစရာများ"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ဆွဲချစာရင်း အဆင့်မြင့် ရွေးစရာများ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ချဲ့ထွင်ရန်"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"သင်၏ ကွန်ရက် ချိတ်ဆက်မှုများကို စီမံကွပ်ကဲရန် <xliff:g id="NEW_APP">%s</xliff:g>ကို သုံးရမလား?{"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"လတ်တလောတည်နေရာ တောင်းခံမှုများ"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"အလုပ်ပရိုဖိုင်အတွက် တည်နေရာ"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"အက်ပ်တည်နေရာ ခွင့်ပြုချက်များ"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"တည်နေရာကို ပိတ်ထားသည်"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{အက်ပ် {total} ခုအနက် # ခုက တည်နေရာကို သုံးခွင့်ရှိသည်}other{အက်ပ် {total} ခုအနက် # ခုက တည်နေရာကို သုံးခွင့်ရှိသည်}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"မျက်နှာပြင်လက်ကွက်ကို သုံးခြင်း"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"စက်၏ကီးဘုတ် ဖွင့်ထားစဉ်တွင် ၎င်းကို ဖန်သားပြင်ပေါ်တွင် ဆက်ထားပါ"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"စာလုံးပို မထပ်စေသည့် ခလုတ်များ"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"ကီးဘုတ်သည် <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms အတွင်း ကီးတစ်ခုတည်း အကြိမ်ကြိမ် အမြန်နှိပ်ခြင်းကို လျစ်လျူရှုသည်"</string>
     <string name="slow_keys" msgid="2891452895499690837">"အနှေး ခလုတ်များ"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms ဖွင့်ရန် ခလုတ်နှိပ်ခြင်းအတွက် ကြာချိန်ကို ပြင်နိုင်သည်"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ကပ်ခွာ ခလုတ်များ"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"ဖြတ်လမ်းလင့်ခ်များအတွက် ခလုတ်များကို တစ်ပြိုင်တည်းဖိထားမည့်အစား တစ်ကြိမ်လျှင် ခလုတ်တစ်ခု နှိပ်နိုင်သည်"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"လက်ကွက်ဖြတ်လမ်းများ"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"ဖြတ်လမ်းလင့်ခ်များစာရင်း ပြပါ"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"အလုပ်ပရိုဖိုင် လက်ကွက်နှင့် တူးလ်များ"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ပြန်သတ်မှတ်ရန်"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"မွမ်းမံပေးရေးကီးကို ရွေးပါ"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> အတွက် ကီးအသစ်ရွေးပါ-"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> အပြင်အဆင်"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"မူရင်း"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"အလိုအလျောက်- <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"အသုံးပြုသူ၏ ရွေးချယ်မှု- <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"စကားသံ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"မြားရွေ့နှုန်း"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"ဂိမ်းထိန်းချုပ်ခြင်း"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"သင့်လိုအပ်ချက်များနှင့် ကိုက်ညီမှုရှိစေရန် ဤစက်ပစ္စည်းကို စိတ်ကြိုက်ပြင်ဆင်နိုင်သည်။ အများသုံးနိုင်သည့် ဤဝန်ဆောင်မှုများကို ဆက်တင်များထဲ၌ နောက်ပိုင်းတွင် ပြောင်းလဲနိုင်သည်။"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"စာလုံးအရွယ်အစားပြောင်းပါ"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"ဖန်သားပြင်ဖတ် အက်ပ်"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ပကတိကီးဘုတ် ရွေးစရာ"</string>
     <string name="captions_category_title" msgid="574490148949400274">"စာတန်းများ"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"အသံ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"အထွေထွေ"</string>
     <string name="display_category_title" msgid="6638191682294461408">"ဖန်သားပြင် ပြသမှု"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"အရောင်နှင့် လှုပ်ရှားမှု"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"အရောင် အလင်းအမှောင်"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"ပိုလင်းပါက စာသား၊ ခလုတ်နှင့် သင်္ကေတများ ပိုပေါ်လွင်ပါသည်။ သင့်အတွက် အသင့်တော်ဆုံး အလင်းအမှောင်ကို ရွေးပါ။"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"အက်ပ်အချို့သည် အရောင်နှင့်စာသား အလင်းအမှောင် ဆက်တင်အားလုံးကို ပံ့ပိုးနိုင်မည်မဟုတ်ပါ"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"သင့်ဖန်သားပြင် နောက်ခံအရောင်ပေါ်မူတည်၍ အရောင်နှင့် စာသား မြင်ရပုံကို ချိန်ညှိနိုင်သည်"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"အစမ်းကြည့်ရှုခြင်း"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen၊ Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"လွန်ခဲ့သော ၂ ရက်"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"လိုက်ကြည့်မလား။"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"အလုပ်ကိစ္စခရီးစဉ် အစီရင်ခံစာ"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"နောက်ထပ်အကူအညီအတွက် ကျွန်ုပ် (သို့) Helen ထံ\nဆက်သွယ်ပေးပါ။ ဤအစီရင်ခံစာသည်"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"ကလိုင်းယင့် ကုန်ကျစရိတ်များ"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"ဖန်သားပြင်ကို ပိုမှောင်အောင်လုပ်ခြင်း"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"အပြန်အလှန်ဆက်သွယ်ချက် ထိန်းချုပ်မှုများ"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"အချိန်ကိုက်ခြင်း ထိန်းချုပ်မှုများ"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"မည်သို့ပင်ဖြစ်စေ ရှေ့ဆက်ရန်"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"မလုပ်တော့"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"ပုံကြီးချဲ့ခြင်း ဆက်တင်များ"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ဖြတ်လမ်းလင့်ခ်ဖြင့် ချဲ့ခြင်း"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ဖြတ်လမ်းလင့်ခ်ဖြင့် သုံးချက်တို့ပြီး ချဲ့ပါ"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> အကြောင်း"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"ဖောက်ထွင်းမမြင်နိုင်ပါ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"အရောင်ခြားနားချက်မြင့် စာသား"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"စာသားအရောင်ကို အမည်း (သို့) အဖြူ ပြောင်းနိုင်သည်။ အရောင်ခြားနားချက်ကို နောက်ခံဖြင့် အမြင့်ဆုံးပြုလုပ်နိုင်သည်။"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"စာသားကို အလင်းဆုံးထားရန်"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"နောက်ခံပေါ်မူတည်၍ အလင်းအမှောင်ကို တိုးမြှင့်ပြီး စာသားအရောင်ကို အမည်း (သို့) အဖြူ ပြောင်းနိုင်သည်။"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"မျက်နှာပြင်ချဲ့မှု အော်တိုအပ်ဒိတ်"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"အက်ပ် အပြောင်းတွင်မျက်နှာပြင်ချဲ့မှုအပ်ဒိတ်လုပ်ရန်"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"ဖွင့်ပိတ်ခလုတ်ဖြင့် ဖုန်းချရန်"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"အသံအတိုးအလျှော့ခလုတ်များကို ဖိထားခြင်း"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"ဖန်သားပြင်ကို သုံးချက် တို့ပါ"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"အများသုံးနိုင်မှု ဖြတ်လမ်းလင့်ခ်များ ပြင်ခြင်း"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s အတွက် သင့်ဖြတ်လမ်းလင့်ခ်ကို ရွေးပါ"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ရှေ့ဆက်ရန်"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"နားကြားကိရိယာ"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA နှင့် LE Audio နားကြားကိရိယာ၊ အတွင်းနားအစားထိုး ခွဲစိတ်စက်ထည့်ခြင်းနှင့် အခြားအသံချဲ့ကိရိယာများကို စနစ်ထည့်သွင်းပြီး စီမံပါ"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"နားကြားကိရိယာ ချိတ်ဆက်မထားပါ"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"နားကြားကိရိယာအား ထည့်သွင်းသည်"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"နားကြားကိရိယာတွဲချိတ်ခြင်း"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"နားကြားကိရိယာ တွဲဖက်သုံးနိုင်မှု"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"တယ်လီကွိုင်များနှင့် ပိုမိုကိုက်ညီစေပြီး မလိုလားသောဆူညံသံများ ဖယ်ရှားပေးသည်"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"နားကြားကိရိယာအကြောင်း"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA (သို့) LE Audio ဖြင့် ပံ့ပိုးမထားသော အခြားနားကြားကိရိယာများ ရှာရန်အတွက် "<b>"စက်အသစ်တွဲချိတ်ရန်"</b>" &gt; "<b>"နောက်ထပ်စက်များ ကြည့်ရန်"</b>" ကိုတို့ပါ"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"နားကြားကိရိယာ တွဲချိတ်ရန်"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ဤစာမျက်နှာတွင် ASHA နှင့် LE Audio နားကြားကိရိယာများကို တွဲချိတ်နိုင်သည်။ သင်၏နားကြားကိရိယာဖွင့်ထားပြီး တွဲချိတ်ရန်အသင့်ဖြစ်နေပါစေ။"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ရနိုင်သော နားကြားကိရိယာ"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"စာတိုများ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"အလိုအလျောက် ဒေတာပြောင်းခြင်း"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"လိုင်းဆွဲအားနှင့် ရနိုင်မှုပေါ်မူတည်၍ ဆင်းမ်ကတ်တစ်ခုခုမှ ဒေတာကို သုံးပါ"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ဒေတာသီးသန့်"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"စနစ်ထည့်သွင်းရန်"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"ရှေ့သို့"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB ပါသည့် အနီးတစ်ဝိုက်ရှိ စက်ပစ္စည်းများ၏ မှန်းခြေနေရာကို ကူညီဖော်ထုတ်ပေးသည်"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB ကို သုံးရန် လေယာဉ်ပျံမုဒ်ကို ပိတ်သည်"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB ကို လက်ရှိတည်နေရာတွင် မရနိုင်ပါ"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"အဆင့်မြင့်အိမ် အသုံးပြုမှု ချောမွေ့စေရန်အတွက် Thread သုံး၍ တွဲသုံးနိုင်သည့်စက်များသို့ ချိတ်ဆက်ပါ"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread သုံးရန် လေယာဉ်ပျံမုဒ်ကို ပိတ်ပါ"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"ကင်မရာသုံးခွင့်"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"မိုက်ခရိုဖုန်းသုံးခွင့်"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"အက်ပ်နှင့် ဝန်ဆောင်မှုများအတွက်"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"မလုပ်တော့"</string>
     <string name="contrast_title" msgid="6885768151336508075">"ဆန့်ကျင်ဘက်"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"ပုံမှန်"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"မူရင်း"</string>
     <string name="contrast_medium" msgid="384414510709285811">"အသင့်အတင့်"</string>
     <string name="contrast_high" msgid="3988567609694797696">"များ"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"ဤအက်ပ်ကို ဝင်းဒိုး ၁ ခုတွင်သာ ဖွင့်နိုင်သည်"</string>
diff --git a/res/values-nb/arrays.xml b/res/values-nb/arrays.xml
index 8ad9385..7a4ae0a 100644
--- a/res/values-nb/arrays.xml
+++ b/res/values-nb/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Behandle som med datamåling"</item>
     <item msgid="2047166446768045816">"Behandle som uten datamåling"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Bruk tilfeldig MAC-adresse (standard)"</item>
-    <item msgid="741680937828608749">"Bruk enhetens MAC-adresse"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nei"</item>
     <item msgid="2163015208097377388">"Ja"</item>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index 6e5ac97..81e50c3 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Tilkoble høyre øre"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Tilkoble venstre øre"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"For alle tilgjengelige høreenheter"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Flere innstillinger for høreapparater"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Endre innstillingene for alle høreapparatene, for eksempel snarveier og kontroller for telespole"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"For denne enheten"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Utenhet for lyd"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Om lyd"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Konfigurerer det private området …"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Varsler fra apper i det private området er skjult når det er låst"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Utforsk innstillingene for det private området for å skjule området og konfigurere automatisk låsing"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Obligatoriske apper er installert i det private området allerede"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Kunne ikke konfigurere et privat område"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Prøv på nytt"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Vil du låse opp det private området med skjermlås?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apper og varsler"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Sensitive varsler på låseskjermen"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Vis sensitivt innhold når det private området er låst opp"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Opprett en Google-konto for å bidra til å holde dataene dine private"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"På neste skjerm kan du logge på en konto du vil bruke med det private området"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Opprett en separat konto for å bidra til å hindre at data vises utenfor det private området, for eksempel:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Synkroniserte bilder, filer, e-poster, kontakter, kalenderaktiviteter og andre data"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Anbefalinger og nedlastingslogg for apper"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Nettleserlogg, bokmerker og lagrede passord"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Foreslått innhold relatert til aktiviteten din i apper i det private området"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Greit"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Du kan legge til opptil <xliff:g id="COUNT">%d</xliff:g> fingeravtrykk"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Du har lagt til maksimalt antall fingeravtrykk"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Kan ikke legge til flere fingeravtrykk"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operatøren din tillater ikke at du kobler til dette nettverket, fordi det bruker en eldre sikkerhetsprotokoll som er mindre sikker"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Tillat WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Lukk"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Vil du koble fra <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Du er koblet til et WEP-nettverk. Hvis du blokkerer disse nettverkene, blir du koblet fra."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Avanserte alternativer"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rullegardinliste med avanserte alternativer"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"vis"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Vil du bruke <xliff:g id="NEW_APP">%s</xliff:g> til å administrere nettverkstilkoblingene?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nylige posisjonsforespørsler"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Sted for jobbprofil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Apper med posisjonstillatelse"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Posisjon er slått av"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# av {total} apper har tilgang til posisjon}other{# av {total} apper har tilgang til posisjon}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Bruk skjermtastaturet"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Ha det på skjermen når det fysiske tastaturet er aktivt"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Filtertaster"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tastaturet ignorerer raskt gjentatte trykk på samme tast innenfor <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Trege taster"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Justerer aktiveringstiden for tastetrykk til <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Trege taster"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Aktiver hurtigtaster ved å trykke på én tast av gangen i stedet for å holde flere taster inne samtidig"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Hurtigtaster"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Vis listen over hurtigtaster"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatur og verktøy i jobbprofilen"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Tilbakestill"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Velg modifikatortast"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Velg en ny tast for <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Standard"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Tale"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Pekerhastighet"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Spillkontroller"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Du kan tilpasse denne enheten etter egne behov. Tilgjengelighetsfunksjonene kan du endre senere i Innstillinger."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Endre skrift­­størrelse"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Skjermleser"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Alternativer for fysiske tastaturer"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Teksting"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Lyd"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Generelt"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Skjerm"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Farge og bevegelse"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Fargekontrast"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Høyere kontrast gjør at tekst, knapper og ikoner blir enklere å se. Velg kontrasten som ser best ut for deg."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Noen apper støtter kanskje ikke alle innstillinger for farge og tekstkontrast"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Juster hvordan farger og tekst ser ut mot bakgrunnsfargen på skjermen."</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Forhåndsvisning"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helene, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 dager siden"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Følg opp?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Rapport fra forretningsreise"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"For å få mer hjelp kan du ta kontakt med \nmeg eller Helene. Denne rapporten blir"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Klientutgifter"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Gjør skjermen mørkere"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaksjonskontroller"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Tidskontroller"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Fortsett likevel"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Avbryt"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Innstillinger for forstørring"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Forstørr med snarvei"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Forstørr med snarvei og trippeltrykk"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Om <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ikke-gjennomsiktig"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst med høy kontrast"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Endre tekstfarge til svart eller hvit. Dette maksimerer kontrasten mot bakgrunnen."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimer tekstkontrasten"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Endre tekstfargen til svart eller hvit for å øke kontrasten mot bakgrunnen."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automatisk oppdatering av skjermforstørrelsen"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Oppdater skjermforstørrelsen ved appbytter"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Legg på med av/på-knappen"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold inne volumtastene"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trippeltrykk på skjermen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Endre tilgjengelighetssnarveier"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Velg hurtigtast for %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Fortsett"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Høreapparater"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Konfigurer og administrer høreapparater, cochlea-implantater og andre forsterkningsenheter som bruker ASHA eller LE-lyd"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ingen høreapparater er tilkoblet"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Legg til høreapparater"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Koble til høreapparater"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilitet med høreapparater"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Forbedrer kompatibiliteten med telespoler og reduserer uønsket støy"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Om høreapparater"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"For å finne andre høreapparater som ikke har støtte for ASHA eller LE-lyd, trykk på "<b>"Koble til en ny enhet"</b>" &gt; "<b>"Se flere enheter"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Koble til høreapparat"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Du kan koble sammen ASHA- og LE-lyd-høreapparater på denne siden. Forsikre deg om at høreapparatet ditt er slått på og klart til sammenkobling."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Tilgjengelige høreapparater"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Tekstmeldinger"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatisk databytte"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Bruk data fra hvilket som helst SIM-kort, avhengig av dekning og tilgjengelighet"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Bare data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Konfigurer"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Neste"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Bidrar til å finne den relative posisjonen til enheter i nærheten som har UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Slå av flymodus for å bruke UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB er tilgjengelig på dette stedet"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Koble til kompatible enheter med Thread for å få en sømløs smarthjemopplevelse"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Slå av flymodus for å bruke Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kameratilgang"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofontilgang"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"For apper og tjenester"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Avbryt"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Standard"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Middels"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Høy"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Denne appen kan bare åpnes i ett vindu"</string>
diff --git a/res/values-ne/arrays.xml b/res/values-ne/arrays.xml
index ce124da..0ac6e52 100644
--- a/res/values-ne/arrays.xml
+++ b/res/values-ne/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"सशुल्क Wi-Fi का रूपमा लिइयोस्"</item>
     <item msgid="2047166446768045816">"नि:शुल्क Wi-Fi का रूपमा लिइयोस्"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"क्रमरहित MAC प्रयोग गरियोस् (डिफल्ट)"</item>
-    <item msgid="741680937828608749">"डिभाइसको MAC प्रयोग गरियोस्"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"छैन"</item>
     <item msgid="2163015208097377388">"हो"</item>
diff --git a/res/values-ne/strings.xml b/res/values-ne/strings.xml
index 88f09d5..eca106a 100644
--- a/res/values-ne/strings.xml
+++ b/res/values-ne/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"दायाँ भाग कनेक्ट गर्नुहोस्"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"बायाँ भाग कनेक्ट गर्नुहोस्"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"उपलब्ध सबै श्रवण यन्त्रसम्बन्धी कन्ट्रोलहरू"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"श्रवण यन्त्रसम्बन्धी थप सेटिङ"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"सर्टकट र टेलिकोइल कन्ट्रोलहरूलगायतका क्रस-डिभाइस सेटिङ बदल्नुहोस्"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"यो डिभाइससम्बन्धी कन्ट्रोलहरू"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"अडियो आउटपुट"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"अडियो आउटपुटका बारेमा"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"निजी स्पेस सेटअप गरिँदै छ…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"निजी स्पेस लक गरिएका बेला निजी स्पेसका एपबाट प्राप्त सूचनाहरू लुकाइन्छन्"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"निजी स्पेस लुकाउन र स्वतः लक गर्ने सुविधा सेटअप गर्न निजी स्पेससम्बन्धी सेटिङका बारेमा जानकारी प्राप्त गर्नुहोस्"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"आवश्यक एपहरू तपाईंको निजी स्पेसमा इन्स्टल गरिसकिएका छन्"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"निजी स्पेस सेटअप गर्न सकिएन"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"फेरि प्रयास गर्नुहोस्"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"निजी स्पेस अनलक गर्न स्क्रिन लक प्रयोग गर्ने हो?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"एप तथा सूचनाहरू"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"लक स्क्रिनमा संवेदनशील सूचनाहरू"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"निजी स्पेस अनलक गरिएका बेला संवेदनशील सामग्री देखाइयोस्"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"आफ्नो डेटा गोप्य राख्न Google खाता बनाउनुहोस्"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"तपाईं अर्को स्क्रिनमा आफूले निजी स्पेसमा प्रयोग गर्न चाहेको खातामा साइन इन गर्न सक्नुहुन्छ"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"निजी स्पेसबाहिर डेटा देखिन नदिन एउटा छुट्टै खाता बनाउनुहोस्, जस्तै:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"सिंक गरिएका फोटो, फाइल, इमेल, कन्ट्याक्ट, पात्रोमा सेट गरिएका कार्यक्रम र अन्य डेटा"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"विगतमा डाउनलोड गरिएका एप र सिफारिसहरू"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ब्राउजिङ हिस्ट्री, बुकमार्क र सेभ गरिएका पासवर्डहरू"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"तपाईंले निजी स्पेसमा भएका एपमा गरेको क्रियाकलापसम्बन्धी सिफारिस गरिएको सामग्री"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"बुझेँ"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"तपाईं बढीमा <xliff:g id="COUNT">%d</xliff:g> वटा फिंगरप्रिन्टहरू हाल्न सक्नुहुन्छ"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"तपाईंले अधिकतम संख्यामा फिंगरप्रिन्टहरू थप्नुभएको छ"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"थप फिंगरप्रिन्टहरू थप्न सकिँदैन"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"यो नेटवर्कले अझ कम सुरक्षित पुरानो सुरक्षा प्रोटोकल प्रयोग गर्ने भएकाले तपाईंको सेवा प्रदायकले तपाईंले यो नेटवर्क कनेक्ट गर्न नमिल्ने बनाएको छ"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP कनेक्ट गर्ने अनुमति दिनुहोस्"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"बन्द गर्नुहोस्"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> बाट अनलिंक गर्ने हो?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"तपाईंले WEP नेटवर्कमा कनेक्ट गर्नुभएको छ। तपाईंले यी नेटवर्कहरू ब्लक गर्नुभयो भने तपाईंलाई डिस्कनेक्ट गरिने छ।"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"उन्नत विकल्पहरू"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ड्रप-डाउन सूचीका उन्नत विकल्पहरू"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"विस्तृत गर्नुहोस्"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"तपाईँको सञ्जाल जडानहरू व्यवस्थापन गर्न <xliff:g id="NEW_APP">%s</xliff:g> प्रयोग गर्ने?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"हालका स्थान अनुरोधहरू"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"काम प्रोफाइलका लागि स्थान"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"एपलाई दिइएको लोकेसन प्रयोग गर्ने अनुमति"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"लोकेसन अफ छ"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} मध्ये # एपलाई लोकेसन प्रयोग गर्ने अनुमति दिइएको छ}other{{total} मध्ये # वटा एपलाई लोकेसन प्रयोग गर्ने अनुमति दिइएको छ}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"अनस्क्रिन किबोर्ड प्रयोग गरियोस्"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"फिजिकल किबोर्ड सक्रिय हुँदा यसलाई स्क्रिनमा राखियोस्"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"बाउन्स की"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"किबोर्डले <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> मिलिसेकेन्डभित्र एउटै कीमा छिटो छिटो दोहोर्‍याएर थिचिएका खण्डमा बेवास्ता गर्छ"</string>
     <string name="slow_keys" msgid="2891452895499690837">"स्लो की"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> मिलिसेकेन्डमा एक्टिभेट गर्नका लागि कुनै की थिच्न लाग्ने समय समायोजन गर्छ"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"स्टिकी की"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"सर्टकट प्राप्त गर्नका लागि कीहरू सँगै थिचिराख्नुको साटो एक पटकमा एउटा की थिच्नुहोस्"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"किबोर्डका सर्टकटहरू"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"सर्टकटहरूको सूची देखाइयोस्"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"कार्य प्रोफाइल किबोर्ड र उपकरणहरू"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"रिसेट गर्नुहोस्"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"मोडिफायर की छान्नुहोस्"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> को नयाँ की छनौट गर्नुहोस्:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"डिफल्ट"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"बोली"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"पोइन्टरको गति"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"खेल नियन्त्रक"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"तपाईं यो डिभाइस आफ्नो आवश्यकताअनुसार कस्टमाइज गर्न सक्नुहुन्छ । यी पहुँच सुविधाहरू पछि सेटिङमा गई परिवर्तन गर्न सकिने छ।"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"फन्टको आकार बदल्नुहोस्"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"स्क्रिन रिडर"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"भौतिक किबोर्डका विकल्पहरू"</string>
     <string name="captions_category_title" msgid="574490148949400274">"क्याप्सनहरू"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"अडियो"</string>
     <string name="general_category_title" msgid="6298579528716834157">"सामान्य"</string>
     <string name="display_category_title" msgid="6638191682294461408">"डिस्प्ले"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"रङ र मोसन"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"रङको कन्ट्रास्ट"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"तपाईंले उच्च कन्ट्रास्ट छनौट गर्नुभयो भने टेक्स्ट, बटन र आइकनहरू अझ आकर्षक देखिन्छन्। तपाईंका लागि सबैभन्दा उपयुक्त हुने कन्ट्रास्ट छनौट गर्नुहोस्।"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"केही एपमा रङ र टेक्स्टको कन्ट्रास्टसम्बन्धी सबै सेटिङले काम नगर्न सक्छ"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"तपाईंको स्क्रिनको ब्याकग्राउन्डको रङमा अन्य रङ र टेक्स्टहरू कस्ता देखिन्छन् भन्ने कुरा मिलाउनुहोस्"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"प्रिभ्यू गर्नुहोस्"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"२ दिनअघि"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"फलो अप गर्ने हो?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"व्यावसायिक यात्रासम्बन्धी रिपोर्ट"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"थप सहायता चाहिएमा कृपया \nमलाई वा Helen लाई सम्पर्क गर्नुहोस्। यो रिपोर्ट"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"क्लाइन्टसँग सम्बन्धित खर्चहरू"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"स्क्रिन अझ अँध्यारो बनाउनुहोस्"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"अन्तर्क्रियासम्बन्धी सेटिङ"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"समयसम्बन्धी कन्ट्रोल"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"जे भए पनि जारी राख्नुहोस्"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"रद्द गर्नु…"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"म्याग्निफिकेसनसम्बन्धी सेटिङ"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"सर्टकट प्रयोग गरी म्याग्निफाइ गर्नुहोस्"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"सर्टकट र तीन पटक ट्याप गरेर म्याग्निफाइ गर्नुहोस्"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>का बारेमा"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"अपारदर्शी"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"हाइ कन्ट्रास्ट टेक्स्ट"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"पाठको रङ बदलेर कालो वा सेतो बनाउनुहोस्। यसले ब्याकग्राउन्डमा कन्ट्रास्टको लेभल अधिकतम बनाउँछ।"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"टेक्स्टको कन्ट्रास्ट सकेसम्म बढाउनुहोस्"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"ब्याकग्राउन्डसँग कन्ट्रास्ट बढाउन टेक्स्टको रङ परिवर्तन गरी कालो वा सेतो बनाउनुहोस्।"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"स्क्रिन आवर्धन स्वतः अपडेट गर्नुहोस्"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"एप ट्रान्जिसनहरूमा स्क्रिन आवर्धन अपडेट गर्नुहोस्"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"पावर बटन थोच्दा फोन काटियोस्"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"भोल्युम कीहरू थिचिरहनुहोस्"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"स्क्रिनमा तीनचोटि ट्याप गर्नुहोस्"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"एक्सेसिबिलिटीसम्बन्धी सर्टकटहरू सम्पादन गर्नुहोस्"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s का लागि आफ्नो सर्टकट रोज्नुहोस्"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"जारी राख्नुहोस्"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"श्रवण यन्त्रहरू"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA र LE अडियो श्रवण यन्त्र, कक्लियर इम्प्लान्ट तथा अन्य एम्प्लिफिकेसन डिभाइसहरू सेटअप र व्यवस्थापन गर्नुहोस्"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"कुनै पनि श्रवण यन्त्र कनेक्ट गरिएको छैन"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"श्रवण यन्त्रहरू थप्नुहोस्"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"श्रवण यन्त्र कनेक्ट गर्नुहोस्"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"श्रवण सहयोगसम्बन्धी कम्प्याटिबिलिटी"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"टेलिकोइलसँग अझ राम्रोसँग काम गर्ने बनाउँछ र अनावश्यक आवाज कम गर्छ"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"श्रवण यन्त्रहरूका बारेमा"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA वा LE अडियो प्रयोग गर्न नमिल्ने अन्य श्रवण यन्त्र भेट्टाउन "<b>"नयाँ डिभाइस कनेक्ट गर्नुहोस्"</b>" &gt; "<b>"अझ धेरै डिभाइसहरू हेर्नुहोस्"</b>" मा ट्याप गर्नुहोस्"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"श्रवण यन्त्र कनेक्ट गर्नुहोस्"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"तपाईं यो पेजमा ASHA र LE अडियो श्रवण यन्त्र कनेक्ट गर्न सक्नुहुन्छ। तपाईंको श्रवण यन्त्र अन गरिएको छ र त्यसमा कनेक्ट गर्न मिल्छ भन्ने कुरा सुनिश्चित गर्नुहोस्।"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"उपलब्ध श्रवण यन्त्रहरू"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"टेक्स्टहरू"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"मोबाइल डेटा स्वतः स्विच हुने सुविधा"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"कभरेज तथा उपलब्धताका आधारमा कुनै एउटा SIM मार्फत मोबाइल डेटा प्रयोग गर्नुहोस्"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"मोबाइल डेटा मात्र"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"सेटअप गर्नुहोस्"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"अर्को"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"यसले UWB चल्ने नजिकैका डिभाइसहरूको सापेक्ष स्थिति पहिचान गर्न मद्दत गर्छ"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB प्रयोग गर्न हवाइजहाज मोड अफ गर्नुहोस्"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"हालको लोकेसनमा UWB उपलब्ध छैन"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"थ्रेड"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"निर्बाध रूपमा स्मार्ट होमको सुविधा प्राप्त गर्न थ्रेड प्रयोग गरी कम्प्याटिबल डिभाइसहरूमा कनेक्ट गर्नुहोस्"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"थ्रेड प्रयोग गर्न हवाइजहाज मोड अफ गर्नुहोस्"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"क्यामेरा प्रयोग गर्ने अनुमति"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"माइक्रोफोन प्रयोग गर्ने अनुमति"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"एप र सेवाहरूका लागि"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"रद्द गर्नुहोस्"</string>
     <string name="contrast_title" msgid="6885768151336508075">"कन्ट्रास्ट"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"डिफल्ट"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"डिफल्ट"</string>
     <string name="contrast_medium" msgid="384414510709285811">"मध्यम"</string>
     <string name="contrast_high" msgid="3988567609694797696">"उच्च"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"यो एप एउटा विन्डोमा मात्र खोल्न मिल्छ"</string>
diff --git a/res/values-night/colors.xml b/res/values-night/colors.xml
index a572841..a27fbaa 100644
--- a/res/values-night/colors.xml
+++ b/res/values-night/colors.xml
@@ -19,7 +19,7 @@
     <color name="homepage_accessibility_background">#783BE5</color>
     <color name="homepage_support_background">#3F5FBD</color>
     <color name="contextual_card_background">@*android:color/material_grey_900</color>
-    <color name="search_bar_background">?androidprv:attr/materialColorSurfaceContainerHigh</color>
+    <color name="search_bar_background">?androidprv:attr/materialColorSurfaceBright</color>
     <color name="notification_importance_button_unselected">#5F6368</color>
 
     <!-- Palette list preference colors. -->
diff --git a/res/values-nl/arrays.xml b/res/values-nl/arrays.xml
index dbf12b1..f2171e2 100644
--- a/res/values-nl/arrays.xml
+++ b/res/values-nl/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Behandelen als wifi met datalimiet"</item>
     <item msgid="2047166446768045816">"Behandelen als wifi zonder datalimiet"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Gebruik een willekeurig MAC-adres (standaard)"</item>
-    <item msgid="741680937828608749">"Gebruik MAC-adres van apparaat"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nee"</item>
     <item msgid="2163015208097377388">"Ja"</item>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 0ac4f9d..3d496cd 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Rechteroor koppelen"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Linkeroor koppelen"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Voor alle beschikbare hoortoestellen"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Meer instellingen voor hoortoestellen"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Wijzig cross-device instellingen, zoals het beheer van snelkoppelingen en telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Voor dit apparaat"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio-uitvoer"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Over audio-uitvoer"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Privéruimte instellen…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Meldingen van apps in het privégedeelte worden verborgen als dit is vergrendeld"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Instellingen om het privégedeelte te verbergen en automatisch te laten vergrendelen"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Vereiste apps zijn al geïnstalleerd in je privégedeelte"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Kan privégedeelte niet instellen"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Opnieuw proberen"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Schermvergrendeling gebruiken voor ontgrendeling van privéruimte?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apps en meldingen"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Gevoelige meldingen op vergrendelscherm"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Toon gevoelige content als het privégedeelte is ontgrendeld"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Een Google-account maken om je gegevens privé te houden"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Op het volgende scherm kun je inloggen bij het account dat je wilt gebruiken voor je privégedeelte"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Maak een apart account zodat gegevens niet buiten je privégedeelte worden getoond, zoals:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Gesynchroniseerde foto\'s, bestanden, e-mails, contacten, agenda-afspraken en andere gegevens"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Downloadgeschiedenis en aanbevelingen voor apps"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Browsegeschiedenis, bookmarks en opgeslagen wachtwoorden"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Aanbevolen content met betrekking tot je activiteit in apps in je privégedeelte"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Je kunt maximaal <xliff:g id="COUNT">%d</xliff:g> vingerafdrukken toevoegen"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Je hebt het maximale aantal vingerafdrukken toegevoegd"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Kan geen extra vingerafdrukken toevoegen"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Je provider staat je niet toe om verbinding te maken met dit netwerk omdat het een ouder beveiligingsprotocol gebruikt dat minder goed beveiligd is"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP toestaan"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Sluiten"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Verbinding met <xliff:g id="NAME">%1$s</xliff:g> verbreken?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Je bent verbonden met een WEP-netwerk. Als je deze netwerken blokkeert, wordt de verbinding verbroken."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Geavanceerde opties"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Dropdownmenu \'Geavanceerde opties\'"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"uitvouwen"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"<xliff:g id="NEW_APP">%s</xliff:g> gebruiken om je netwerkverbindingen te beheren?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Recente locatieverzoeken"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Locatie voor werkprofiel"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Locatierechten voor apps"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Locatie staat uit"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# van {total} apps heeft toegang tot de locatie}other{# van {total} apps hebben toegang tot de locatie}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Schermtoetsenbord gebruiken"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Toon op het scherm terwijl het fysieke toetsenbord actief is"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Bouncetoetsen"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Het toetsenbord negeert het binnen <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms snel herhaald indrukken van dezelfde toets"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Langzame toetsen"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Past de tijd voordat een toetsaanslag wordt geactiveerd aan naar <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Plaktoetsen"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Druk toetsen één voor één in voor sneltoetsen in plaats van meerdere toetsen tegelijkertijd"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Sneltoetsen"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Toon lijst met sneltoetsen"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Toetsenborden en tools van werkprofiel"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Resetten"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Functietoets kiezen"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Kies een nieuwe toets voor <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Indeling: <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Standaard"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatisch: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Door de gebruiker geselecteerd: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Spraak"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Snelheid van aanwijzer"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Gamecontroller"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Pas dit apparaat aan je behoeften aan. Je kunt de toegankelijkheidsfuncties later altijd veranderen in de Instellingen."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Lettergrootte wijzigen"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Schermlezer"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opties voor fysiek toetsenbord"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Ondertiteling"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Algemeen"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Scherm"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Kleur en beweging"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kleurcontrast"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Bij een hoger contrast vallen tekst, knoppen en iconen meer op. Kies het contrast dat je prettig vindt."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Sommige apps ondersteunen misschien niet alle instellingen voor kleur- en tekstcontrast"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Pas aan hoe kleuren en tekst eruitzien tegen de achtergrondkleur van je scherm"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Voorbeeld"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 dagen geleden"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Opvolgen?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Verslag van zakenreis"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Neem voor meer hulp contact op met \nmij of Helen. Dit rapport wordt"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Klantuitgaven"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Scherm donkerder maken"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interactieopties"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Bedienings­elementen voor timing"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Toch doorgaan"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Annuleren"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Instellingen voor vergroting"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Vergroten met sneltoets"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Vergroten met sneltoets en drie keer tikken"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Over <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Niet-transparant"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst met hoog contrast"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Wijzig de tekstkleur in zwart of wit. Zo maximaliseer je het contrast met de achtergrond."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Tekstcontrast maximaliseren"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Wijzig de tekstkleur in zwart of wit om het contrast met de achtergrond te verhogen."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Schermvergroting automatisch updaten"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Schermvergroting updaten bij app-overgangen"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Aan/uit-knop beëindigt gesprek"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Houd de volumetoetsen ingedrukt"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tik 3 keer op het scherm"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Snelkoppelingen voor toegankelijkheid bewerken"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Kies je sneltoets voor %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Doorgaan"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hoortoestellen"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Hoortoestellen, cochleaire implantaten en andere versterkingsapparaten met ASHA en LE Audio instellen en beheren"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Geen verbonden hoortoestellen"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Hoortoestellen toevoegen"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Hoortoestellen koppelen"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Geschiktheid voor hoortoestellen"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Verbetert de compatibiliteit met luisterspoelen en beperkt ongewenst geluid"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Over hoortoestellen"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Als je andere hoortoestellen wilt vinden die niet worden ondersteund door ASHA of LE Audio, tik je op "<b>"Nieuw apparaat koppelen"</b>" &gt; "<b>"Meer apparaten bekijken"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Hoortoestel koppelen"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Op deze pagina kun je ASHA- en LE Audio-hoortoestellen koppelen. Zorg dat je hoortoestel aanstaat en klaar is voor koppelen."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Beschikbare hoortoestellen"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Tekstberichten"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatische dataschakeling"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Gebruik data van beide sims, afhankelijk van dekking en beschikbaarheid"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Alleen data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Instellen"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Volgende"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Helpt bij het identificeren van de relatieve positie van apparaten in de buurt die UWB hebben"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Zet de vliegtuigmodus uit om UWB te gebruiken"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is niet beschikbaar op je huidige locatie"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Maak verbinding met geschikte apparaten via Thread voor een naadloze smarthome-functionaliteit"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Zet de vliegtuigmodus uit om Thread te gebruiken"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Cameratoegang"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Microfoontoegang"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Voor apps en services"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Annuleren"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standaard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Standaard"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Gemiddeld"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Hoog"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Deze app kan maar in 1 venster worden geopend"</string>
diff --git a/res/values-or/arrays.xml b/res/values-or/arrays.xml
index a893d93..3ee9806 100644
--- a/res/values-or/arrays.xml
+++ b/res/values-or/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"ମିଟର୍ ହୋଇଥିବା ରୂପେ ବିବେଚନା କରନ୍ତୁ"</item>
     <item msgid="2047166446768045816">"ମିଟର୍ ହୋଇନଥିବା ରୂପେ ବିବେଚନା କରନ୍ତୁ"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ରେଣ୍ଡମାଇଜ୍ଡ MAC ବ୍ୟବହାର କରନ୍ତୁ (ଡିଫଲ୍ଟ)"</item>
-    <item msgid="741680937828608749">"MAC ଡିଭାଇସ ବ୍ୟବହାର କରନ୍ତୁ"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"ନା"</item>
     <item msgid="2163015208097377388">"ହଁ"</item>
diff --git a/res/values-or/strings.xml b/res/values-or/strings.xml
index d3c3dd6..793e62f 100644
--- a/res/values-or/strings.xml
+++ b/res/values-or/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"ଡାହାଣ କାନକୁ ପେୟାର କର"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"ବାମ କାନକୁ ପେୟାର କର"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"ସମସ୍ତ ଉପଲବ୍ଧ ହିଅରିଂ ଡିଭାଇସ ପାଇଁ"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"ଶୁଣିବା ଡିଭାଇସର ଅଧିକ ସେଟିଂସ"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"ସର୍ଟକଟ ଏବଂ ଟେଲିକଏଲ ନିୟନ୍ତ୍ରଣଗୁଡ଼ିକ ପରି କ୍ରସ-ଡିଭାଇସ ସେଟିଂସକୁ ପରିବର୍ତ୍ତନ କରନ୍ତୁ"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"ଏହି ଡିଭାଇସ ପାଇଁ"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ଅଡିଓ ଆଉଟପୁଟ"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ଅଡିଓ ଆଉଟପୁଟ ବିଷୟରେ"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"ପ୍ରାଇଭେଟ ସ୍ପେସ ସେଟ ଅପ କରାଯାଉଛି…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ପ୍ରାଇଭେଟ ସ୍ପେସ ଲକ ଥିବା ସମୟରେ ଏହାର ଆପ୍ସରୁ ବିଜ୍ଞପ୍ତିଗୁଡ଼ିକୁ ଲୁଚାଯାଇଥାଏ"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"ପ୍ରାଇଭେଟ ସ୍ପେସକୁ ଲୁଚାଇବା ଏବଂ ସ୍ୱତଃ ଲକିଂ ସେଟ ଅପ କରିବା ପାଇଁ ପ୍ରାଇଭେଟ ସ୍ପେସ ସେଟିଂସକୁ ଏକ୍ସପ୍ଲୋର କରନ୍ତୁ"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"ପୂର୍ବରୁ ଆବଶ୍ୟକ ଆପ୍ସ ଆପଣଙ୍କ ପ୍ରାଇଭେଟ ସ୍ପେସରେ ଇନଷ୍ଟଲ କରାଯାଇଛି"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"ଏକ ପ୍ରାଇଭେଟ ସ୍ପେସ ସେଟ ଅପ କରାଯାଇପାରିଲା ନାହିଁ"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ପୁଣି ଚେଷ୍ଟା କରନ୍ତୁ"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"ପ୍ରାଇଭେଟ ସ୍ପେସ ଅନଲକ ପାଇଁ ସ୍କ୍ରିନ ଲକ ବ୍ୟବହାର କରିବେ?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"ଆପ୍ସ ଏବଂ ବିଜ୍ଞପ୍ତିଗୁଡ଼ିକ"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"ଲକ ସ୍କ୍ରିନରେ ସମ୍ବେଦନଶୀଳ ବିଜ୍ଞପ୍ତିଗୁଡ଼ିକ"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"ପ୍ରାଇଭେଟ ସ୍ପେସକୁ ଅନଲକ କରାଯାଇଥିବା ସମୟରେ ସମ୍ବେଦନଶୀଳ ବିଷୟବସ୍ତୁ ଦେଖନ୍ତୁ"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"ଆପଣଙ୍କ ଡାଟାକୁ ପ୍ରାଇଭେଟ ରଖିବାରେ ସାହାଯ୍ୟ କରିବାକୁ ଏକ Google ଆକାଉଣ୍ଟ ତିଆରି କରନ୍ତୁ"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"ପରବର୍ତ୍ତୀ ସ୍କ୍ରିନରେ ଆପଣଙ୍କ ପ୍ରାଇଭେଟ ସ୍ପେସ ସହ ବ୍ୟବହାର କରିବାକୁ ଆପଣ ଏକ ଆକାଉଣ୍ଟରେ ସାଇନ ଇନ କରିପାରିବେ"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"ପ୍ରାଇଭେଟ ସ୍ପେସ ବାହାରେ ଦେଖାଯିବାରୁ ଡାଟାକୁ ପ୍ରତିରୋଧ କରିବାରେ ସାହାଯ୍ୟ କରିବା ପାଇଁ ଏକ ଉତ୍ସର୍ଗୀକୃତ ଆକାଉଣ୍ଟ ତିଆରି କରନ୍ତୁ, ଯେପରି:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"ସିଙ୍କ ହୋଇଥିବା ଫଟୋ, ଫାଇଲ, ଇମେଲ, କଣ୍ଟାକ୍ଟ, କେଲେଣ୍ଡର ଇଭେଣ୍ଟ ଏବଂ ଅନ୍ୟ ଡାଟା"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"ଆପ ଡାଉନଲୋଡ ଇତିହାସ ଏବଂ ସୁପାରିଶଗୁଡ଼ିକ"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ବ୍ରାଉଜିଂ ଇତିହାସ, ବୁକମାର୍କ ଏବଂ ସେଭ ହୋଇଥିବା ପାସୱାର୍ଡଗୁଡ଼ିକ"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"ପ୍ରାଇଭେଟ ସ୍ପେସ ଆପ୍ସରେ ଆପଣଙ୍କ କାର୍ଯ୍ୟକଳାପ ସମ୍ବନ୍ଧିତ ପ୍ରସ୍ତାବିତ ବିଷୟବସ୍ତୁ"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"ବୁଝିଗଲି"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"ଆପଣ ସର୍ବାଧିକ <xliff:g id="COUNT">%d</xliff:g> ଟିପଚିହ୍ନ ଯୋଗ କରିପାରିବେ"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"ଆପଣ ସର୍ବାଧିକ ସଂଖ୍ୟାର ଆଙ୍ଗୁଠି ଚିହ୍ନ ଯୋଡିଛନ୍ତି"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"ଆଉ ଅଧିକ ଟିପଚିହ୍ନ ଯୋଡିପାରିବ ନାହିଁ"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"ଏହି ନେଟୱାର୍କ କମ ସୁରକ୍ଷିତ ଥିବା ଏକ ପୁରୁଣା ସୁରକ୍ଷା ପ୍ରୋଟୋକଲ ବ୍ୟବହାର କରୁଥିବା ଯୋଗୁଁ ଆପଣଙ୍କ କେରିଅର ଆପଣଙ୍କୁ ଏହା ସହ କନେକ୍ଟ କରିବାକୁ ଅନୁମତି ଦିଏ ନାହିଁ"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEPକୁ ଅନୁମତି ଦିଅନ୍ତୁ"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"ବନ୍ଦ କରନ୍ତୁ"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g>ରୁ ବିଚ୍ଛିନ୍ନ କରିବେ କି?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"ଆପଣ ଏକ WEP ନେଟୱାର୍କ ସହ କନେକ୍ଟ ଅଛନ୍ତି। ଯଦି ଆପଣ ଏହି ନେଟୱାର୍କଗୁଡ଼ିକୁ ବ୍ଲକ କରନ୍ତି, ତେବେ ଆପଣ ଡିସକନେକ୍ଟ ହେଇଯିବେ।"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"ଉନ୍ନତ ବିକଳ୍ପ"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ଡ୍ରପ୍-ଡାଉନ୍ ତାଲିକାରେ ଉନ୍ନତ ବିକଳ୍ପଗୁଡ଼ିକ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ବିସ୍ତାର କରନ୍ତୁ"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"ନିଜର ନେଟ୍‌ୱର୍କ ସଂଯୋଗ ପରିଚାଳନା କରିବା ପାଇଁ <xliff:g id="NEW_APP">%s</xliff:g>ର ବ୍ୟବହାର କରିବେ?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"ବର୍ତ୍ତମାନର ଲୋକେସନ୍ ଅନୁରୋଧ"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ୱାର୍କ ପ୍ରୋଫାଇଲ୍‌ ପାଇଁ ଲୋକେସନ୍‌"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ଆପର ଲୋକେସନ ଅନୁମତିଗୁଡ଼ିକ"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"ଲୋକେସନ୍‌ ବନ୍ଦ ଅଛି"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total}ଟିରୁ #ଟି ଆପ୍ସର ଲୋକେସନକୁ ଆକ୍ସେସ ଅଛି}other{{total}ଟିରୁ #ଟି ଆପ୍ସର ଲୋକେସନକୁ ଆକ୍ସେସ ଅଛି}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ଅନ୍-ସ୍କ୍ରିନ୍ କୀବୋର୍ଡ ବ୍ୟବହାର କରନ୍ତୁ"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"ଫିଜିକାଲ୍‌ କୀବୋର୍ଡ ସକ୍ରିୟ ଥିବାବେଳେ ଏହାକୁ ସ୍କ୍ରିନ୍‌ ଉପରେ ରଖନ୍ତୁ"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"ବାଉନ୍ସ କୀଗୁଡ଼ିକ"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"କୀବୋର୍ଡ <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms ମଧ୍ୟରେ ସମାନ କୀ ଶୀଘ୍ର ବାରମ୍ବାର ଦବାଇବାକୁ ଅଣଦେଖା କରେ"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ଶ୍ଲୋ କୀଗୁଡ଼ିକ"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> msକୁ ସକ୍ରିୟ କରିବାକୁ ଏକ କୀ ଦବାଇବା ପାଇଁ ଲାଗୁଥିବା ସମୟକୁ ଏହା ଆଡଜଷ୍ଟ କରେ"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ଷ୍ଟିକି କୀଗୁଡ଼ିକ"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"ଏକାଠି କୀଗୁଡ଼ିକୁ ଦବାଇ ଧରିବା ପରିବର୍ତ୍ତେ ସର୍ଟକର୍ଟଗୁଡ଼ିକ ପାଇଁ ଥରକେ ଗୋଟିଏ କୀ ଦବାନ୍ତୁ"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"କୀବୋର୍ଡ଼ ସର୍ଟକଟଗୁଡ଼ିକ"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"ସର୍ଟକଟଗୁଡ଼ିକର ତାଲିକା ଦେଖାନ୍ତୁ"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"ୱର୍କ ପ୍ରୋଫାଇଲ୍ କୀବୋର୍ଡ &amp; ଟୁଲ୍‌ଗୁଡ଼ିକ"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ରିସେଟ କରନ୍ତୁ"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"ମୋଡିଫାୟର କୀ ବାଛନ୍ତୁ"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> ପାଇଁ ଏକ ନୂଆ କୀ ବାଛନ୍ତୁ:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ପୂର୍ବ-ନିର୍ଦ୍ଧାରିତ"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"ସ୍ପିଚ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"ପଏଣ୍ଟର୍‌ର ବେଗ"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"ଗେମ କଣ୍ଟ୍ରୋଲର"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ନିଜର ଆବଶ୍ୟକତା ଅନୁସାରେ ଏହି ଡିଭାଇସକୁ ଆପଣ କଷ୍ଟମାଇଜ କରିପାରିବେ। ଏହି ଆକ୍ସେସିବିଲିଟୀ ଫିଚରଗୁଡ଼ିକୁ ପରେ ସେଟିଂସରେ ବଦଳାଯାଇପାରିବ।"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ଫଣ୍ଟ ସାଇଜ୍ ବଦଳାନ୍ତୁ"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"ସ୍କ୍ରିନ୍ ରିଡର୍"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ଫିଜିକାଲ କୀବୋର୍ଡ ବିକଳ୍ପଗୁଡ଼ିକ"</string>
     <string name="captions_category_title" msgid="574490148949400274">"କ୍ୟାପସନଗୁଡ଼ିକ"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ଅଡିଓ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"ସାଧାରଣ"</string>
     <string name="display_category_title" msgid="6638191682294461408">"ଡିସପ୍ଲେ"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"ରଙ୍ଗ ଏବଂ ମୋସନ"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"ରଙ୍ଗ କଣ୍ଟ୍ରାଷ୍ଟ"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"ଉଚ୍ଚ କଣ୍ଟ୍ରାଷ୍ଟ ଟେକ୍ସଟ, ବଟନ ଏବଂ ଆଇକନକୁ ଅଧିକ ସ୍ୱତନ୍ତ୍ର ଭାବେ ଦେଖାଇଥାଏ। ଆପଣଙ୍କ ସଠିକ ହୋଇଥିବା କଣ୍ଟ୍ରାଷ୍ଟ ବାଛନ୍ତୁ।"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"କିଛି ଆପ୍ସ ସମସ୍ତ ରଙ୍ଗ ଏବଂ ଟେକ୍ସଟ କଣ୍ଟ୍ରାଷ୍ଟ ସେଟିଂସକୁ ସମର୍ଥନ କରିନପାରେ"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"ଆପଣଙ୍କ ସ୍କ୍ରିନର ପୃଷ୍ଠପଟ ରଙ୍ଗ ଅନୁଯାୟୀ ରଙ୍ଗ ଏବଂ ଟେକ୍ସଟ କିପରି ଦେଖାଯିବ ତାହା ନିୟନ୍ତ୍ରଣ କରନ୍ତୁ"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"ପ୍ରିଭ୍ୟୁ"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"ହେଲେନ, ଆଦାମ"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 ଦିନ ପୂର୍ବେ"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ଫଲୋ ଅପ୍ କରିବେ?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"ବିଜିନେସ ଟ୍ରିପ ରିପୋର୍ଟ"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"ଅଧିକ ସହାୟତା ପାଇଁ ମୋ ସହ କିମ୍ବା ହେଲେନ\nସହ ଯୋଗାଯୋଗ କରନ୍ତୁ। ଏହି ରିପୋର୍ଟଟି ଏସବୁ ହେବ"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"କ୍ଲାଏଣ୍ଟର ଖର୍ଚ୍ଚ"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"ସ୍କ୍ରିନକୁ ଅଧିକ ଗାଢ଼ା କରନ୍ତୁ"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ଇଣ୍ଟରାକସନ୍‌ ନିୟନ୍ତ୍ରଣ"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"ସମୟ ନିୟନ୍ତ୍ରଣଗୁଡ଼ିକ"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"ଯେ କୌଣସି ମତେ ଜାରି ରଖନ୍ତୁ"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"ବାତିଲ କର"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"ମାଗ୍ନିଫିକେସନ ସେଟିଂସ"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ସର୍ଟକଟ୍ ସାହାଯ୍ୟରେ ମାଗ୍ନିଫାଏ କରନ୍ତୁ"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ତିନି ଥର ଟାପ୍ ଓ ସର୍ଟକଟ୍ ସାହାଯ୍ୟରେ ମାଗ୍ନିଫାଏ କରନ୍ତୁ"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> ବିଷୟରେ"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"ନନ୍-ଟ୍ରାନ୍ସପେରେଣ୍ଟ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ଉଚ୍ଚ କଣ୍ଟ୍ରାଷ୍ଟଯୁକ୍ତ ଟେକ୍ସଟ୍‌"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"ଟେକ୍ସଟର ରଙ୍ଗକୁ କଳା କିମ୍ବା ଧଳା ରଙ୍ଗରେ ପରିବର୍ତ୍ତନ କରନ୍ତୁ। ପୃଷ୍ଠପଟ ସହିତ କଣ୍ଟ୍ରାଷ୍ଟ ବଢ଼ାଏ।"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"ଟେକ୍ସଟର କଣ୍ଟ୍ରାଷ୍ଟ ସର୍ବାଧିକ କରନ୍ତୁ"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"ପୃଷ୍ଠପଟ ଅନୁସାରେ କଣ୍ଟ୍ରାଷ୍ଟ ବଢ଼ାଇବାକୁ ଟେକ୍ସଟର ରଙ୍ଗ କଳା କିମ୍ବା ଧଳାରେ ପରିବର୍ତ୍ତନ କରନ୍ତୁ।"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"ସ୍କ୍ରିନ୍‌ ମ୍ୟାଗ୍ନିଫାୟର୍‌ ସ୍ୱତଃ ଅପଡେଟ୍‌ କରନ୍ତୁ"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"ଆପ୍‌ ବଦଳିବାବେଳେ ସ୍କ୍ରୀନ୍‌କୁ ବଡ଼ କର"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"ପାୱର୍‌ ବଟନ୍‌ କଲ୍‌ ସମାପ୍ତ କରେ"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"ଭଲ୍ୟୁମ କୀ\'କୁ ଧରି ରଖନ୍ତୁ"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"ଟ୍ରିପଲ୍ ଟାପ୍ ସ୍କ୍ରିନ୍"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ଆକ୍ସେସିବିଲିଟୀ ସର୍ଟକଟଗୁଡ଼ିକୁ ଏଡିଟ କରନ୍ତୁ"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s ପାଇଁ ଆପଣଙ୍କ ସର୍ଟକଟ ବାଛନ୍ତୁ"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ଜାରି ରଖନ୍ତୁ"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"ଶ୍ରବଣ ଡିଭାଇସଗୁଡ଼ିକ"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA ଏବଂ LE ଅଡିଓ ଶ୍ରବଣ ଯନ୍ତ୍ର, କକଲିୟର ଇମ୍ପଲାଣ୍ଟ ଓ ଅନ୍ୟ ଆମ୍ପ୍ଲିଫିକେସନ ଡିଭାଇସଗୁଡ଼ିକୁ ସେଟ ଅପ ଏବଂ ପରିଚାଳନା କରନ୍ତୁ"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"କୌଣସି ଶ୍ରବଣ ଡିଭାଇସ କନେକ୍ଟ କରାଯାଇନାହିଁ"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"ଶ୍ରବଣ ଯନ୍ତ୍ର ଯୋଗ କରନ୍ତୁ"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"ଶ୍ରବଣ ଯନ୍ତ୍ରକୁ ପେୟାର କର"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"ଶ୍ରବଣ ଯନ୍ତ୍ର କମ୍ପାଟିବିଲିଟୀ"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ଟେଲିକୋଲିସ ସହ କମ୍ପାଟିବିଲିଟୀକୁ ଉନ୍ନତ କରେ ଏବଂ ଅବାଞ୍ଛିତ ନଏଜକୁ ହ୍ରାସ କରେ"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"ହିଅରିଂ ଡିଭାଇସଗୁଡ଼ିକ ବିଷୟରେ"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA କିମ୍ବା LE ଅଡିଓ ଦ୍ୱାରା ସମର୍ଥିତ ନଥିବା ଅନ୍ୟ ହିଅରିଂ ଡିଭାଇସଗୁଡ଼ିକ ଖୋଜିବାକୁ "<b>"ନୂଆ ଡିଭାଇସ ପେୟାର କରନ୍ତୁ"</b>" &gt; "<b>"ଅଧିକ ଡିଭାଇସ ଦେଖନ୍ତୁ"</b>"ରେ ଟାପ କରନ୍ତୁ"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"ହିଅରିଂ ଡିଭାଇସକୁ ପେୟାର କର"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ଆପଣ ଏହି ପୃଷ୍ଠାରେ ASHA ଏବଂ LE ଅଡିଓ ହିଅରିଂ ଡିଭାଇସଗୁଡ଼ିକୁ ପେୟାର କରିପାରିବେ। ଆପଣଙ୍କ ହିଅରିଂ ଡିଭାଇସ ଚାଲୁ ଅଛି ଏବଂ ଏହା ପେୟାର ହେବା ପାଇଁ ପ୍ରସ୍ତୁତ ଅଛି ବୋଲି ସୁନିଶ୍ଚିତ କରନ୍ତୁ।"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ଉପଲବ୍ଧ ଶ୍ରବଣ ଡିଭାଇସଗୁଡ଼ିକ"</string>
@@ -3567,7 +3548,7 @@
     <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"ପିକଚର-ଇନ-ପିକଚରକୁ ଅନୁମତି ଦିଅନ୍ତୁ"</string>
     <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"ଆପଟି ଖୋଲା ଥିବା ସମୟରେ କିମ୍ୱା ଆପଣ ଏଥିରୁ ବାହାରି ଯିବା ପରେ (ଉଦାହରଣସ୍ୱରୂପ, ଏକ ଭିଡିଓ ଦେଖିବା ଜାରି ରଖିବାକୁ) ଏକ ପିକଚର-ଇନ-ପିକଚର ୱିଣ୍ଡୋ ତିଆରି କରିବା ପାଇଁ ଏହି ଆପକୁ ଅନୁମତି ଦିଅନ୍ତୁ। ଆପଣ ବ୍ୟବହାର କରୁଥିବା ଅନ୍ୟ ଆପ୍ସର ଶୀର୍ଷରେ ଏହି ୱିଣ୍ଡୋ ଦେଖାଯାଏ।"</string>
     <string name="interact_across_profiles_title" msgid="7285906999927669971">"କନେକ୍ଟ କରାଯାଇଥିବା ୱାର୍କ ଓ ବ୍ୟକ୍ତିଗତ ଆପ୍ସ"</string>
-    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"ସଂଯୋଗ ହୋଇଛି"</string>
+    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"କନେକ୍ଟ ହୋଇଛି"</string>
     <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"ସଂଯୋଗ ହୋଇନାହିଁ"</string>
     <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"କୌଣସି ସଂଯୁକ୍ତ ଥିବା ଆପ୍ ନାହିଁ"</string>
     <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"କ୍ରସ୍ ପ୍ରୋଫାଇଲରେ ସଂଯୁକ୍ତ ଥିବା ଆପ୍, କାର୍ଯ୍ୟସ୍ଥଳୀ ଏବଂ ବ୍ୟକ୍ତିଗତ ଆପଗୁଡ଼ିକ"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ଟେକ୍ସଟଗୁଡ଼ିକ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ସ୍ୱତଃ ଡାଟା ସୁଇଚିଂ"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"କଭରେଜ ଏବଂ ଉପଲବ୍ଧତା ଉପରେ ନିର୍ଭର କରି ଯେ କୌଣସି SIMରୁ ଡାଟା ବ୍ୟବହାର କରନ୍ତୁ"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"କେବଳ ଡାଟା"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"ସେଟ ଅପ କରନ୍ତୁ"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"ପରବର୍ତ୍ତୀ"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"ଆଖପାଖରେ UWB ଥିବା ଡିଭାଇସଗୁଡ଼ିକର ଆପେକ୍ଷିକ ଅବସ୍ଥିତି ଚିହ୍ନଟ କରିବାରେ ସାହାଯ୍ୟ କରେ"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB ବ୍ୟବହାର କରିବାକୁ ଏୟାରପ୍ଲେନ୍ ମୋଡ୍ ବନ୍ଦ କରନ୍ତୁ"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"ବର୍ତ୍ତମାନର ଲୋକେସନରେ UWB ଉପଲବ୍ଧ ନାହିଁ"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"ଥ୍ରେଡ"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"ଏକ ବାଧାରହିତ ସ୍ମାର୍ଟ ହୋମ ଅନୁଭୂତି ପାଇଁ ଥ୍ରେଡ ବ୍ୟବହାର କରି କମ୍ପାଟିବଲ ଡିଭାଇସଗୁଡ଼ିକ ସହ କନେକ୍ଟ କରନ୍ତୁ"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"ଥ୍ରେଡ ବ୍ୟବହାର କରିବାକୁ ଏୟାରପ୍ଲେନ ମୋଡକୁ ବନ୍ଦ କରନ୍ତୁ"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"କେମେରା ଆକ୍ସେସ"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"ମାଇକ୍ରୋଫୋନ୍ ଆକ୍ସେସ୍"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ଆପ ଓ ସେବାଗୁଡ଼ିକ ପାଇଁ"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"ବାତିଲ କରନ୍ତୁ"</string>
     <string name="contrast_title" msgid="6885768151336508075">"କଣ୍ଟ୍ରାଷ୍ଟ"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"ଷ୍ଟାଣ୍ଡାର୍ଡ"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ଡିଫଲ୍ଟ"</string>
     <string name="contrast_medium" msgid="384414510709285811">"ମଧ୍ୟମ"</string>
     <string name="contrast_high" msgid="3988567609694797696">"ଅଧିକ"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"ଏହି ଆପକୁ କେବଳ 1ଟି ୱିଣ୍ଡୋରେ ଖୋଲାଯାଇପାରିବ"</string>
diff --git a/res/values-pa/arrays.xml b/res/values-pa/arrays.xml
index 998b096..c90412f 100644
--- a/res/values-pa/arrays.xml
+++ b/res/values-pa/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"ਮੀਟਰਬੱਧ ਮੰਨੋ"</item>
     <item msgid="2047166446768045816">"ਗੈਰ-ਮੀਟਰਬੱਧ ਮੰਨੋ"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ਬੇਤਰਤੀਬਵਾਰ MAC (ਪੂਰਵ-ਨਿਰਧਾਰਿਤ) ਵਰਤੋ"</item>
-    <item msgid="741680937828608749">"ਡੀਵਾਈਸ MAC ਵਰਤੋ"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"ਨਹੀਂ"</item>
     <item msgid="2163015208097377388">"ਹਾਂ"</item>
diff --git a/res/values-pa/strings.xml b/res/values-pa/strings.xml
index 64cf844..73bdcdb 100644
--- a/res/values-pa/strings.xml
+++ b/res/values-pa/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"ਸੱਜਾ ਕੰਨ ਜੋੜਾਬੱਧ ਕਰੋ"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"ਖੱਬਾ ਕੰਨ ਜੋੜਾਬੱਧ ਕਰੋ"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"ਸਾਰੇ ਉਪਲਬਧ ਸੁਣਨ ਵਾਲੇ ਡੀਵਾਈਸਾਂ ਲਈ"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"ਹੋਰ ਸੁਣਨ ਵਾਲੇ ਡੀਵਾਈਸ ਦੀਆਂ ਸੈਟਿੰਗਾਂ"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"ਸ਼ਾਰਟਕੱਟ ਅਤੇ ਟੈਲੀਕੋਇਲ ਕੰਟਰੋਲਾਂ ਵਰਗੀਆਂ ਕ੍ਰਾਸ-ਡੀਵਾਈਸ ਸੈਟਿੰਗਾਂ ਬਦਲੋ"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"ਇਸ ਡੀਵਾਈਸ ਲਈ"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ਆਡੀਓ ਆਊਟਪੁੱਟ"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ਆਡੀਓ ਆਊਟਪੁੱਟ ਬਾਰੇ"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"ਨਿੱਜੀ ਸਪੇਸ ਦਾ ਸੈੱਟਅੱਪ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਦੇ ਲਾਕ ਹੋਣ \'ਤੇ, ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਐਪਾਂ ਦੀਆਂ ਸੂਚਨਾਵਾਂ ਲੁਕੀਆਂ ਹੁੰਦੀਆਂ ਹਨ"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਨੂੰ ਲੁਕਾਉਣ ਲਈ ਅਤੇ ਸਵੈਚਲਿਤ ਲਾਕ ਕਰਨ ਦੀ ਸੁਵਿਧਾ ਦਾ ਸੈੱਟਅੱਪ ਕਰਨ ਲਈ, ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਸੈਟਿੰਗਾਂ ਦੀ ਪੜਚੋਲ ਕਰੋ"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"ਤੁਹਾਡੀ ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਵਿੱਚ ਲੋੜੀਂਦੀਆਂ ਐਪਾਂ ਪਹਿਲਾਂ ਹੀ ਸਥਾਪਤ ਕੀਤੀਆਂ ਹੋਈਆਂ ਹਨ"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਦਾ ਸੈੱਟਅੱਪ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਿਆ"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"ਕੀ ਨਿੱਜੀ ਸਪੇਸ ਨੂੰ ਸਕ੍ਰੀਨ ਲਾਕ ਨਾਲ ਅਣਲਾਕ ਕਰਨਾ ਹੈ?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"ਐਪਾਂ ਅਤੇ ਸੂਚਨਾਵਾਂ"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"ਲਾਕ ਸਕ੍ਰੀਨ \'ਤੇ ਸੰਵੇਦਨਸ਼ੀਲ ਸੂਚਨਾਵਾਂ"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਅਣਲਾਕ ਹੋਣ \'ਤੇ ਸੰਵੇਦਨਸ਼ੀਲ ਸਮੱਗਰੀ ਦਿਖਾਓ"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"ਆਪਣੇ ਡਾਟੇ ਨੂੰ ਨਿੱਜੀ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਲਈ Google ਖਾਤਾ ਬਣਾਓ"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"ਅਗਲੀ ਸਕ੍ਰੀਨ ’ਤੇ, ਤੁਸੀਂ ਆਪਣੀ ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਨਾਲ ਵਰਤਣ ਲਈ ਕਿਸੇ ਖਾਤੇ ਵਿੱਚ ਸਾਈਨ-ਇਨ ਕਰ ਸਕਦੇ ਹੋ"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"ਡਾਟੇ ਨੂੰ ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਤੋਂ ਬਾਹਰ ਦਿਸਣ ਤੋਂ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਲਈ ਸਮਰਪਿਤ ਖਾਤਾ ਬਣਾਓ, ਜਿਵੇਂ ਕਿ:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"ਸਿੰਕ ਕੀਤੀਆਂ ਫ਼ੋਟੋਆਂ, ਫ਼ਾਈਲਾਂ, ਈਮੇਲਾਂ, ਸੰਪਰਕ, ਕੈਲੰਡਰ ਇਵੈਂਟ ਅਤੇ ਹੋਰ ਡਾਟਾ"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"ਐਪ ਡਾਊਨਲੋਡ ਇਤਿਹਾਸ ਅਤੇ ਸਿਫ਼ਾਰਸ਼ਾਂ"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ਬ੍ਰਾਊਜ਼ਿੰਗ ਇਤਿਹਾਸ, ਬੁੱਕਮਾਰਕ ਅਤੇ ਰੱਖਿਅਤ ਕੀਤੇ ਪਾਸਵਰਡ"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਐਪਾਂ ਵਿੱਚ ਤੁਹਾਡੀ ਸਰਗਰਮੀ ਨਾਲ ਸੰਬੰਧਿਤ ਸੁਝਾਈ ਗਈ ਸਮੱਗਰੀ"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"ਸਮਝ ਲਿਆ"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"ਤੁਸੀਂ <xliff:g id="COUNT">%d</xliff:g> ਤੱਕ ਫਿੰਗਰਪ੍ਰਿੰਟ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"ਤੁਸੀਂ ਫਿੰਗਰਪ੍ਰਿੰਟਾਂ ਦੀ ਅਧਿਕਤਮ ਸੰਖਿਆ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਹੋਇਆ ਹੈ"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"ਹੋਰ ਫਿੰਗਰਪ੍ਰਿੰਟਾਂ ਨੂੰ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"ਤੁਹਾਡਾ ਕੈਰੀਅਰ ਤੁਹਾਨੂੰ ਇਸ ਨੈੱਟਵਰਕ ਨਾਲ ਕਨੈਕਟ ਕਰਨ ਦੀ ਆਗਿਆ ਨਹੀਂ ਦਿੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਕਿਸੇ ਪੁਰਾਣੇ ਸੁਰੱਖਿਆ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਘੱਟ ਸੁਰੱਖਿਅਤ ਹੈ"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP ਦੀ ਆਗਿਆ ਦਿਓ"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"ਬੰਦ ਕਰੋ"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"ਕੀ <xliff:g id="NAME">%1$s</xliff:g> ਤੋਂ ਡਿਸਕਨੈਕਟ ਕਰਨਾ ਹੈ?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"ਤੁਸੀਂ WEP ਨੈੱਟਵਰਕ ਨਾਲ ਕਨੈਕਟ ਹੋ। ਜੇ ਤੁਸੀਂ ਇਨ੍ਹਾਂ ਨੈੱਟਵਰਕਾਂ ਨੂੰ ਬਲਾਕ ਕਰ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਡਿਸਕਨੈਕਟ ਕਰ ਦਿੱਤਾ ਜਾਵੇਗਾ।"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"ਅਡਵਾਂਸ ਵਿਕਲਪ"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ਡ੍ਰੌਪ-ਡਾਊਨ ਸੂਚੀ ਦੇ ਉੱਨਤ ਵਿਕਲਪ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ਵਿਸਤਾਰ ਕਰੋ"</string>
@@ -1553,6 +1540,7 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"ਕੀ ਆਪਣੇ ਨੈੱਟਵਰਕ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਨ ਲਈ <xliff:g id="NEW_APP">%s</xliff:g> ਵਰਤਣਾ ਹੈ?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"ਹਾਲੀਆ ਟਿਕਾਣਾ ਬੇਨਤੀਆਂ"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ਕਾਰਜ ਪ੍ਰੋਫਾਈਲ ਲਈ ਟਿਕਾਣਾ"</string>
+    <string name="private_profile_location_switch_title" msgid="4127119143109855789">"ਪ੍ਰਾਈਵੇਟ ਸਪੇਸ ਦਾ ਟਿਕਾਣਾ"</string>
     <string name="location_app_level_permissions" msgid="907206607664629759">"ਐਪ ਦੀਆਂ ਟਿਕਾਣੇ ਸੰਬੰਧੀ ਇਜਾਜ਼ਤਾਂ"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"ਟਿਕਾਣਾ ਬੰਦ ਹੈ"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} ਵਿੱਚੋਂ # ਐਪ ਕੋਲ ਟਿਕਾਣੇ ਤੱਕ ਪਹੁੰਚ ਹੈ}one{{total} ਵਿੱਚੋਂ # ਐਪ ਕੋਲ ਟਿਕਾਣੇ ਤੱਕ ਪਹੁੰਚ ਹੈ}other{{total} ਵਿੱਚੋਂ # ਐਪਾਂ ਕੋਲ ਟਿਕਾਣੇ ਤੱਕ ਪਹੁੰਚ ਹੈ}}"</string>
@@ -1886,14 +1874,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ਆਨ-ਸਕ੍ਰੀਨ ਕੀ-ਬੋਰਡ ਨੂੰ ਵਰਤੋ"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"ਭੌਤਿਕ ਕੀ-ਬੋਰਡ ਕਿਰਿਆਸ਼ੀਲ ਹੋਣ ਦੌਰਾਨ ਇਸ ਨੂੰ ਸਕ੍ਰੀਨ \'ਤੇ ਬਣਾਈ ਰੱਖੋ"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"ਬਾਊਂਸ ਕੁੰਜੀਆਂ"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ਮਿਲੀਸਕਿੰਟਾਂ ਵਿੱਚ ਵਾਰ-ਵਾਰ ਇੱਕੋ ਕੁੰਜੀ ਨੂੰ ਦਬਾਉਂਦੇ ਰਹਿਣ \'ਤੇ ਕੀ-ਬੋਰਡ ਉਸਨੂੰ ਅਣਡਿੱਠ ਕਰ ਦਿੰਦਾ ਹੈ"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ਧੀਵੀਂ ਕੁੰਜੀਆਂ"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"ਕਿਸੇ ਕੁੰਜੀ ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਕਰਨ ਵਿੱਚ ਲੱਗਣ ਵਾਲੇ ਸਮੇਂ ਨੂੰ <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ਮਿਲੀਸਕਿੰਟਾਂ ਤੱਕ ਵਿਵਸਥਿਤ ਕਰਦਾ ਹੈ"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ਸਥਿਰ ਕੁੰਜੀਆਂ"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"ਸ਼ਾਰਟਕੱਟਾਂ ਲਈ ਕੁੰਜੀਆਂ ਨੂੰ ਇਕੱਠੇ ਦਬਾਈ ਰੱਖਣ ਦੀ ਬਜਾਏ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ ਕੁੰਜੀ ਦਬਾਓ"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"ਕੀ-ਬੋਰਡ ਸ਼ਾਰਟਕੱਟ"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"ਸ਼ਾਰਟਕੱਟਾਂ ਦੀ ਸੂਚੀ ਦਿਖਾਓ"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"ਕਾਰਜ ਪ੍ਰੋਫਾਈਲ ਕੀ-ਬੋਰਡ ਅਤੇ ਟੂਲ"</string>
@@ -1947,7 +1932,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ਰੀਸੈੱਟ ਕਰੋ"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"ਸੋਧਕ ਕੁੰਜੀ ਚੁਣੋ"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> ਲਈ ਨਵੀਂ ਕੁੰਜੀ ਚੁਣੋ:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ਪੂਰਵ-ਨਿਰਧਾਰਿਤ"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"ਬੋਲੀ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"ਪੁਆਇੰਟਰ ਸਪੀਡ"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"ਗੇਮ ਕੰਟ੍ਰੋਲਰ"</string>
@@ -2003,35 +1994,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ਤੁਸੀਂ ਇਸ ਡੀਵਾਈਸ ਨੂੰ ਆਪਣੀਆਂ ਲੋੜਾਂ ਮੁਤਾਬਕ ਵਿਉਂਤਬੱਧ ਕਰ ਸਕਦੇ ਹੋ। ਇਨ੍ਹਾਂ ਪਹੁੰਚਯੋਗਤਾ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਜਾ ਕੇ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ਫੌਂਟ ਦਾ ਆਕਾਰ ਬਦਲੋ"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"ਸਕ੍ਰੀਨ ਰੀਡਰ"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ਭੌਤਿਕ ਕੀ-ਬੋਰਡ ਦੇ ਵਿਕਲਪ"</string>
     <string name="captions_category_title" msgid="574490148949400274">"ਸੁਰਖੀਆਂ"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ਆਡੀਓ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"ਸਧਾਰਨ"</string>
     <string name="display_category_title" msgid="6638191682294461408">"ਡਿਸਪਲੇ"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"ਰੰਗ ਅਤੇ ਮੋਸ਼ਨ"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"ਰੰਗ ਦਾ ਕੰਟ੍ਰਾਸਟ"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"ਜ਼ਿਆਦਾ ਕੰਟ੍ਰਾਸਟ ਨਾਲ ਲਿਖਤ, ਬਟਨ ਅਤੇ ਪ੍ਰਤੀਕ ਹੋਰ ਵੀ ਵੱਖਰੇ ਨਜ਼ਰ ਆਉਂਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਵਧੀਆ ਦਿਸਣ ਵਾਲਾ ਕੰਟ੍ਰਾਸਟ ਚੁਣੋ।"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"ਸ਼ਾਇਦ ਕੁਝ ਐਪਾਂ ਸਾਰੀਆਂ ਰੰਗ ਅਤੇ ਲਿਖਤ ਦੀਆਂ ਕੰਟ੍ਰਾਸਟ ਸੈਟਿੰਗਾਂ ਦਾ ਸਮਰਥਨ ਨਾ ਕਰਨ"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"ਵਿਵਸਥਿਤ ਕਰੋ ਕਿ ਰੰਗ ਅਤੇ ਲਿਖਤ ਤੁਹਾਡੀ ਸਕ੍ਰੀਨ ਦੇ ਬੈਕਗ੍ਰਾਊਂਡ ਰੰਗ ਅੱਗੇ ਕਿਵੇਂ ਲੱਗਦੇ ਹਨ"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"ਪੂਰਵ-ਝਲਕ ਦੇਖੋ"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"ਹੈਲਨ, ਐਡਮ"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 ਦਿਨ ਪਹਿਲਾਂ"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ਫ਼ਾਲੋ ਅੱਪ ਕਰਨਾ ਹੈ?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"ਕਾਰੋਬਾਰੀ ਯਾਤਰਾ ਦੀ ਰਿਪੋਰਟ"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"ਹੋਰ ਸਹਾਇਤਾ ਲਈ, ਕਿਰਪਾ ਕਰਕੇ \nਮੈਨੂੰ ਜਾਂ ਹੈਲਨ ਨੂੰ ਸੰਪਰਕ ਕਰੋ। ਇਹ ਰਿਪੋਰਟ"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"ਕਲਾਇੰਟ ਦੇ ਖਰਚੇ"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"ਸਕ੍ਰੀਨ ਦਾ ਗੂੜ੍ਹਾ ਕਰੋ"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ਅੰਤਰਕਿਰਿਆ ਦੇ ਕੰਟਰੋਲ"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"ਟਾਈਮਿੰਗ ਕੰਟਰੋਲ"</string>
@@ -2081,6 +2060,9 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"ਫਿਰ ਵੀ ਜਾਰੀ ਰੱਖੋ"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"ਰੱਦ ਕਰੋ"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"ਵੱਡਦਰਸ਼ੀਕਰਨ ਸੈਟਿੰਗਾਂ"</string>
+    <string name="accessibility_magnification_one_finger_panning_title" msgid="4503949739883092989">"ਇੱਕ ਉਂਗਲ ਨਾਲ ਪੈਨਿੰਗ"</string>
+    <string name="accessibility_magnification_one_finger_panning_summary_on" msgid="9133125894310777539">"ਇੱਕ ਉਂਗਲ ਨਾਲ ਘਸੀਟ ਕੇ ਵੱਡਦਰਸ਼ੀਕਰਨ ਖੇਤਰ ਨੂੰ ਹਿਲਾਓ।"</string>
+    <string name="accessibility_magnification_one_finger_panning_summary_off" msgid="8979146350396559805">"ਦੋ ਉਂਗਲਾਂ ਨਾਲ ਘਸੀਟ ਕੇ ਵੱਡਦਰਸ਼ੀਕਰਨ ਖੇਤਰ ਨੂੰ ਹਿਲਾਓ।"</string>
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ਸ਼ਾਰਟਕੱਟ ਨਾਲ ਵੱਡਾ ਕਰੋ"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ਸ਼ਾਰਟਕੱਟ ਅਤੇ ਤਿੰਨ-ਟੈਪ ਨਾਲ ਵੱਡਾ ਕਰੋ"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> ਬਾਰੇ"</string>
@@ -2168,10 +2150,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"ਗੈਰ-ਪਾਰਦਰਸ਼ੀ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ਉੱਚ ਕੰਟ੍ਰਾਸਟ ਲਿਖਤ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"ਲਿਖਤ ਦਾ ਰੰਗ ਬਦਲ ਕੇ ਕਾਲਾ ਜਾਂ ਸਫ਼ੈਦ ਕਰੋ। ਇਹ ਬੈਕਗ੍ਰਾਉਂਡ ਦੇ ਨਾਲ ਕੰਟ੍ਰਾਸਟ ਵਧਾ ਦਿੰਦਾ ਹੈ।"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"ਲਿਖਤ ਦੇ ਕੰਟ੍ਰਾਸਟ ਨੂੰ ਵੱਡਾ ਕਰੋ"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"ਬੈਕਗ੍ਰਾਊਂਡ ਦੇ ਨਾਲ ਕੰਟ੍ਰਾਸਟ ਵਧਾਉਣ ਲਈ ਲਿਖਤ ਦਾ ਰੰਗ ਬਦਲ ਕੇ ਕਾਲਾ ਜਾਂ ਸਫ਼ੈਦ ਕਰੋ।"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"ਸਕ੍ਰੀਨ ਵਿਸਤਰੀਕਰਨ ਸਵੈ-ਅੱਪਡੇਟ ਕਰੋ"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"ਐਪ ਟ੍ਰਾਂਜਿਸ਼ਨਾਂ ਤੇ ਸਕ੍ਰੀਨ ਵਿਸਤਰੀਕਰਨ ਅੱਪਡੇਟ ਕਰੋ"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"ਪਾਵਰ ਬਟਨ ਨਾਲ ਕਾਲ ਕੱਟਣਾ"</string>
@@ -2267,12 +2247,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"ਅਵਾਜ਼ ਕੁੰਜੀਆਂ ਨੂੰ ਦਬਾ ਕੇ ਰੱਖੋ"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"ਸਕ੍ਰੀਨ \'ਤੇ ਟ੍ਰਿਪਲ ਟੈਪ ਕਰੋ"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ਪਹੁੰਚਯੋਗਤਾ ਸ਼ਾਰਟਕੱਟਾਂ ਦਾ ਸੰਪਾਦਨ ਕਰੋ"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s ਲਈ ਆਪਣਾ ਸ਼ਾਰਟਕੱਟ ਚੁਣੋ"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ਜਾਰੀ ਰੱਖੋ"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"ਸੁਣਨ ਵਾਲੇ ਡੀਵਾਈਸ"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA ਅਤੇ LE ਆਡੀਓ ਸੰਬੰਧੀ ਸੁਣਨ ਦੇ ਸਾਧਨ, ਕੋਕਲੀਅਰ ਇਮਪਲਾਂਟਾਂ ਅਤੇ ਹੋਰ ਐਂਪਲੀਫ਼ੀਕੇਸ਼ਨ ਡੀਵਾਈਸਾਂ ਦਾ ਸੈੱਟਅੱਪ ਕਰੋ ਅਤੇ ਉਨ੍ਹਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰੋ"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"ਸੁਣਨ ਵਾਲਾ ਕੋਈ ਡੀਵਾਈਸ ਕਨੈਕਟ ਨਹੀਂ ਹੈ"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"ਸੁਣਨ ਦੇ ਸਾਧਨ ਸ਼ਾਮਲ ਕਰੋ"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"ਸੁਣਨ ਦੇ ਸਾਧਨਾਂ ਨੂੰ ਜੋੜਾਬੱਧ ਕਰੋ"</string>
@@ -2290,8 +2268,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"ਸੁਣਨ ਦੇ ਸਾਧਨ ਦੀ ਅਨੁਰੂਪਤਾ"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ਟੈਲੀਕੋਇਲਾਂ ਨਾਲ ਅਨੁਰੂਪਤਾ ਦਾ ਸੁਧਾਰ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਹ ਅਣਚਾਹੇ ਸ਼ੋਰ ਨੂੰ ਘਟਾਉਂਦੇ ਹਨ"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"ਸੁਣਨ ਵਾਲੇ ਡੀਵਾਈਸਾਂ ਬਾਰੇ"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ਅਜਿਹੇ ਸੁਣਨ ਵਾਲੇ ਹੋਰ ਡੀਵਾਈਸ ਲੱਭਣ ਲਈ ਜੋ ASHA ਜਾਂ LE ਆਡੀਓ ਵੱਲੋਂ ਸਮਰਥਿਤ ਨਹੀਂ ਹਨ, "<b>"ਨਵਾਂ ਡੀਵਾਈਸ ਜੋੜਾਬੱਧ ਕਰੋ"</b>" ਅਤੇ "<b>"ਹੋਰ ਡੀਵਾਈਸ ਦੇਖੋ"</b>" \'ਤੇ ਟੈਪ ਕਰੋ"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"ਸੁਣਨ ਵਾਲਾ ਡੀਵਾਈਸ ਜੋੜਾਬੱਧ ਕਰੋ"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ਤੁਸੀਂ ਇਸ ਪੰਨੇ \'ਤੇ ASHA ਅਤੇ LE ਆਡੀਓ ਦੇ ਸੁਣਨ ਵਾਲੇ ਡੀਵਾਈਸਾਂ ਨੂੰ ਜੋੜਾਬੱਧ ਕਰ ਸਕਦੇ ਹੋ। ਪੱਕਾ ਕਰੋ ਕਿ ਤੁਹਾਡਾ ਸੁਣਨ ਵਾਲਾ ਡੀਵਾਈਸ ਚਾਲੂ ਹੈ ਅਤੇ ਜੋੜਾਬੱਧ ਹੋਣ ਲਈ ਤਿਆਰ ਹੈ।"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ਸੁਣਨ ਵਾਲੇ ਉਪਲਬਧ ਡੀਵਾਈਸ"</string>
@@ -4663,6 +4640,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ਲਿਖਤ ਸੁਨੇਹੇ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ਆਪਣੇ ਆਪ ਡਾਟਾ ਸਵਿੱਚ ਹੋਣਾ"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"ਕਵਰੇਜ ਅਤੇ ਉਪਲਬਧਤਾ ਦੇ ਆਧਾਰ \'ਤੇ ਕਿਸੇ ਵੀ ਸਿਮ ਤੋਂ ਡਾਟੇ ਦੀ ਵਰਤੋਂ ਕਰੋ"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ਸਿਰਫ਼ ਡਾਟਾ"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"ਸੈੱਟਅੱਪ ਕਰੋ"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"ਅੱਗੇ"</string>
@@ -4941,12 +4924,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"ਉਨ੍ਹਾਂ ਨਜ਼ਦੀਕੀ ਡੀਵਾਈਸਾਂ ਦੀ ਸੰਬੰਧਿਤ ਸਥਿਤੀ ਦੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਜਿੰਨ੍ਹਾਂ ਕੋਲ UWB ਹੈ"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਹਵਾਈ-ਜਹਾਜ਼ ਮੋਡ ਬੰਦ ਕਰੋ"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"ਮੌਜੂਦਾ ਟਿਕਾਣੇ \'ਤੇ UWB ਉਪਲਬਧ ਨਹੀਂ ਹੈ"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"ਸਹਿਜ ਸਮਾਰਟ ਹੋਮ ਅਨੁਭਵ ਲਈ Thread ਨੂੰ ਵਰਤ ਕੇ ਅਨੁਰੂਪ ਡੀਵਾਈਸਾਂ ਨਾਲ ਕਨੈਕਟ ਕਰੋ"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਹਵਾਈ-ਜਹਾਜ਼ ਮੋਡ ਬੰਦ ਕਰੋ"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"ਕੈਮਰਾ ਪਹੁੰਚ"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"ਮਾਈਕ੍ਰੋਫ਼ੋਨ ਪਹੁੰਚ"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ਐਪਾਂ ਅਤੇ ਸੇਵਾਵਾਂ ਲਈ"</string>
@@ -5123,8 +5103,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"ਰੱਦ ਕਰੋ"</string>
     <string name="contrast_title" msgid="6885768151336508075">"ਕੰਟ੍ਰਾਸਟ"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"ਮਿਆਰੀ"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ਪੂਰਵ-ਨਿਰਧਾਰਿਤ"</string>
     <string name="contrast_medium" msgid="384414510709285811">"ਦਰਮਿਆਨਾ"</string>
     <string name="contrast_high" msgid="3988567609694797696">"ਜ਼ਿਆਦਾ"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"ਇਹ ਐਪ ਸਿਰਫ਼ 1 ਵਿੰਡੋ ਵਿੱਚ ਖੋਲ੍ਹੀ ਜਾ ਸਕਦੀ ਹੈ"</string>
diff --git a/res/values-pl/arrays.xml b/res/values-pl/arrays.xml
index 04202aa..76eea67 100644
--- a/res/values-pl/arrays.xml
+++ b/res/values-pl/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Traktuj jako sieć z pomiarem użycia danych"</item>
     <item msgid="2047166446768045816">"Traktuj jako sieć bez pomiaru użycia danych"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Randomizowany MAC (domyślnie)"</item>
-    <item msgid="741680937828608749">"Używaj adresu MAC urządzenia"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nie"</item>
     <item msgid="2163015208097377388">"Tak"</item>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index e1cab51..211a1d2 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Sparuj prawe ucho"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Sparuj lewe ucho"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Dla wszystkich dostępnych urządzeń słuchowych"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Więcej ustawień urządzenia słuchowego"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Zmień ustawienia dla wielu urządzeń, takie jak skróty czy opcje cewki telefonicznej"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Dla tego urządzenia"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Wyjście audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"O wyjściu audio"</string>
@@ -591,15 +589,14 @@
     <string name="private_space_setup_title" msgid="2272968244329821450">"Przestrzeń prywatna"</string>
     <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Ukryj lub zablokuj aplikacje prywatne w oddzielnym obszarze. Aby zwiększyć bezpieczeństwo, skorzystaj z dedykowanego konta Google."</string>
     <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Skonfiguruj przestrzeń prywatną"</string>
-    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Wybierz konto Google dla swojej przestrzeni"</b>\n"Korzystanie z dedykowanego konta zapobiega wyświetlaniu się synchronizowanych plików, zdjęć i e-maili poza Twoją przestrzenią"</string>
-    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Ustaw blokadę"</b>\n"Zablokuj swoją przestrzeń, żeby inni nie mogli jej otworzyć"</string>
+    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Wybierz konto Google dla swojej przestrzeni"</b>\n"Korzystanie z dedykowanego konta zapobiega wyświetlaniu się synchronizowanych plików, zdjęć i e-maili poza Twoją przestrzenią."</string>
+    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Ustaw blokadę"</b>\n"Zablokuj swoją przestrzeń, żeby inni nie mogli jej otworzyć."</string>
     <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Zainstaluj aplikacje"</b>\n"Twoja przestrzeń prywatna ma własny Sklep Play, dzięki czemu instalowanie aplikacji jest proste."</string>
     <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Aplikacje w obszarze prywatnym nie będą wyświetlane w menedżerze uprawnień, panelu prywatności ani innych ustawieniach, gdy obszar prywatny jest zablokowany.\n\nObszaru prywatnego nie można przenieść na nowe urządzenie. Jeśli chcesz korzystać z niego na innym urządzeniu, musisz skonfigurować kolejny obszar prywatny.\n\nKażdy, kto połączy Twoje urządzenie z komputerem lub zainstaluje na urządzeniu szkodliwe aplikacje, będzie mieć możliwość uzyskania dostępu do Twojego obszaru prywatnego."</string>
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Konfiguruję obszar prywatny…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Powiadomienia z aplikacji w przestrzeni prywatnej są ukryte, gdy jest ona zablokowana"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"W ustawieniach przestrzeni prywatnej możesz ukryć przestrzeń prywatną i skonfigurować automatyczne blokowanie"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Niektóre aplikacje są już zainstalowane w przestrzeni prywatnej"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Nie udało się skonfigurować przestrzeni prywatnej"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Spróbuj ponownie"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Używać blokady ekranu do odblokowywania obszaru prywatnego?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikacje i powiadomienia"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Powiadomienia poufne na ekranie blokady"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Pokazuj treści poufne, gdy przestrzeń prywatna jest odblokowana"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Utwórz konto Google, aby lepiej chronić prywatność swoich danych"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na następnym ekranie możesz zalogować się na konto, z którego chcesz korzystać w przestrzeni prywatnej"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Utwórz osobne konto, aby zapobiegać wyświetlaniu poza przestrzenią prywatną danych takich jak:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Zsynchronizowane zdjęcia, pliki, e-maile, kontakty, wydarzenia w kalendarzu i inne dane"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historia pobierania aplikacji i rekomendacje"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historia przeglądania, zakładki i zapisane hasła"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Sugerowane treści związane z Twoją aktywnością w aplikacjach w przestrzeni prywatnej"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Możesz dodać do <xliff:g id="COUNT">%d</xliff:g> odcisków palców"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodano maksymalną liczbę odcisków palców"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nie można dodać więcej odcisków palców"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Twój operator nie zezwala na łączenie się z tą siecią, ponieważ korzysta ona ze starszego protokołu zabezpieczeń, który jest mniej bezpieczny"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Zezwalaj na sieci z protokołem WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Zamknij"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Rozłączyć z siecią <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Masz połączenie z siecią WEP. Jeśli zablokujesz te sieci, nastąpi rozłączenie."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opcje zaawansowane"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista Opcje zaawansowane"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"rozwiń"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Używać <xliff:g id="NEW_APP">%s</xliff:g> do zarządzania połączeniami sieciowymi?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Ostatnie prośby o lokalizację"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokalizacja dla profilu służbowego"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Dostęp do lokalizacji"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokalizacja jest wyłączona"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# z {total} aplikacji ma dostęp do lokalizacji}few{# z {total} aplikacji mają dostęp do lokalizacji}many{# z {total} aplikacji ma dostęp do lokalizacji}other{# z {total} aplikacji ma dostęp do lokalizacji}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Używaj klawiatury ekranowej"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Pozostaw na ekranie, gdy aktywna jest klawiatura fizyczna"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Klawisze zwrócone"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Klawiatura ignoruje szybkie naciśnięcia tego samego klawisza powtórzone w ciągu <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Powolne klawisze"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Zmienia czas wymagany do aktywacji naciśnięcia klawisza na <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Klawisze trwałe"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Naciśnij 1 klawisz, aby zyskać dostęp do skrótów, zamiast przytrzymywać kilka jednocześnie"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Skróty klawiszowe"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Lista skrótów"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Klawiatura i narzędzia w profilu służbowym"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Resetuj"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Wybierz klawisz modyfikujący"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Wybierz nowy klawisz jako <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Układ <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Domyślny"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automatyczny: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Wybrany przez użytkownika: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Mowa"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Szybkość wskaźnika"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Kontroler gier"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Możesz dostosować urządzenie do swoich potrzeb. Ułatwienia dostępu możesz zawsze zmienić w Ustawieniach."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Zmień rozmiar czcionki"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Czytnik ekranu"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opcje klawiatury fizycznej"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Napisy"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Dźwięk"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Ogólne"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Wyświetlacz"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Kolor i ruch"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kontrast kolorów"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Wyższy kontrast powoduje większe wyróżnienie tekstu, przycisków i ikon. Wybierz poziom kontrastu, który najbardziej Ci odpowiada."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Niektóre aplikacje mogą nie obsługiwać wszystkich ustawień kontrastu kolorów i tekstu"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Dostosuj wygląd kolorów i tekstu względem tła na ekranie"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Podgląd"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helena, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 dni temu"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Napisać ponownie?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Raport z podróży służbowej"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"W razie potrzeby proszę o kontakt \nze mną lub z Heleną. Ten raport zostanie"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Wydatki klienta"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Przyciemnij ekran"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Zarządzanie interakcjami"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Ustawienia czasowe"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Kontynuuj mimo to"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Anuluj"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Ustawienia powiększenia"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Powiększanie skrótem"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Powiększanie skrótem i trzykrotnym kliknięciem"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> – informacje"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Nieprzezroczyste"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst o dużym kontraście"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Zmień kolor tekstu na czarny lub biały. Spowoduje to ustawienie maksymalnego kontrastu względem tła."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Zmaksymalizuj kontrast tekstu"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Zmień kolor tekstu na czarny lub biały. Spowoduje to zwiększenie kontrastu względem tła."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automatyczna aktualizacja powiększenia ekranu"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Aktualizuj powiększenie ekranu przy zmianie aplikacji"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Przycisk zasilania kończy rozmowę"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Przytrzymaj przyciski głośności"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trzykrotnie kliknij ekran"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edytowanie skrótów ułatwień dostępu"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Wybierz skrót dla: %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Dalej"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Urządzenia słuchowe"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Skonfiguruj aparaty słuchowe, implanty ślimakowe i inne urządzenia wzmacniające dźwięk obsługujące technologię ASHA i LE Audio oraz zarządzaj nimi"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Brak połączonych urządzeń słuchowych"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Dodaj aparaty słuchowe"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Sparuj aparat słuchowy"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Zgodność z aparatem słuchowym"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Zwiększa zgodność z cewkami telefonicznymi i ogranicza niepożądany szum"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"O urządzeniach słuchowych"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Aby znaleźć inne urządzenia słuchowe, które nie obsługują technologii ASHA lub LE Audio, wybierz "<b>"Sparuj nowe urządzenie"</b>" &gt; "<b>"Zobacz więcej urządzeń"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Sparuj urządzenie słuchowe"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Na tej stronie możesz sparować urządzenia słuchowe ASHA i LE Audio. Sprawdź, czy urządzenie słuchowe jest włączone i gotowe do sparowania."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostępne urządzenia słuchowe"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS-y"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatyczne przełączanie danych"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Użyj mobilnej transmisji danych z dowolnej karty SIM w zależności od zasięgu i dostępności"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Tylko dane"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Skonfiguruj"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Dalej"</string>
@@ -4943,12 +4927,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomaga określić względne położenie urządzeń w pobliżu, które obsługują UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Aby użyć UWB, wyłącz tryb samolotowy"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Technologia UWB nie jest dostępna w tym miejscu"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Łącz się ze zgodnymi urządzeniami za pomocą protokołu Thread, aby móc wygodnie korzystać z funkcji inteligentnego domu"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Aby użyć Thread, wyłącz tryb samolotowy"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Dostęp do aparatu"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Dostęp do mikrofonu"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Dotyczy aplikacji i usług"</string>
@@ -5125,8 +5106,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Anuluj"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standardowy"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Domyślny"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Średni"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Wysoki"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ta aplikacja może być otwarta tylko w 1 oknie."</string>
diff --git a/res/values-pt-rBR/arrays.xml b/res/values-pt-rBR/arrays.xml
index 302e554..d3af579 100644
--- a/res/values-pt-rBR/arrays.xml
+++ b/res/values-pt-rBR/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tratar como limitada"</item>
     <item msgid="2047166446768045816">"Tratar como ilimitada"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Usar MAC aleatório (padrão)"</item>
-    <item msgid="741680937828608749">"Usar MAC do dispositivo"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Não"</item>
     <item msgid="2163015208097377388">"Sim"</item>
diff --git a/res/values-pt-rBR/strings.xml b/res/values-pt-rBR/strings.xml
index 9b9a4b0..1b75ea2 100644
--- a/res/values-pt-rBR/strings.xml
+++ b/res/values-pt-rBR/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Parear lado direito"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Parear lado esquerdo"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Para todos os aparelhos auditivos disponíveis"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Mais configurações para aparelhos auditivos"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Mude as configurações entre dispositivos, como atalhos e controles de telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Para este aparelho"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Saída de áudio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Sobre a saída de áudio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configurando o espaço particular…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Notificações de apps no espaço privado ficam ocultas quando ele está bloqueado"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Consulte as configurações do espaço privado para ocultá-lo e configurar o bloqueio automático"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Os apps necessários já estão instalados no seu espaço privado"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Não foi possível configurar um espaço privado"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Tentar de novo"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Usar o bloq. de tela p/ abrir o Espaço particular?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apps e notificações"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notificações sensíveis na tela de bloqueio"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Mostrar conteúdo sensível quando o espaço privado estiver desbloqueado"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Crie uma Conta do Google para ajudar a manter a privacidade dos seus dados"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na próxima tela, você pode fazer login em uma conta para usar com seu espaço privado"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Crie uma conta dedicada para ajudar a impedir que os dados apareçam fora do espaço privado, como:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Fotos, arquivos, e-mails, contatos, eventos da agenda e outros dados estão sincronizados"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Histórico e recomendações de download de apps"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Histórico de navegação, favoritos e senhas salvas"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Conteúdo sugerido relacionado à sua atividade em apps do espaço privado"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Entendi"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"É possível adicionar até <xliff:g id="COUNT">%d</xliff:g> digitais"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Você adicionou o número máximo de impressões digitais"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Não é possível adicionar mais impressões digitais"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Sua operadora não permite que você se conecte a esta rede porque ela usa um protocolo de segurança mais antigo e menos seguro"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permitir WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Fechar"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Desconectar de <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Você se conectou a uma rede WEP. Se bloquear essas redes, a conexão será perdida."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opções avançadas"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista suspensa \"Opções avançadas\""</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"abrir"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Usar <xliff:g id="NEW_APP">%s</xliff:g> para gerenciar suas conexões de rede?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitações recentes"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Local do perfil de trabalho"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Permissões de acesso ao local"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Localização desativada"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# app de {total} tem acesso à localização}one{# app de {total} tem acesso à localização}other{# apps de {total} têm acesso à localização}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Usar teclado na tela"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Manter na tela enquanto o teclado físico estiver ativo"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Teclas de filtro"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"O teclado ignora pressionamentos rápidos e repetidos da mesma tecla dentro de <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Teclas lentas"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajusta o tempo que leva para um pressionamento de tecla ser ativado para <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Teclas de aderência"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Pressione uma tecla por vez para usar atalhos em vez de manter as teclas pressionadas juntas"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Atalhos do teclado"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostrar lista de atalhos"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclados e ferramentas de perfil de trabalho"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Redefinir"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Escolher a tecla modificadora"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Escolha uma nova tecla para <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Layout do <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Padrão"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automático: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Usuário selecionado: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Fala"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Velocidade do cursor"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Controlador de jogos"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Você pode personalizar este dispositivo do jeito que quiser. Esses recursos de acessibilidade podem ser alterados depois nas Configurações."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Mudar o tamanho da fonte"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Leitor de tela"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opções de teclado físico"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Legendas"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Áudio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Geral"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Exibição"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Cor e movimento"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contraste de cor"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Um contraste mais alto faz com que o texto, os botões e os ícones se destaquem. Escolha o contraste mais adequado para você."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"É possível que alguns apps ainda não tenham suporte a todas as configurações de contraste de cor e texto"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ajuste a aparência das cores e do texto em relação à cor do plano de fundo"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Prévia"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"há 2 dias"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Acompanhar?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Relatório de viagem de negócios"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Entre em contato \ncomigo ou com a Helen para receber ajuda. Este relatório será"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Despesas de clientes"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Escurecer a tela"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Controles de interação"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Controles de marcação de tempo"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuar mesmo assim"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancelar"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Configurações de ampliação"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ampliar com atalho"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ampliar com atalho e toque triplo"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Não transparente"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texto em alto contraste"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mudar a cor do texto para preto ou branco. Maximiza o contraste com o plano de fundo."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximize o contraste do texto"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Mude a cor do texto para preto ou branco para aumentar o contraste com o plano de fundo"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Atual. autom. da ampliação da tela"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Atualiz. ampliação da tela em transições de aplic."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Botão liga/desliga encerra chamadas"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mantenha as teclas de volume pressionadas"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tocar na tela três vezes"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Editar atalhos de acessibilidade"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Escolha o atalho para %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Aparelhos auditivos"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configure e gerencie aparelhos auditivos ASHA e LE Audio, implantes cocleares e outros dispositivos de amplificação de som"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nenhum aparelho auditivo conectado"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Adicionar aparelhos auditivos"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Parear aparelhos auditivos"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilidade com aparelhos auditivos"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Melhora a compatibilidade com telecoils e reduz sons indesejados"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Sobre aparelhos auditivos"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Para encontrar outros aparelhos auditivos que não têm suporte de ASHA ou LE Audio, toque em "<b>"Parear novo dispositivo"</b>" &gt; "<b>"Mais dispositivos"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Parear aparelho auditivo"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Você pode parear aparelhos auditivos ASHA e LE Audio nesta página. Confira se o seu aparelho auditivo está ligado e pronto para parear."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Aparelhos auditivos disponíveis"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mensagens de texto"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Troca de dados automática"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Usar dados de qualquer chip dependendo da cobertura e disponibilidade"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Somente dados"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configurar"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Próxima"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Ajuda a identificar a posição relativa de dispositivos com UWB por perto"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desative o modo avião para usar a UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB indisponível no local atual"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Conecte-se a dispositivos compatíveis usando a rede Thread para ter uma ótima experiência de casa inteligente"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desative o modo avião para usar a rede Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Acesso à câmera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Acesso ao microfone"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Para apps e serviços"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Cancelar"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contraste"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Padrão"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Padrão"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Médio"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Alto"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Esse app só pode ser aberto em uma única janela"</string>
diff --git a/res/values-pt-rPT/arrays.xml b/res/values-pt-rPT/arrays.xml
index d2606cb..b5efffe 100644
--- a/res/values-pt-rPT/arrays.xml
+++ b/res/values-pt-rPT/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tratar como acesso limitado"</item>
     <item msgid="2047166446768045816">"Tratar como acesso ilimitado"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Usar MAC aleatório (predefinição)"</item>
-    <item msgid="741680937828608749">"Usar MAC do dispositivo"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Não"</item>
     <item msgid="2163015208097377388">"Sim"</item>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index 9c02c13..edb3101 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"A sua operadora não lhe permite ligar-se a esta rede porque usa um protocolo de segurança mais antigo que é menos seguro"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permitir WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Fechar"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Terminar a ligação a <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Tem ligação a uma rede WEP. Se bloquear estas redes, a ligação é terminada."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opções avançadas"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista pendente: Opções avançadas"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expandir"</string>
@@ -1542,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Usar <xliff:g id="NEW_APP">%s</xliff:g> para gerir as ligações de rede?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Pedidos de localização recentes"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Local. para perfil de trabalho"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Autorizações de localização das apps"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"A localização está desativada"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# de {total} apps tem acesso à localização}other{# de {total} apps têm acesso à localização}}"</string>
@@ -1875,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Usar o teclado no ecrã"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Manter no ecrã enquanto o teclado físico estiver ativo"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Teclas de rejeição"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"O teclado ignora os toques rápidos repetidos da mesma tecla no espaço de <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Teclas lentas"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajusta o tempo que demora a ativação de uma tecla premida para <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Teclas aderentes"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Prima uma tecla de cada vez para os atalhos em vez de manter as teclas premidas em simultâneo"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Atalhos de teclado"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostre a lista de atalhos"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclados e ferramentas do perfil de trabalho"</string>
@@ -1936,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Repor"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Escolha uma tecla de modificação"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Escolha uma nova tecla para <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Predefinição"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Voz"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Velocidade do ponteiro"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Controlador de Jogos"</string>
@@ -1992,8 +1995,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Pode personalizar este dispositivo de acordo com as suas necessidades. Pode alterar estas funcionalidades de acessibilidade mais tarde em Definições."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Alterar o tamanho do tipo de letra"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Leitor de ecrã"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opções do teclado físico"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Legendas"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Áudio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Geral"</string>
@@ -2059,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuar mesmo assim"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancelar"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Definições de ampliação"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Amplie com um atalho"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Amplie com um atalho e três toques"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Acerca de <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2243,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Manter premidas as teclas de volume."</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tocar três vezes no ecrã."</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Edite os atalhos de acessibilidade"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Escolha o atalho para %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Dispositivos auditivos"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configure e faça a gestão dos dispositivos auditivos ASHA e LE Audio, implantes cocleares e outros dispositivos de amplificação"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nenhum dispositivo auditivo ligado"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Adicione aparelhos auditivos"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Sincronizar aparelhos auditivos"</string>
@@ -2266,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilidade com aparelhos auditivos"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Melhora a compatibilidade com telebobinas e reduz o ruído indesejado"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Acerca de dispositivos auditivos"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Para encontrar outros dispositivos auditivos que não são suportados pelo ASHA ou LE Audio, toque em "<b>"Sincronizar novo dispositivo"</b>" &gt; "<b>"Veja mais dispositivos"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Sincronize disp. auditivo"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Pode sincronizar os dispositivos auditivos ASHA e LE Audio nesta página. Certifique-se de que o dispositivo auditivo está ativado e pronto para ser sincronizado."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Disp. auditivos disponíveis"</string>
@@ -3373,7 +3378,7 @@
     <string name="asst_capability_ranking_title" msgid="312998580233257581">"Classificação das notificações adaptável"</string>
     <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Classifique as notificações por relevância automaticamente."</string>
     <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Feedback sobre as notificações adaptáveis"</string>
-    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Indicar ajustes efetuados às notificações e mostrar a opção para fornecer feedback ao sistema"</string>
+    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Indicar ajustes efetuados às notificações e mostrar a opção para dar feedback ao sistema"</string>
     <string name="asst_importance_reset_title" msgid="6191265591976440115">"Repor a importância das notificações"</string>
     <string name="asst_importance_reset_summary" msgid="684794589254282667">"Reponha as definições de importância alteradas pelo utilizador e permita que o assistente de notificações defina prioridades."</string>
     <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Respostas e ações sugeridas"</string>
@@ -4639,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mensagens de texto"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Comutação automática de dados"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Use dados de qualquer um dos SIMs, consoante a cobertura e a disponibilidade"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Apenas de dados"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configurar"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Seguinte"</string>
@@ -4917,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Ajuda a identificar a posição relativa de dispositivos próximos com UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desative o modo de avião para utilizar UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"A UWB (banda ultralarga) está indisponível na localização atual"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Ligue-se a dispositivos compatíveis usando o Thread para uma experiência de casa inteligente sem falhas"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desative o modo de avião para usar o Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Acesso à câmara"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Acesso ao microfone"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Para apps e serviços"</string>
diff --git a/res/values-pt/arrays.xml b/res/values-pt/arrays.xml
index 302e554..d3af579 100644
--- a/res/values-pt/arrays.xml
+++ b/res/values-pt/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tratar como limitada"</item>
     <item msgid="2047166446768045816">"Tratar como ilimitada"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Usar MAC aleatório (padrão)"</item>
-    <item msgid="741680937828608749">"Usar MAC do dispositivo"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Não"</item>
     <item msgid="2163015208097377388">"Sim"</item>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index 9b9a4b0..1b75ea2 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Parear lado direito"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Parear lado esquerdo"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Para todos os aparelhos auditivos disponíveis"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Mais configurações para aparelhos auditivos"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Mude as configurações entre dispositivos, como atalhos e controles de telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Para este aparelho"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Saída de áudio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Sobre a saída de áudio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configurando o espaço particular…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Notificações de apps no espaço privado ficam ocultas quando ele está bloqueado"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Consulte as configurações do espaço privado para ocultá-lo e configurar o bloqueio automático"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Os apps necessários já estão instalados no seu espaço privado"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Não foi possível configurar um espaço privado"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Tentar de novo"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Usar o bloq. de tela p/ abrir o Espaço particular?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apps e notificações"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notificações sensíveis na tela de bloqueio"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Mostrar conteúdo sensível quando o espaço privado estiver desbloqueado"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Crie uma Conta do Google para ajudar a manter a privacidade dos seus dados"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na próxima tela, você pode fazer login em uma conta para usar com seu espaço privado"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Crie uma conta dedicada para ajudar a impedir que os dados apareçam fora do espaço privado, como:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Fotos, arquivos, e-mails, contatos, eventos da agenda e outros dados estão sincronizados"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Histórico e recomendações de download de apps"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Histórico de navegação, favoritos e senhas salvas"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Conteúdo sugerido relacionado à sua atividade em apps do espaço privado"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Entendi"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"É possível adicionar até <xliff:g id="COUNT">%d</xliff:g> digitais"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Você adicionou o número máximo de impressões digitais"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Não é possível adicionar mais impressões digitais"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Sua operadora não permite que você se conecte a esta rede porque ela usa um protocolo de segurança mais antigo e menos seguro"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permitir WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Fechar"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Desconectar de <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Você se conectou a uma rede WEP. Se bloquear essas redes, a conexão será perdida."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opções avançadas"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista suspensa \"Opções avançadas\""</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"abrir"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Usar <xliff:g id="NEW_APP">%s</xliff:g> para gerenciar suas conexões de rede?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitações recentes"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Local do perfil de trabalho"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Permissões de acesso ao local"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Localização desativada"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# app de {total} tem acesso à localização}one{# app de {total} tem acesso à localização}other{# apps de {total} têm acesso à localização}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Usar teclado na tela"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Manter na tela enquanto o teclado físico estiver ativo"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Teclas de filtro"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"O teclado ignora pressionamentos rápidos e repetidos da mesma tecla dentro de <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Teclas lentas"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajusta o tempo que leva para um pressionamento de tecla ser ativado para <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Teclas de aderência"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Pressione uma tecla por vez para usar atalhos em vez de manter as teclas pressionadas juntas"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Atalhos do teclado"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostrar lista de atalhos"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclados e ferramentas de perfil de trabalho"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Redefinir"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Escolher a tecla modificadora"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Escolha uma nova tecla para <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Layout do <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Padrão"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automático: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Usuário selecionado: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Fala"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Velocidade do cursor"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Controlador de jogos"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Você pode personalizar este dispositivo do jeito que quiser. Esses recursos de acessibilidade podem ser alterados depois nas Configurações."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Mudar o tamanho da fonte"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Leitor de tela"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opções de teclado físico"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Legendas"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Áudio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Geral"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Exibição"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Cor e movimento"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contraste de cor"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Um contraste mais alto faz com que o texto, os botões e os ícones se destaquem. Escolha o contraste mais adequado para você."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"É possível que alguns apps ainda não tenham suporte a todas as configurações de contraste de cor e texto"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ajuste a aparência das cores e do texto em relação à cor do plano de fundo"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Prévia"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"há 2 dias"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Acompanhar?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Relatório de viagem de negócios"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Entre em contato \ncomigo ou com a Helen para receber ajuda. Este relatório será"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Despesas de clientes"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Escurecer a tela"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Controles de interação"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Controles de marcação de tempo"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuar mesmo assim"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancelar"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Configurações de ampliação"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ampliar com atalho"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ampliar com atalho e toque triplo"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Não transparente"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texto em alto contraste"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mudar a cor do texto para preto ou branco. Maximiza o contraste com o plano de fundo."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximize o contraste do texto"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Mude a cor do texto para preto ou branco para aumentar o contraste com o plano de fundo"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Atual. autom. da ampliação da tela"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Atualiz. ampliação da tela em transições de aplic."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Botão liga/desliga encerra chamadas"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mantenha as teclas de volume pressionadas"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tocar na tela três vezes"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Editar atalhos de acessibilidade"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Escolha o atalho para %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Aparelhos auditivos"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configure e gerencie aparelhos auditivos ASHA e LE Audio, implantes cocleares e outros dispositivos de amplificação de som"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nenhum aparelho auditivo conectado"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Adicionar aparelhos auditivos"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Parear aparelhos auditivos"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilidade com aparelhos auditivos"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Melhora a compatibilidade com telecoils e reduz sons indesejados"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Sobre aparelhos auditivos"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Para encontrar outros aparelhos auditivos que não têm suporte de ASHA ou LE Audio, toque em "<b>"Parear novo dispositivo"</b>" &gt; "<b>"Mais dispositivos"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Parear aparelho auditivo"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Você pode parear aparelhos auditivos ASHA e LE Audio nesta página. Confira se o seu aparelho auditivo está ligado e pronto para parear."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Aparelhos auditivos disponíveis"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mensagens de texto"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Troca de dados automática"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Usar dados de qualquer chip dependendo da cobertura e disponibilidade"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Somente dados"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configurar"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Próxima"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Ajuda a identificar a posição relativa de dispositivos com UWB por perto"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desative o modo avião para usar a UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB indisponível no local atual"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Conecte-se a dispositivos compatíveis usando a rede Thread para ter uma ótima experiência de casa inteligente"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desative o modo avião para usar a rede Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Acesso à câmera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Acesso ao microfone"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Para apps e serviços"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Cancelar"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contraste"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Padrão"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Padrão"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Médio"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Alto"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Esse app só pode ser aberto em uma única janela"</string>
diff --git a/res/values-ro/arrays.xml b/res/values-ro/arrays.xml
index b44dfcd..a9b90a2 100644
--- a/res/values-ro/arrays.xml
+++ b/res/values-ro/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tratează ca fiind contorizată"</item>
     <item msgid="2047166446768045816">"Tratează ca fiind necontorizată"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Folosește o adresă MAC aleatorie (prestabilit)"</item>
-    <item msgid="741680937828608749">"Folosește adresa MAC a dispozitivului"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nu"</item>
     <item msgid="2163015208097377388">"Da"</item>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 266675f..ac08c73 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Asociază urechea dreaptă"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Asociază urechea stângă"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Pentru toate aparatele auditive disponibile"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Mai multe setări pentru aparate auditive"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Modifică setările pe mai multe dispozitive, de exemplu, comenzile rapide și comenzile pentru bobina cu inducție"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Pentru acest dispozitiv"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Ieșire audio"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Despre ieșirea audio"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Se configurează spațiul privat…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Notificările de la aplicațiile din spațiul privat sunt ascunse atunci când acesta este blocat"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Explorează setările spațiului privat pentru a ascunde spațiul privat și a configura blocarea automată"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Aplicațiile obligatorii au fost deja instalate în spațiul privat"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Nu s-a putut configura un spațiu privat"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Încearcă din nou"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Folosești blocarea ecranului pentru a debloca spațiul privat?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplicații și notificări"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Notificările privind conținutul sensibil de pe ecranul de blocare"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Afișează conținut sensibil atunci când spațiul privat este deblocat"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Creează un Cont Google pentru a-ți păstra datele private"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Pe următorul ecran, poți să te conectezi la un cont pe care să-l folosești cu spațiul privat"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Creează un cont dedicat pentru a împiedica datele să apară în afara spațiului privat, de exemplu:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Fotografii, fișiere, e-mailuri, agenda, evenimente din calendar și alte date sincronizate"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Istoricul descărcărilor de aplicații și recomandări"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Istoricul de navigare, marcaje și parole salvate"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Conținut sugerat care are legătură cu activitatea ta în aplicațiile din spațiul privat"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Poți să adaugi până la <xliff:g id="COUNT">%d</xliff:g> amprente"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Ai adăugat numărul maxim de amprente digitale"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nu se mai pot adăuga amprente digitale"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operatorul nu îți dă voie să te conectezi la această rețea, deoarece ea folosește un protocol de securitate mai vechi și mai puțin sigur"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permite rețelele WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Închide"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Te deconectezi de la <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Te-ai conectat la o rețea WEP. Dacă blochezi aceste rețele, te vei deconecta."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opțiuni avansate"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista drop-down Opțiuni avansate"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"extindeți"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Folosești <xliff:g id="NEW_APP">%s</xliff:g> pentru a gestiona conexiunile la rețea?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitări recente ale locației"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Locație pt. profil de serviciu"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Permisiuni pentru locație"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Locația este dezactivată"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# din {total} aplicații are acces la locație}few{# din {total} aplicații au acces la locație}other{# din {total} de aplicații au acces la locație}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Folosește tastatura pe ecran"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Se păstrează pe ecran cât timp este activată tastatura fizică"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Taste de ieșire imediată"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tastatura ignoră apăsările repetate rapid ale aceleiași taste în <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Taste lente"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajustează timpul necesar pentru ca o apăsare de tastă să se activeze la <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Taste adezive"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Apasă câte o tastă pentru comenzile rapide în loc să ții apăsate tastele împreună"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Comenzi rapide de la tastatură"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Afișează lista de comenzi rapide"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastaturi și instrumente pt. profilul de serviciu"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Resetează"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Alege tasta de modificare"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Alege o nouă tastă pentru <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Prestabilit"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Voce"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Viteza indicatorului"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Controler de joc"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Poți personaliza acest dispozitiv conform nevoilor tale. Aceste funcții de accesibilitate pot fi modificate ulterior în setări."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Modifică dimensiunea fontului"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Cititor de ecran"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opțiuni pentru tastatura fizică"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Subtitrări"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"General"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Afișaj"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Culoare și mișcare"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contrastul culorilor"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Contrastul mai înalt scoate în evidență textul, butoanele și pictogramele. Alege contrastul care ți se pare cel mai potrivit."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Este posibil ca unele aplicații să nu accepte toate setările pentru contrastul culorilor și al textului"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ajustează felul în care arată culorile și textul peste culoarea de fundal a ecranului"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Previzualizează"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Elena, Andrei"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Acum 2 zile"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Urmărești?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Raport – călătoria de afaceri"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Pentru asistență suplimentară, contactează-ne pe \nmine sau pe Elena. Acest raport va fi"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Cheltuielile clientului"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Redu luminozitatea ecranului"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Comenzi pentru interacțiune"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Comenzi de sincronizare"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuă oricum"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Anulează"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Setări pentru mărire"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Mărește folosind scurtătura"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Mărește folosind scurtătura și atingând de trei ori"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Despre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Netransparent"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text cu contrast ridicat"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Schimbă culoarea textului în negru sau alb. Astfel, se maximizează contrastul cu fundalul."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximizează contrastul textului"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Schimbă culoarea textului în negru sau alb pentru a crește contrastul dintre acesta și fundal."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Actualiz. automat mărirea ecranului"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Actualiz. mărirea ecran. la tranziția între aplic."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Butonul de pornire închide"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Apasă lung butoanele de volum"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Atinge ecranul de trei ori"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Editează comenzile rapide de accesibilitate"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Alege comanda rapidă pentru %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuă"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Aparate auditive"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configurează și gestionează aparatele auditive ASHA și LE Audio, implanturile cohleare și alte dispozitive de amplificare"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Niciun aparat auditiv conectat"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Adaugă aparate auditive"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Asociază aparatele auditive"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilitate cu aparatele auditive"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Îmbunătățește compatibilitatea cu bobinele cu inducție și reduce zgomotul nedorit"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Despre dispozitivele auditive"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Ca să găsești alte aparate auditive care nu sunt acceptate de ASHA sau LE Audio, atinge "<b>"Asociază un nou dispozitiv"</b>" &gt; "<b>"Vezi mai multe dispozitive"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Asociază aparatul auditiv"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Poți să asociezi aparate auditive ASHA și LE Audio din această pagină. Verifică dacă aparatul auditiv este pornit și gata de asociat."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Aparate auditive disponibile"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mesaje text"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Comutarea automată a datelor"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Folosește date de pe orice card SIM, în funcție de acoperire și de disponibilitate"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Numai pentru date"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configurează"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Înainte"</string>
@@ -4942,12 +4929,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Identifică poziția relativă a dispozitivelor din apropiere care au UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Dezactivează modul Avion pentru a folosi UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Tehnologia UWB nu este disponibilă în locația actuală"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Conectează-te la dispozitivele compatibile folosind Thread pentru o experiență fluidă cu casa inteligentă"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Dezactivează modul Avion pentru a folosi Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Acces la cameră"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Acces la microfon"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Pentru aplicații și servicii"</string>
@@ -5124,8 +5108,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Anulează"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Prestabilit"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Mediu"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Ridicat"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Aplicația se poate deschide într-o singură fereastră"</string>
diff --git a/res/values-ru/arrays.xml b/res/values-ru/arrays.xml
index 869ce51..dd79b82 100644
--- a/res/values-ru/arrays.xml
+++ b/res/values-ru/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"С тарификацией"</item>
     <item msgid="2047166446768045816">"Без тарификации"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Случайный MAC-адрес (по умолчанию)"</item>
-    <item msgid="741680937828608749">"MAC-адрес устройства"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Нет"</item>
     <item msgid="2163015208097377388">"Да"</item>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 61d3724..2fcb7b6 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Подключить прав. ухо"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Подключить левое ухо"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"На всех доступных слуховых аппаратах"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Другие настройки слухового аппарата"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Измените параметры телекатушки и настройки для нескольких устройств, например ярлыки"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"На этом устройстве"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аудиовыход"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"О выводе звука"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Создание личного пространства…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Когда личное пространство заблокировано, уведомления из добавленных в него приложений скрываются"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"В параметрах личного пространства можно скрыть его и настроить автоматическую блокировку"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"В вашем личном пространстве уже установлены нужные приложения"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Не удалось создать личное пространство"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Повторить попытку"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Использовать способ, настроенный для экрана?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Приложения и уведомления"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Уведомления с конфиденциальными данными на заблокированном экране"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Показывать конфиденциальные данные, когда личное пространство разблокировано"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Создайте аккаунт Google для защиты своих данных"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"На следующем экране вы сможете войти в аккаунт, чтобы использовать его в личном пространстве."</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Создайте отдельный аккаунт, чтобы данные не появлялись вне вашего личного пространства:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Синхронизированные фотографии, файлы, письма, контакты, мероприятия и другие данные."</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Рекомендации и история скачанных приложений."</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"История браузера, закладки и сохраненные пароли."</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Контент, рекомендованный с учетом ваших действий в приложениях из личного пространства."</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"ОК"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Максимальное количество отпечатков пальца, которые можно добавить: <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Вы уже добавили максимальное количество отпечатков"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Больше нельзя добавить отпечатки пальцев"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Ваш оператор запрещает подключаться к этой сети, поскольку она использует устаревший протокол безопасности с низким уровнем защиты."</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Разрешить сети с WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Закрыть"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Отключиться от сети \"<xliff:g id="NAME">%1$s</xliff:g>\"?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Вы подключились к сети WEP. Если такие сети заблокировать, подключение будет потеряно."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Расширенные настройки"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Раскрывающийся список расширенных настроек"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"развернуть"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Использовать приложение \"<xliff:g id="NEW_APP">%s</xliff:g>\" для управления сетевыми подключениями?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Последние запросы местоположения"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Геоданные для рабочего профиля"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Доступ приложений к геоданным"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Доступ к геоданным отключен"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# приложение из {total} имеет доступ к данным о местоположении}one{# приложение из {total} имеет доступ к данным о местоположении}few{# приложения из {total} имеют доступ к данным о местоположении}many{# приложений из {total} имеют доступ к данным о местоположении}other{# приложения из {total} имеют доступ к данным о местоположении}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Использовать экранную клавиатуру"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Не скрывать экранную клавиатуру, когда включена физическая"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Контроль повторного нажатия"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Повторные нажатия одной клавиши в течение <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> мс игнорируются"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Медленные клавиши"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Нажатие клавиши регистрируется по истечении заданного времени: <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> мс"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Залипание клавиш"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Вместо того чтобы удерживать вместе все клавиши из сочетания, нажимайте их по одной"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Быстрые клавиши"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Показывать список сочетаний клавиш"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Клавиатуры и инструменты рабочего профиля"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Сбросить"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Выбор клавиши-модификатора"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Выберите новую клавишу для <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"По умолчанию"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Речь"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Скорость указателя"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Игровые контроллеры"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Используйте специальные возможности для удобной работы с устройством. Эти параметры можно изменить в настройках."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Изменить размер шрифта"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Программа чтения с экрана"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Настройки физической клавиатуры"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Субтитры"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Аудио"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Общие"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Экран"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Цвет и движение"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Цветовая контрастность"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Настройте контрастность. Чем она выше, тем заметнее текст, кнопки и значки."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Некоторые настройки контрастности цвета и текста поддерживаются не во всех приложениях."</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Сделайте цвета и текст заметнее на экране"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Предпросмотр"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Елена, Адам"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 дня назад"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Есть вопросы?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Отчет о командировке"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Если у вас остались вопросы, напишите мне или Елене.\n Этот отчет будет"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Расходы клиента"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Уменьшение яркости экрана"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Элементы управления"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Настройка времени задержки"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Продолжить"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Отмена"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Настройки увеличения"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Увеличение с помощью кнопки"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Увеличение с помощью кнопки и по тройному нажатию"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"О функции \"<xliff:g id="SERVICE">%1$s</xliff:g>\""</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Непрозрачная"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Контрастный текст"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Изменить цвет текста на черный или белый, чтобы сделать его максимально заметным"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Максимальная контрастность текста"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Измените цвет текста на черный или белый, чтобы сделать его заметнее."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Сохранять масштаб"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Сохранять масштаб при переходе между приложениями"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Кнопка питания завершает вызов"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Удерживать кнопки регулировки громкости"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Тройное нажатие на экран"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Настройки быстрого включения специальных возможностей"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Выберите сочетание клавиш для функции \"%1$s\""</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Далее"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Слуховые аппараты"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Управляйте слуховыми аппаратами ASHA и LE Audio, кохлеарными имплантатами и другими устройствами усиления звука"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Слуховые аппараты не подключены"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Добавить слуховой аппарат"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Подключите аппараты"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Поддержка слуховых аппаратов"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Улучшить совместимость со слуховыми аппаратами и уменьшить нежелательный шум"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"О слуховых аппаратах"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Чтобы найти другие слуховые аппараты, которые не поддерживают технологию ASHA или LE Audio, нажмите "<b>"Добавить устройство"</b>" &gt; "<b>"Другие устройства"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Подключение аппарата"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"На этой странице вы можете подключить слуховые устройства ASHA и LE Audio. Убедитесь, что ваш слуховой аппарат работает и готов к подключению."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Доступные слуховые аппараты"</string>
@@ -3437,7 +3418,7 @@
     <string name="notification_pulse_title" msgid="8013178454646671529">"Световая индикация"</string>
     <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Конфиденциаль­ность"</string>
     <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Пропуск заблок. экрана"</string>
-    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"После разблокировки перейдите к последнему открытому экрану. На заблокированном экране уведомления не показываются. Для их просмотра проведите вниз."</string>
+    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"После разблокировки переходить к последнему открытому экрану. На заблокированном экране уведомления не показываются. Для их просмотра проведите вниз."</string>
     <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Заблокированный экран, пропустить, перейти"</string>
     <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Когда рабочий профиль заблокирован"</string>
     <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Только новые уведомления на заблокированном экране"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Текстовые сообщения"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Автопереключение моб. трафика"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Используйте мобильный трафик любой SIM-карты в зависимости от покрытия и доступности."</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Только доступ к интернету"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Настроить"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Далее"</string>
@@ -4943,12 +4930,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Помогает определить относительное местоположение устройств с технологией сверхширокополосной связи поблизости"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Выключает режим полета, чтобы использовать сверхширокополосную связь"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Сверхширокополосная связь недоступна в вашем регионе"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Подключайтесь к совместимым устройствам умного дома по сети Thread"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Чтобы использовать сеть Thread, отключите режим полета"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Доступ к камере"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Доступ к микрофону"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Для приложений и сервисов"</string>
@@ -5125,8 +5109,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Отмена"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Контрастность"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Стандартная"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"По умолчанию"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Средняя"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Высокая"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Это приложение можно открыть только в одном окне."</string>
diff --git a/res/values-si/arrays.xml b/res/values-si/arrays.xml
index 7601af6..39feb72 100644
--- a/res/values-si/arrays.xml
+++ b/res/values-si/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"මනින ලද ලෙස සලකන්න"</item>
     <item msgid="2047166446768045816">"නොමනින ලද ලෙස සලකන්න"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"අහඹු කළ MAC භාවිත කරන්න (පෙරනිමි)"</item>
-    <item msgid="741680937828608749">"MAC උපාංගය භාවිත කරන්න"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"නැත"</item>
     <item msgid="2163015208097377388">"ඔව්"</item>
diff --git a/res/values-si/strings.xml b/res/values-si/strings.xml
index f117684..9980963 100644
--- a/res/values-si/strings.xml
+++ b/res/values-si/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"දකුණු කණ යුගල කරන්න"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"වම් කණ යුගල කරන්න"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"පවතින සියලු ශ්‍රවණ උපාංග සඳහා"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"තවත් ශ්‍රවණ උපකරණ සැකසීම්"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"කෙටිමං, සහ ටෙලිකොයිල් පාලන වැනි හරස් උපාංග සැකසීම් වෙනස් කරන්න"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"මෙම උපාංගය සඳහා"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ශබ්ද ප්‍රතිදානය"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ශ්‍රව්‍ය ප්‍රතිදානය පිළිබඳව"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"පෞද්ගලික අවකාශය පිහිටුවමින්…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"පුද්ගලික අවකාශය අගුලු දමා ඇති විට ඒ වෙතින් එන දැනුම් දීම් සැඟවී ඇත"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"රහසිගත අවකාශය සැඟවීමට සහ ස්වයංක්‍රීය අගුලු දැමීම සැකසීමට රහසිගත අවකාශ සැකසීම් ගවේෂණය කරන්න"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"අවශ්‍ය වූ යෙදුම් දැනටමත් ඔබේ රහසිගත අවකාශයේ ස්ථාපනය කර ඇත"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"පුද්ගලික අවකාශයක් සැකසීමට නොහැකි විය"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"නැවත උත්සාහ කරන්න"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"පෞද්ගලික අවකාශය අගුළු හැරීමට තිර අගුල භාවිතා කරන්න ද?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"යෙදුම් සහ දැනුම්දීම්"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"අගුළු තිරය මත සංවේදී දැනුම්දීම්"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"රහසිගත අවකාශය අගුළු හරින ලද විට සංවේදී අන්තර්ගතය පෙන්වන්න"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"ඔබේ දත්ත පෞද්ගලිකව තබා ගැනීමට උදවු කිරීමට Google ගිණුමක් සාදන්න"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"මීළඟ තිරයේ ඔබට ඔබේ රහසිගත අවකාශය සමග භාවිත කිරීමට ගිණුමකට පුරනය විය හැක"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"රහසිගත අවකාශයෙන් පිටත දත්ත දිස්වීම නැවැත්වීමට උදවු කිරීමට කැපවූ ගිණුමක් සාදන්න, එනම්:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"සමමුහුර්ත කළ ඡායාරූප, ගොනු, ඉ-තැපැල්, සම්බන්ධතා, දින දර්ශන සිදුවීම් සහ වෙනත් දත්ත"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"යෙදුම් බාගැනීම් ඉතිහාසය සහ නිර්දේශ"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"බ්‍රවුස් කිරීමේ ඉතිහාසය, පිටුසන් සහ සුරකින ලද මුරපද"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"රහසිගත අවකාශ යෙදුම්වල ඔබේ ක්‍රියාකාරකම්වලට අදාළ යෝජිත අන්තර්ගතය"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"තේරුණා"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"ඔබට ඇඟිලි සලකුණු <xliff:g id="COUNT">%d</xliff:g> දක්වා එකතු කළ හැකිය"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"ඔබ ඇඟිලි සලකුණු උපරිම සංඛ්‍යාව එක් කර ඇත"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"තවත් ඇඟිලි සලකුණු එක් කළ නොහැකිය"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"ඔබේ වාහකයා ඔබට මෙම ජාලයට සම්බන්ධ වීමට ඉඩ නොදෙන්නේ එය අඩුවෙන් සුරක්ෂිත පැරණි ආරක්ෂක ප්‍රොටෝකෝලයක් භාවිතා කරන බැවිනි"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP ඉඩ දෙන්න"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"වසන්න"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> වෙතින් විසන්ධි කරන්නේ ද?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"ඔබ WEP ජාලයකට සම්බන්ධ වී ඇත. ඔබ මෙම ජාල අවහිර කරන්නේ නම්, ඔබ විසන්ධි වනු ඇත."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"උසස් විකල්ප"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"පතන ලැයිස්තු උසස් විකල්ප"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"දිග හරින්න"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"ඔබගේ ජාල සම්බන්ධතා කළමනාකරණය කිරීමට <xliff:g id="NEW_APP">%s</xliff:g> භාවිතා කරන්නද?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"මෑත කාලීන ස්ථාන ඉල්ලීම්"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"කාර්යාල පැතිකඩ සඳහා ස්ථානය"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"යෙදුම් ස්ථාන අවසර"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"ස්ථානය ක්‍රියාවිරහිතයි"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{යෙදුම් {total}න් #කට ස්ථානයට ප්‍රවේශය ඇත}one{යෙදුම් {total}න් #කට ස්ථානයට ප්‍රවේශය ඇත}other{යෙදුම් {total}න් #කට ස්ථානයට ප්‍රවේශය ඇත}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"තිරය මත යතුරු පුවරුව භාවිත කරන්න"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"භෞතික යතුරු පුවරුව සක්‍රිය අතරතුර එය තිරය මත තබා ගන්න"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"පනින යතුරු"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"යතුරුපුවරුව <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms ඇතුළත එකම යතුර නැවත නැවතත් එබීම් නොසලකා හරියි"</string>
     <string name="slow_keys" msgid="2891452895499690837">"මන්දගාමී යතුරු"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"යතුරු එබීම සඳහා ගතවන කාලය <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms දක්වා සකසයි"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ඇලෙන යතුරු"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"කෙටිමං සඳහා යතුරු එකට තබා ගැනීම වෙනුවට වරකට යතුරක් ඔබන්න"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"යතුරු පුවරු කෙටිමං"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"කෙටිමං ලැයිස්තුව පෙන්වන්න"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"කාර්යාල පැතිකඩ යතුරු පුවරු සහ මෙවලම්"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"යළි සකසන්න"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"සංස්කාරක යතුර තෝරා ගන්න"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> සඳහා නව යතුරක් තෝරා ගන්න:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"පෙරනිමි"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"කථනය"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"දර්ශක වේගය"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"ක්‍රීඩා පාලකය"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"ඔබට ඔබේ අවශ්‍යතාවන්ට ගැළපෙන පරිදි මෙම උපාංගය අභිරුචිකරණය කළ හැකිය. මෙම ප්‍රවේශ්‍යතා විශේෂාංග සැකසීම්වල පසුව වෙනස් කළ හැකිය."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ෆොන්ට තරම වෙනස් කරන්න"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"තිර කියවනය"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"භෞතික යතුරුපුවරු විකල්ප"</string>
     <string name="captions_category_title" msgid="574490148949400274">"සිරස්තල"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ශ්‍රව්‍ය"</string>
     <string name="general_category_title" msgid="6298579528716834157">"පොදු"</string>
     <string name="display_category_title" msgid="6638191682294461408">"සංදර්ශකය"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"වර්ණය සහ චලනය"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"වර්ණ අසමානතාව"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"ඉහළ අසමානතාව පෙළ, බොත්තම් සහ අයිකන වඩාත් කැපී පෙනෙන ලෙස සකසයි. ඔබට වඩාත්ම හොඳ යැයි හැඟෙන අසමානතාව තෝරන්න."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"සමහර යෙදුම් සියලු වර්ණ සහ පෙළ අසමානතා සැකසීම් සඳහා සහාය නොදක්වයි"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"ඔබේ තිරයේ පසුබිම් වර්ණයට එරෙහිව වර්ණ සහ පෙළ පෙනෙන ආකාරය සකසන්න"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"පෙරදසුන"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"හෙලන්, ඇඩම්"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"දින 2කට පෙර"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"පසු විපරම් කරන්න ද?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"ව්‍යාපාරික සංචාර වාර්තාව"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"වැඩිදුර සහාය සඳහා, \nමා හෝ හෙලන් වෙත සම්බන්ධ වන්න. මෙම වාර්තාව වනු ඇත්තේ"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"සේවාලාභීයාගේ වියදම්"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"තිරය අඳුරු කිරීම ක්‍රියාත්මක කිරීම"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"අන්තර්ක්‍රියා පාලන"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"කාල නියාමන පාලන"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"කෙසේ වෙතත් ඉදිරියට යන්න"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"අවලංගු කරන්න"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"විශාලන සැකසීම්"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"කෙටිමඟ සමඟ විශාලන කරන්න"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"කෙටිමඟ සහ තට්ටු කිරීම් තුනක් සමඟ විශාලන කරන්න"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> පිළිබඳ"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"පාරදෘශ්‍ය නොවන"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ඉහළම වෙනසක් ඇති පෙළ"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"පෙළ වර්ණය කළු හෝ සුදු ලෙස වෙනස් කරන්න. පසුබිම සමඟ වෙනස උපරිම කරයි."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"පෙළ අසමානතාව උපරිම කරන්න"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"පසුබිම සමග අසමානතාව වැඩි කිරීමට පෙළ වර්ණය කළු හෝ සුදු ලෙස වෙනස් කරන්න."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"තිර විශාලනය ස්වයංක්‍රීයව යාවත්කාලීන කරන්න"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"යෙදුම් සංක්‍රමණයේදී තිර විශාලනය යාවත්කාලීන කරන්න"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"බල බොත්තම ඇමතුම අවසන් කරයි"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"හඬ පරිමා යතුරු අල්ලාගන්න"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"තිරය තෙවරක් තට්ටු කරන්න"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ප්‍රවේශ්‍යතා කෙටිමං සංස්කරණය කරන්න"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s සඳහා ඔබේ කෙටිමඟ තෝරා ගන්න"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ඉදිරියට යන්න"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"ශ්‍රවණ උපාංග"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA සහ LE ශ්‍රව්‍ය ශ්‍රවණාධාර, දර්වාකාර බද්ධ කිරීම්, සහ අනෙකුත් විස්තාරණ උපාංග පිහිටුවීම සහ කළමනාකරණය කිරීම"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"ශ්‍රවණ උපාංග සම්බන්ධ නැත"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"ශ්‍රවණාධාරක එක් කරන්න"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"ශ්‍රවණාධාරක යුගල කරන්න"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"ශ්‍රවණාධාරක අනුකූලත්වය"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ටෙලිකොයිල් සමග ගැළපෙන බව වැඩි දියුණු කරන අතර අනවශ්‍ය ශබ්දය අඩු කරයි"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"ශ්‍රවණ උපාංග පිළිබඳව"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA හෝ LE Audio මගින් සහාය නොදක්වන වෙනත් ශ්‍රවණ උපාංග සොයා ගැනීමට, "<b>"නව උපාංගය යුගල කරන්න"</b>" &gt; "<b>"තවත් උපාංග බලන්න"</b>" තට්ටු කරන්න"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"ශ්‍රවණ උපාංගය යුගල කරන්න"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ඔබට මෙම පිටුවෙහි ASHA සහ LE ශ්‍රව්‍ය ශ්‍රවණ උපකරණ යුගල කළ හැක. ඔබේ ශ්‍රවණ උපකරණය ක්‍රියාත්මක කර යුගල කිරීමට සූදානම් බව සහතික කර ගන්න"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"ලබා ගත හැකි ශ්‍රවණ උපාංග"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"පෙළ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ස්වයංක්‍රීය දත්ත මාරු කිරීම"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"ආවරණය සහ ලබා ගැනීමේ හැකියාව මත පදනම්ව කිනම් හෝ SIM එකකින් දත්ත භාවිතා කරන්න"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"දත්ත පමණි"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"පිහිටුවන්න"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"මීළඟ"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWB ඇති අවට උපාංගවල සාපේක්ෂ පිහිටීම හඳුනා ගැනීමට උපකාරී වේ"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB භාවිත කිරීමට ගුවන් යානා ප්‍රකාරය ක්‍රියාවිරහිත කරන්න"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB වත්මන් ස්ථානයේ නොමැත"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"පොට"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"බාධාවකින් තොරව ස්මාර්ට් නිවාස අත්දැකීමක් සඳහා පොට භාවිතයෙන් ගැළපෙන උපාංග වෙත සම්බන්ධ වන්න"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"පොට භාවිත කිරීමට ගුවන් යානා ප්‍රකාරය ක්‍රියාවිරහිත කරන්න"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"කැමරා ප්‍රවේශය"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"මයික්‍රෆෝන ප්‍රවේශය"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"යෙදුම් සහ සේවා සඳහා"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"අවලංගු කරන්න"</string>
     <string name="contrast_title" msgid="6885768151336508075">"අසමානතාව"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"සම්මත"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"පෙරනිමි"</string>
     <string name="contrast_medium" msgid="384414510709285811">"මධ්‍යම"</string>
     <string name="contrast_high" msgid="3988567609694797696">"ඉහළ"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"මෙම යෙදුම විවෘත කළ හැක්කේ 1 කවුළුවක පමණයි"</string>
diff --git a/res/values-sk/arrays.xml b/res/values-sk/arrays.xml
index cfd3db8..48e13d6 100644
--- a/res/values-sk/arrays.xml
+++ b/res/values-sk/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Považovať za meranú sieť"</item>
     <item msgid="2047166446768045816">"Považovať za nemeranú sieť"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Náhodná adresa MAC (predvol.)"</item>
-    <item msgid="741680937828608749">"Používať adresu MAC zariadenia"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nie"</item>
     <item msgid="2163015208097377388">"Áno"</item>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index 2727ed7..6dc0e22 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Spárovať pravé ucho"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Spárovať ľavé ucho"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Pre všetky dostupné načúvadlá"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Ďalšie nastavenia načúvacieho zariadenia"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Zmeňte nastavenia pre viacero zariadení, ako sú skratky a ovládanie cievky telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Pre toto zariadenie"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Zvukový výstup"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Zvukový výstup"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Nastavuje sa súkromný priestor…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Keď je súkromný priestor uzamknutý, upozornenia z aplikácií, ktoré sú v ňom, sú skryté"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Preskúmajte nastavenia súkromného priestoru umožňujúce jeho skrytie alebo nastavenie automatického zamykania"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Povinné aplikácie sú už nainštalované vo vašom súkromnom priestore"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Súkromný priestor sa nepodarilo nastaviť"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Skúsiť znova"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Odomykať súkromný priestor zámkou obrazovky?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikácie a upozornenia"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Citlivé upozornenia na uzamknutej obrazovke"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Zobrazujte citlivý obsah, keď je súkromný priestor odomknutý"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Vytvorte účet Google a pomôžte tak uchovať svoje údaje v súkromí"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na ďalšej obrazovke sa budete môcť prihlásiť do účtu, aby ste mohli začať používať súkromný priestor"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Vytvorte vyhradený účet a pomôžte tak zaistiť, aby sa údaje nezobrazovali mimo súkromného priestoru, napríklad:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Synchronizované fotky, súbory, e‑maily, kontakty, udalosti v kalendári a ďalšie údaje"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"História sťahovania aplikácií a odporúčania"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"História prehliadania, záložky a uložené heslá"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Navrhovaný obsah súvisiaci s vašou aktivitou v aplikáciách v súkromnom priestore"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Dobre"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Maximálny počet odtlačkov, ktoré môžete pridať: <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Pridali ste maximálny počet odtlačkov prstov"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nie je možné pridať ďalšie odtlačky prstov"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Váš operátor vám nepovoľuje pripojiť sa k tejto sieti, pretože používa starší bezpečnostný protokol s nižšou úrovňou zabezpečenia"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Povoliť WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Zavrieť"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Chcete sa odpojiť od siete <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Máte pripojenie k sieti WEP. Ak tieto siete zablokujete, pripojenie sa preruší."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Rozšírené možnosti"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rozbaľovací zoznam Pokročilé možnosti"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"rozbaliť"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Chcete spravovať sieťové pripojenia pomocou aplikácie <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedávne žiadosti o polohu"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Poloha pre pracovný profil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Prístup aplikácií k polohe"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Poloha je vypnutá"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Prístup k polohe má # z {total} aplikácií}few{Prístup k polohe majú # z {total} aplikácií}many{# of {total} apps have access to location}other{Prístup k polohe má # z {total} aplikácií}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Používať klávesnicu na obrazovke"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Ponechať na obrazovke, keď je aktívna fyzická klávesnica"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Klávesy jedného stlačenia"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Klávesnica ignoruje rýchle opakované stlačenia rovnakého klávesa rýchlosťou do <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Pomalé klávesy"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Upravte čas aktivácie klávesa stlačením na <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Režim uzamknutia klávesa"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Používajte skratky stlačením jedného klávesa namiesto viacerých"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klávesové skratky"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Zobrazenie zoznamu skratiek"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Klávesnice a nástroje pracovného profilu"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Resetovať"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Vyberte modifikačný kláves"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Vyberte pre <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> nový kláves:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Predvolené"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Reč"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Rýchlosť kurzora"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Herné ovládače"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Zariadenie môžete prispôsobiť, aby zodpovedalo vašim potrebám. Tieto funkcie dostupnosti môžete neskôr zmeniť v Nastaveniach."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Zmeniť veľkosť písma"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Čítačka obrazovky"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Možnosti fyzickej klávesnice"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Titulky"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Zvuk"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Všeobecné"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Zobrazenie"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Farba a pohyb"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Farebný kontrast"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Zvýšením kontrastu zvýrazníte text, tlačidlá a ikony. Vyberte úroveň kontrastu, ktorá vám najviac vyhovuje."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Niektoré aplikácie nemusia podporovať všetky nastavenia kontrastu farieb a textu"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Upravte, vzhľad farieb a textu na farbe pozadia obrazovky"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Ukážka"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helena, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Pred 2 dňami"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Nadviazať?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Hlásenie o obchodnej ceste"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Ak budete potrebovať ďalšiu pomoc, obráťte sa na \nmňa alebo Helenu. Toto hlásenie bude"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Výdavky klienta"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Stmavenie obrazovky"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Doplnkové ovládanie"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Ovládanie časovania"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Aj tak pokračovať"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Zrušiť"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Nastavenia priblíženia"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Priblíženie skratkou"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Priblíženie skratkou a trojitým klepnutím"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Nepriehľadné"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text s vysokým kontrastom"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Zmeniť farbu textu na čiernu alebo bielu, čim sa maximalizuje kontrast s pozadím"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximalizujte kontrast textu"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Zmeňte farbu textu na čiernu alebo bielu, aby lepšie vynikol na pozadí."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Auto. aktualiz. priblíž. obrazovky"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Aktualizovať priblíž. obrazov. pri prechodoch apl."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Ukončiť hovor vypínačom"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Pridržanie tlačidiel hlasitosti"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trojité klepnutie na obrazovku"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Úprava skratiek dostupnosti"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Vyberte skratku pre %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Ďalej"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Načúvacie zariadenia"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Nastavte a spravujte načúvadlá podporujúce protokol ASHA a aplikáciu LE Audio, kochleárne implantáty a ďalšie zosilňovacie zariadenia"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nie sú pripojené žiadne načúvacie zariadenia"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Pridať načúvadlá"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Párovanie načúvadiel"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilita s načúvadlami"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Zlepšuje kompatibilitu s telecievkami a znižuje úroveň nežiaduceho hluku"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Načúvacie zariadenia"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Ak chcete nájsť iné načúvacie zariadenia, ktoré ASHA alebo LE Audio nepodporuje, klepnite na "<b>"Párovať nové zariadenie"</b>" a "<b>"Zobraziť ďalšie zariadenia"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Párovanie načúvadla"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Na tejto stránke môžete spárovať načúvacie zariadenia ASHA a LE Audio. Skontrolujte, či je načúvacie zariadenie zapnuté a pripravené na párovanie."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Dostupné načúvacie zariadenia"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Textové správy"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatické prepínanie dát"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"V závislosti od pokrytia a dostupnosti môžete používať dáta oboch SIM kariet"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Iba dáta"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Nastaviť"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Ďalej"</string>
@@ -4943,12 +4930,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomáha zistiť relatívnu pozíciu zariadení v okolí, ktoré majú UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Ak chcete používať UWB, vypnite režim v lietadle"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Technológia UWB nie je v aktuálnej oblasti k dispozícii"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Pripojte sa ku kompatibilným zariadeniam pomocou siete Thread, aby ste mali k dispozícii plynulé prostredie inteligentnej domácnosti"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Ak chcete používať Thread, vypnite režim v lietadle"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Prístup ku kamere"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Prístup k mikrofónu"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Pre aplikácie a služby"</string>
@@ -5125,8 +5109,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Zrušiť"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Štandardný"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Predvolené"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Stredný"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Vysoký"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Táto aplikácia môže byť otvorená iba v jednom okne"</string>
diff --git a/res/values-sl/arrays.xml b/res/values-sl/arrays.xml
index 17a3c79..7efa5e1 100644
--- a/res/values-sl/arrays.xml
+++ b/res/values-sl/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Obravnavaj kot: omejen prenos podatkov"</item>
     <item msgid="2047166446768045816">"Obravnavaj kot: neomejen prenos podatkov"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Uporabi naključni MAC (privzeto)"</item>
-    <item msgid="741680937828608749">"Uporabi naslov MAC naprave"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ne"</item>
     <item msgid="2163015208097377388">"Da"</item>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index 3fad070..1536cba 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Seznani desno uho"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Seznani levo uho"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Za vse razpoložljive slušne aparate"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Več nastavitev za slušne pripomočke"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Spremenite nastavitve za zunanje naprave, kot so kontrolniki za bližnjice in teletuljave"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Za to napravo"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Zvočni izhod"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"O zvočnem izhodu"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Nastavljanje zasebnega prostora …"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Obvestila aplikacij v zasebnem prostoru so skrita, kadar je zasebni prostor zaklenjen"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Raziščite nastavitve zasebnega prostora, če želite skriti zasebni prostor in nastaviti samodejno zaklepanje"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Obvezne aplikacije so že nameščene v zasebnem prostoru"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Zasebnega prostora ni bilo mogoče nastaviti"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Poskusi znova"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Želite uporabiti zaklepanje zaslona za odklepanje zasebnega prostora?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikacije in obvestila"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Občutljiva obvestila na zaklenjenem zaslonu"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Prikaz občutljive vsebine, ko je zasebni prostor odklenjen"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Ustvarite račun Google, da poskrbite za zasebnost svojih podatkov"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na naslednjem zaslonu se lahko prijavite v račun, ki ga boste uporabljali z zasebnim prostorom"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Ustvarite namenski račun, da se podatki, kot so naslednji, ne bodo prikazovali zunaj zasebnega prostora:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinhronizirane fotografije, datoteke, e-poštna sporočila, stiki, dogodki na koledarju in drugi podatki"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Zgodovina in priporočila prenosov aplikacij"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Zgodovina brskanja, zaznamki in shranjena gesla"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Predlagana vsebina v zvezi z vašo dejavnostjo v aplikacijah v zasebnem prostoru"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Razumem"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Dodate lahko do toliko prstnih odtisov: <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodali ste največje dovoljeno število prstnih odtisov"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Prstnih odtisov ni več mogoče dodati"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Vaš operater ne dovoli povezovanja s tem omrežjem, ker uporablja starejši varnostni protokol z nižjo stopnjo varnosti"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Dovoli omrežja WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Zapri"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Želite prekiniti povezavo z omrežjem <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Povezava z omrežjem WEP je vzpostavljena. Če blokirate ta omrežja, bo povezava prekinjena."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Dodatne možnosti"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Dodatne možnosti spustnega seznama"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"razširi"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Želite za upravljanje omrežnih povezav uporabljati aplikacijo <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavne zahteve za lokacijo"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za delovni profil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Dovoljenja aplikacij za lokacijo"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Zaznavanje lokacije je izklopljeno."</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Dostop do lokacije ima # aplikacija od {total}.}one{Dostop do lokacije ima # aplikacija od {total}.}two{Dostop do lokacije imata # aplikaciji od {total}.}few{Dostop do lokacije imajo # aplikacije od {total}.}other{Dostop do lokacije ima # aplikacij od {total}.}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Uporabi zaslonsko tipkovnico"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Obdrži na zaslonu, tudi ko je fizična tipkovnica aktivna."</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Zaznava večkratnih pritiskov tipk"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tipkovnica prezre hitro ponovljene pritiske iste tipke v <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Daljši pritisk tipk"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Čas, potreben za aktiviranje pritiska tipke, prilagodi na <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Zaklepanje tipk"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Za bližnjice pritisnite eno tipko hkrati namesto več tipk hkrati"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Bližnjične tipke"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Prikaz seznama bližnjic"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tipkovnice in orodja delovnega profila"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Ponastavi"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Izbira modifikatorske tipke"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Izberite novo tipko za »<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>«:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Postavitev <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Privzeto"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Samodejno: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Uporabniško izbrano: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Govor"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Hitrost kazalca"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Krmilnik za igre"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"To napravo lahko prilagodite svojim potrebam. Te funkcije dostopnosti lahko pozneje spremenite v nastavitvah."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Spremenite velikost pisave"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Bralnik zaslona"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Možnosti fizične tipkovnice"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Podnapisi"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Zvok"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Splošno"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Zaslon"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Barva in gibanje"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Barvni kontrast"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Z višjim kontrastom bodo besedilo, gumbi in ikone bolj izstopali. Izberite kontrast, ki se vam zdi najboljši."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Nekatere aplikacije morda ne podpirajo vseh nastavitev kontrasta barv in besedila"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Prilagodite videz barv in besedila glede na barvo ozadja zaslona"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Predogled"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Pred 2 dnevoma"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Imate podvprašanje?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Poročilo o službenem potovanju"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Za dodatno pomoč se obrnite \nname ali na Helen. To poročilo bo"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Stroški stranke"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Potemnitev zaslona"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrolniki za interakcije"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Časovni kontrolniki"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Vseeno nadaljuj"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Prekliči"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Nastavitve povečave"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Povečanje z bližnjico"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Povečanje z bližnjico in trikratnim dotikom"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"O funkciji »<xliff:g id="SERVICE">%1$s</xliff:g>«"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Neprosojno"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Visokokontrastno besedilo"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Spremenite barvo besedila v črno ali belo. Poveča kontrast z ozadjem."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Povečanje kontrasta besedila"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Spremenite barvo besedila v črno ali belo, da povečate kontrast z ozadjem."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Samodejno posodobi povečavo zaslona"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Posodabljanje povečave zaslona pri prehodih aplik."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Gumb za vklop konča klic"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Pridržanje tipk za glasnost"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trikratni dotik zaslona"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Urejanje bližnjic za dostopnost"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Izberite bližnjico za: %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Naprej"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Slušni pripomočki"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Nastavitev in upravljanje slušnih pripomočkov, polževih vsadkov in drugih naprav za ojačitev, ki jih podpira protokol ASHA ali LE zvok"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Noben slušni pripomoček ni povezan."</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Dodajanje slušnih pripomočkov"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Seznanite slušne aparate"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Združljivost s slušnimi aparati"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Izboljša združljivost s teletuljavami in zmanjša količino neželenega hrupa."</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"O slušnih aparatih"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Če želite poiskati druge slušne pripomočke, ki jih protokol ASHA ali LE zvok ne podpira, se dotaknite "<b>"Seznanitev nove naprave"</b>" &gt; "<b>"Ogled več naprav"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Seznanitev slušnega aparata"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Na tej strani lahko seznanite slušne aparate, združljive s funkcijama ASHA in LE zvok. Poskrbite, da je slušni aparat vklopljen in pripravljen za seznanjanje."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Razpoložljivi slušni pripomočki"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Sporočila SMS"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Samodejni preklop prenosa podatkov"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Uporaba prenosa podatkov prek ene ali druge kartice SIM, odvisno od pokritosti in razpoložljivosti"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Samo prenos podatkov"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Nastavi"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Naprej"</string>
@@ -4943,12 +4927,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomaga določiti relativni položaj naprav v bližini, ki imajo UWB."</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Če želite uporabljati UWB, izklopite način za letalo."</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Na trenutni lokaciji UWB ni na voljo."</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Prek protokola Thread vzpostavite povezavo z združljivimi napravami za nemoteno izkušnjo pametnega doma"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Če želite uporabljati protokol Thread, izklopite način za letalo"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Dostop do fotoaparata"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Dostop do mikrofona"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Za aplikacije in storitve."</string>
@@ -5125,8 +5106,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Prekliči"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standardni"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Privzeto"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Srednji"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Visok"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"To aplikacijo je mogoče odpreti samo v enem oknu"</string>
diff --git a/res/values-sq/arrays.xml b/res/values-sq/arrays.xml
index 0fd29d9..ed2f984 100644
--- a/res/values-sq/arrays.xml
+++ b/res/values-sq/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Trajto si me matje"</item>
     <item msgid="2047166446768045816">"Trajto si pa matje"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Përdor adresë MAC të rastësishme (parazgjedhje)"</item>
-    <item msgid="741680937828608749">"Përdor adresën MAC të pajisjes"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Jo"</item>
     <item msgid="2163015208097377388">"Po"</item>
diff --git a/res/values-sq/strings.xml b/res/values-sq/strings.xml
index c1b2818..80ab818 100644
--- a/res/values-sq/strings.xml
+++ b/res/values-sq/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Çifto anën e djathtë"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Çifto anën e majtë"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Për të gjitha pajisjet e dëgjimit që ofrohen"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Cilësime të tjera të pajisjes ndihmëse për dëgjimin"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Ndrysho cilësimet e pajisjeve të ndërlidhura si shkurtorja dhe kontrollet e telebobinës"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Për këtë pajisje"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Dalja e audios"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Rreth daljes së audios"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Hapësira private po konfigurohet…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Njoftimet nga aplikacionet e hapësirëa private janë të fshehura kur ajo është e kyçur"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Eksploro cilësimet e hapësirës private për ta fshehur hapësirën private dhe për të konfiguruar kyçjen automatike"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Aplikacionet e kërkuara janë instaluar tashmë në hapësirën tënde private"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Hapësira private nuk mund të konfigurohej"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Provo përsëri"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Të përdoret kyçja e ekranit për të shkyçur hapësirën private?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Aplikacionet dhe njoftimet"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Njoftimet delikate në ekranin e kyçjes"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Shfaq përmbajtjet delikate kur hapësira private është e shkyçur"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Krijo një \"Llogari të Google\" për të ndihmuar t\'i mbash private të dhënat e tua"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Në ekranin tjetër mund të identifikohesh në një llogari për ta përdorur me hapësirën tënde private"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Krijo një llogari të posaçme për të ndihmuar në ndalimin e shfaqjes së të dhënave jashtë hapësirës private, si p.sh.:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Fotografitë, skedarët, email-et, kontaktet, ngjarjet e kalendarit dhe të dhëna të tjera të sinkronizuara"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Historiku i shkarkimit të aplikacioneve dhe rekomandimet"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historiku i shfletimit, faqeshënuesit dhe fjalëkalimet e ruajtura"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Përmbajtjet e sugjeruara në lidhje me aktivitetin tënd në aplikacionet e hapësirës private"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"E kuptova"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Mund të shtosh deri në <xliff:g id="COUNT">%d</xliff:g> gjurmë gishtash"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Ke shtuar numrin maksimal të gjurmëve të gishtave"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nuk mund të shtohen gjurmë të tjera të gishtave"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operatori celular nuk të lejon që të lidhesh me këtë rrjet sepse ai përdor një protokoll më të vjetër të sigurisë që është më pak i sigurt"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Lejo WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Mbyll"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Do të shkëputesh nga <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Je lidhur me një rrjet WEP. Nëse i bllokon këto rrjete, do të shkëputesh."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Opsionet e përparuara"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Opsionet e përparuara të listës me lëshim poshtë"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"zgjero"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Të përdoret <xliff:g id="NEW_APP">%s</xliff:g> për të menaxhuar lidhjet e rrjetit?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Kërkesat e vendndodhjeve të fundit"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Vend. për profilin e punës"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Lejet e vendndodhjes për aplikacionet"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Vendndodhja është joaktive"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# nga {total} aplikacione ka qasje te vendndodhja}other{# nga {total} aplikacione kanë qasje te vendndodhja}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Përdor tastierën në ekran"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Mbaje në ekran ndërsa tastiera fizike është aktive"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Tastet e kërcimit"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tastiera i shpërfill shtypjet e shpejta të përsëritura të të njëjtit tast brenda <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Tastet e ngadalta"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Rregullon kohën që duhet për aktivizimin e një shtypjeje tasti në <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Tastet e përhershme"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Shtyp vetëm një tast në një moment për shkurtoret në vend që t\'i mbash shtypur bashkë tastet"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Shkurtoret e tastierës"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Shfaq listën e shkurtoreve"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastierat dhe veglat e profilit të punës"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Rivendos"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Zgjidh tastin modifikues"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Zgjidh një çelës të ri për <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"E parazgjedhur"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Ligjërimi"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Shpejtësia e treguesit"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Kontrolluesi i lojës"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Mund ta personalizosh këtë pajisje për t\'iu përshtatur nevojave të tua. Këto veçori të qasshmërisë mund të ndryshohen më vonë te \"Cilësimet\"."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Ndrysho madhësinë e shkrimit"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Lexuesi i ekranit"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Opsionet e tastierës fizike"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Titrat"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Të përgjithshme"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Ekrani"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Ngjyra dhe lëvizja"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Kontrasti i ngjyrës"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Kontrasti më i lartë bën që teksti, butonat dhe ikonat të dallohen më shumë. Zgjidh kontrastin që të duket më mirë."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Disa aplikacione mund të mos i mbështesin të gjitha cilësimet e kontrastit të tekstit dhe të ngjyrave"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Rregullo se si duken ngjyrat dhe testi në ngjyrën e sfondit të ekranit"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Pamja paraprake"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Elena, Adi"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 ditë më parë"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Do ta ndjekësh?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Raporti i udhëtimit të punës"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Për ndihmë të mëtejshme, kontakto me \nmua ose Elenën. Ky raport do të jetë"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Shpenzimet e klientit"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Bëj ekranin më të errët"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrollet e ndërveprimeve"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Kontrollet në lidhje me kohën"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Vazhdo gjithsesi"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Anulo"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Cilësimet e zmadhimit"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Zmadho me shkurtore"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Zmadho me shkurtore dhe tri trokitje"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Rreth \"<xliff:g id="SERVICE">%1$s</xliff:g>\""</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Jotransparente"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst me kontrast të lartë"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Ndrysho ngjyrën e tekstit në të zezë ose në të bardhë. Maksimizon kontrastin me sfondin."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maksimizo kontrastin e tekstit"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Ndrysho ngjyrën e tekstit në të zezë ose të bardhë për të rritur kontrstin me sfondin."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Përditëso auto. zmadhimin e ekranit"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Përditëso zmadhimin e ekranit në kalimet e apl."</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Butoni i energjisë mbyll telefonatën"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mbaj butonat e volumit"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trokit tri herë tek ekrani"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Zgjidh shkurtoret e qasshmërisë"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Zgjidh shkurtoren tënde për %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Vazhdo"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Pajisjet e dëgjimit"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Konfiguro dhe menaxho aparatet e dëgjimit, implantet kokleare dhe pajisje të tjera amplifikimi me ASHA dhe LE Audio"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nuk ka pajisje dëgjimi të lidhura"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Shto aparate dëgjimi"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Çifto aparatin e dëgjimit"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Përputhshmëria me aparate dëgjimi"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Përmirëson përputhshmërinë me kapësit e tingujve dhe redukton zhurmën e padëshiruar"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Rreth pajisjeve të dëgjimit"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Për të gjetur pajisje të tjera ndihmëse për dëgjimin që nuk mbështetet nga ASHA ose LE Audio, trokit te "<b>"Çifto pajisjen e re"</b>" &gt; "<b>"Shiko pajisje të tjera"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Çifto pajisjet e dëgjimit"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Mund t\'i çiftosh pajisjet ndihmëse për dëgjimin me ASHA dhe LE Audio në këtë faqe. Sigurohu që pajisja jote ndihmëse për dëgjimin të jetë e aktivizuar dhe gati për çiftim."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Pajisjet e dëgjimit që ofrohen"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mesazhet me tekst"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Ndërrimi automatik për të dhënat"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Përdor të dhënat nga cilado kartë SIM në varësi të mbulimit dhe disponueshmërisë"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Vetëm për të dhënat"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Konfiguro"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Para"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Ndihmon për të identifikuar pozicionin e përafërt të pajisjeve në afërsi që kanë UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Çaktivizo \"Modalitetin e aeroplanit\" për të përdorur UWB."</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Veçoria UWB nuk ofrohet në vendndodhjen aktuale"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Lidhu me pajisjet e përputhshme duke përdorur Thread për një përvojë pa ndërprerje me shtëpinë inteligjente"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Çaktivizo modalitetin e aeroplanit për të përdorur Thread."</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Qasja te kamera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Qasja te mikrofoni"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Për aplikacionet dhe shërbimet"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Anulo"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrasti"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Parazgjedhja"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Mesatar"</string>
     <string name="contrast_high" msgid="3988567609694797696">"I lartë"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ky aplikacion mund të hapet vetëm në 1 dritare"</string>
diff --git a/res/values-sr/arrays.xml b/res/values-sr/arrays.xml
index 4ecb26d..9884e06 100644
--- a/res/values-sr/arrays.xml
+++ b/res/values-sr/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Третирај као мрежу са ограничењем"</item>
     <item msgid="2047166446768045816">"Третирај као мрежу без ограничења"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Користи насумичну MAC адресу (подразумевано)"</item>
-    <item msgid="741680937828608749">"Користи MAC адресу уређаја"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Не"</item>
     <item msgid="2163015208097377388">"Да"</item>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 9f04b5f..b12e29c 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Упари десно уво"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Упари лево уво"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"За све доступне слушне апарате"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Још подешавања слушног апарата"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Промените подешавања на више уређаја, на пример контроле пречица и телекоила"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"За овај уређај"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аудио излаз"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"О аудио излазу"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Подешава се приватни простор…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Обавештења из апликација у приватном простору су скривена кад је он закључан"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Истражите подешавања приватног простора да бисте га сакрили и подесили аутоматско закључавање"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Обавезне апликације су већ инсталиране у приватном простору"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Подешавање приватног простора није успело"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Пробај поново"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Откључати приватни простор откључавањем екрана?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Апликације и обавештења"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Осетљива обавештења на закључаном екрану"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Приказујте осетљив садржај када је приватни простор откључан"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Отворите наменски Google налог да бисте заштитили приватност података"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"На следећем екрану можете да се пријавите на налог који ћете користити са приватним простором"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Отворите наменски налог како бисте спречили да се изван приватног простора приказују подаци, на пример:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Синхронизоване слике, фајлови, имејлови, контакти, догађаји у календару и други подаци"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Историја преузимања апликације и препоруке"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Историја прегледања, обележивачи и сачуване лозинке"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Предложен садржај повезан са активностима у апликацијама из приватног простора"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Важи"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Можете да их додате до <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Додали сте максималан број отисака прстију"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Не можете да додате још отисака прстију"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Мобилни оператер не дозвољава да се повежете са овом мрежом јер она користи старији безбедносни протокол који је мање сигуран"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Дозволи WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Затвори"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Желите да прекинете везу са: <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Повезани сте на WEP мрежу. Ако блокирате ове мреже, нећете бити повезани."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Напредне опције"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Падајућа листа са напредним опцијама"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"проширите"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Желите ли да користите апликацију <xliff:g id="NEW_APP">%s</xliff:g> за управљање мрежним везама?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Недавни захтеви за локацију"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Локација за пословни профил"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Дозволе за локацију апликације"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Локација је искључена"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Приступ локацији има # апликација од {total}}one{Приступ локацији има # апликација од {total}}few{Приступ локацији имају # апликације од {total}}other{Приступ локацији има # апликација од {total}}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Користи тастатуру на екрану"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Задржава се на екрану док је физичка тастатура активна"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Дужи одзив тастера"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Тастатура занемарује брзе притиске истог тастера који се понављају у року од <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Спори тастери"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Приладите време потребно да се тастер активира после притиска на <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Лепљиви тастери"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Притискајте један по један тастер да бисте користили пречице уместо да истовремено држите тастере"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Тастерске пречице"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Приказује листу пречица"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Тастатуре и алатке за пословни профил"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Ресетуј"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Одаберите модификујући тастер"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Одаберите нови тастер за <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Распоред <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Подразумевано"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Аутоматски: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Изабрао је корисник: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Говор"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Брзина показивача"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Контролер за игре"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Можете да прилагодите овај уређај према потребама. Те функције приступачности можете касније да промените у Подешавањима."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Промените величину фонта"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Читач екрана"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Опције физичке тастатуре"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Титл"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Звук"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Опште"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Приказ"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Боја и покрет"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Контраст боја"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Већи контраст истиче текст, дугмад и иконе. Изаберите контраст који вам изгледа најбоље."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Неке апликације можда не подржавају сва подешавања за контраст боја и текста"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Прилагодите изглед боја и текста у односу на боју позадине екрана"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Преглед"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Хелена, Адам"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Пре 2 дана"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Додатни упит?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Извештај о пословном путу"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Да бисте добили додатну помоћ, обратите се \nмени или Хелени. Овај извештај ће бити"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Трошкови клијента"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Затамњује екран"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Контроле интеракције"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Контроле временских одредница"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Ипак настави"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Откажи"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Подешавања увећања"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Увећавајте помоћу пречице"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Увећавајте помоћу пречице и троструког додира"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"О услузи <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Није прозирно"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Текст високог контраста"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Промените боју текста у црну или белу. Максимално увећава контраст са позадином."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Максимално увећајте контраст текста"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Промените боју текста у црну или белу да бисте повећали контраст са позадином."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Аутоматски ажурирај увелич. екрана"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ажурира увеличавање екрана при прелазу апликација"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Дугме за укључивање прекида позив"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Задржите тастере за јачину звука"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Додирните екран трипут"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Измените пречице за приступачност"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Изаберите пречицу за %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Настави"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Слушни апарати"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Подесите слушне апарате који имају ASHA и LE Audio, кохлеарне импланте и уређаје за појачавање звука и управљајте њима"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Нема повезаних слушних апарата"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Додајте слушне апарате"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Упарите слушне апарате"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Компатибилност са слушним апаратима"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Побољшава компатибилност са телекоиловима и смањује нежељену буку"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"О слушним апаратима"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Да бисте пронашли друге слушне апарате који немају ASHA ни LE Audio, додирните "<b>"Упари нови уређај"</b>" &gt; "<b>"Прикажи још уређаја"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Упарите слушни апарат"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"На овој страници можете да упарите слушне апарате који имају ASHA и LE Audio. Проверите да ли је слушни апарат укључен и спреман за упаривање."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Доступни слушни апарати"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS поруке"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Ауто. замена преноса података"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Користи пренос података са било ког SIM-а у зависности од покривености и доступности"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Само пренос података"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Подеси"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Даље"</string>
@@ -4942,12 +4926,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Помаже у идентификацији релативног положаја уређаја у близини који имају UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Искључује режим рада у авиону ради коришћења UWB-а"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Ултра-широки појас је недоступан на актуелној локацији"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Повежите се са компатибилним уређајима помоћу Thread-а да бисте имали беспрекоран доживљај паметне куће"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Искључите режим рада у авиону да бисте користили Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Приступ камери"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Приступ микрофону"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"За апликације и услуге"</string>
@@ -5124,8 +5105,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Откажи"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Контраст"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Стандардно"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Подразумевано"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Средње"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Високо"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ова апликација може да се отвори само у једном прозору"</string>
diff --git a/res/values-sv/arrays.xml b/res/values-sv/arrays.xml
index b311e99..5c30761 100644
--- a/res/values-sv/arrays.xml
+++ b/res/values-sv/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Behandla som nätverk med datapriser"</item>
     <item msgid="2047166446768045816">"Behandla som nätverk utan datapriser"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Slumpgenererad MAC-adress (standard)"</item>
-    <item msgid="741680937828608749">"Använd enhetens MAC-adress"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Nej"</item>
     <item msgid="2163015208097377388">"Ja"</item>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index cb4157f..4951ead 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Parkoppla höger"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Parkoppla vänster"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"För alla tillgängliga hörapparater"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Fler inställningar för hörhjälpmedel"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Ändra inställningar för flera enheter, som kontroller för kortkommandon och telespole"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"För den här enheten"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Ljudutgång"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Om ljudutgång"</string>
@@ -591,15 +589,14 @@
     <string name="private_space_setup_title" msgid="2272968244329821450">"Privat område"</string>
     <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Dölj eller lås privata appar i ett separat område. Använd ett dedikerat Google-konto för extra säkerhet."</string>
     <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Konfigurera ett privat område"</string>
-    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Välj ett Google-konto för ditt område"</b>\n"Genom att använda ett dedikerat konto visas inte synkroniserade filer, foton och e-postmeddelanden utanför området"</string>
+    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Välj ett Google-konto för ditt område"</b>\n"Om du använder ett dedikerat konto visas inte synkroniserade filer, foton och e-postmeddelanden utanför området"</string>
     <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Ställ in ett lås"</b>\n"Lås ditt område så att andra inte kan öppna det"</string>
-    <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Installera appar"</b>\n"Ditt privata område har ett eget Play Butik så att du smidigt kan installera appar."</string>
+    <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Installera appar"</b>\n"Ditt privata område har en egen Play Butik så att du smidigt kan installera appar."</string>
     <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Appar i ditt privata rum visas inte i behörighetshanteringen, integritetsöversikten eller andra inställningar när ditt privata rum är låst.\n\nDitt privata rum kan inte flyttas till en ny enhet. Du måste ställa in ett nytt privat rum om du vill använda det på en annan enhet.\n\nAlla som ansluter din enhet till en dator eller installerar skadliga appar på enheten kanske kan få åtkomst till ditt privata rum."</string>
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Ställer in privat rum …"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Aviseringar från appar i ett privat område döljs när det är låst"</string>
-    <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Utforska inställningar för privat område om du vill dölja privat område och konfigurera automatiskt lås"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Utforska inställningarna för privat område om du vill dölja privat område och ställa in automatiskt lås"</string>
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Appar som krävs är redan installerade i ditt privata område"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Det gick inte att ställa in privat område"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Försök igen"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Vill du låsa upp privat rum med skärmlåset?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Appar och aviseringar"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Känsliga aviseringar på låsskärmen"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Visa känsligt innehåll när privat område är olåst"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Skapa ett Google-konto för att hålla din data privat:"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"På nästa skärm kan du logga in på kontot som du vill använda med ditt privata område"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Skapa ett dedikerat konto för att förhindra att data visas utanför det privata området, till exempel:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Synkroniserade foton, filer, e-post, kontakter, kalenderhändelser och annan data"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Rekommendationer och nedladdningshistorik för appar"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Webbhistorik, bokmärken och sparade lösenord"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Föreslaget innehåll som rör din aktivitet i appar i det privat området"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Du kan lägga till upp till <xliff:g id="COUNT">%d</xliff:g> fingeravtryck"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Du har lagt till det högsta tillåtna antalet fingeravtryck"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Det går inte att lägga till fler fingeravtryck"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Din operatör tillåter inte att du ansluter till det här nätverket eftersom det använder ett äldre säkerhetsprotokoll som är mindre säkert"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Tillåt WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Stäng"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Vill du koppla från <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Du är ansluten till ett WEP-nätverk. Om du blockerar sådana nätverk kopplas du från."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Avancerade alternativ"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rullgardinsmenyn Avancerade alternativ"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"utöka"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Vill du hantera nätverksanslutningarna med <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nya platsförfrågningar"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Plats för jobbprofil"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Appars platsbehörighet"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Plats har inaktiverats"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# av {total} appar har platsåtkomst}other{# av {total} appar har platsåtkomst}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Använd skärmtangentbord"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Ha kvar det på skärmen när det fysiska tangentbordet används"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Studsande tangenter"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Tangentbordet ignorerar snabbt upprepade tryck på samma tangent inom <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Långsamma tangenter"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Justera tiden det tar innan ett tryck på en tangent aktiveras till <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Tröga tangenter"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Tryck ned en tangent i taget för kortkommandon i stället för att hålla ned flera tangenter samtidigt"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Kortkommandon"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Visa en lista över genvägar"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tangentbord och verktyg för jobbprofilen"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Återställ"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Välj specialtangent"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Välj en ny tangent för <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Standard"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Tal"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Markörens hastighet"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Spelkontroller"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Du kan anpassa enheten efter dina behov. Tillgänglighetsfunktionerna kan ändras senare under Inställningar."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Ändra teckenstorlek"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Skärmläsare"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Alternativ för fysiskt tangentbord"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Textning"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Ljud"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Allmänt"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Skärm"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Färg och rörelse"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Färgkontrast"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Högre kontrast gör att text, knappar och ikoner syns bättre. Välj kontrasten som ser bäst ut för dig."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Vissa appar kanske inte har stöd för alla inställningar för färg- och textkontrast"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Justera hur färger och text ser ut mot skärmens bakgrundsfärg"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Förhandsgranska"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 dagar sedan"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Följdfråga?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Rapport om affärsresa"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Om du behöver mer hjälp kontaktar du \nmig eller Helen. Den här rapporten kommer att vara"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Klientutgifter"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Gör skärmen mörkare"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktionsinställningar"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Inställningar för tidsgräns"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Fortsätt ändå"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Avbryt"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Inställningar för förstoring"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Förstora med genväg"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Förstora med genväg och tryck snabbt tre gånger"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Om <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Inte genomskinlig"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text med hög kontrast"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Ändra textfärgen till svart eller vit. Det ger bäst kontrast mot bakgrunden."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximera textkontrasten"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Ändra textfärgen till svart eller vit för att öka kontrasten mot bakgrunden."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Uppdatera skärmförstoring automatiskt"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Uppdatera skärmförstoring på appövergångar"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Avsluta samtal med av/på-knapp"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Håll ned volymknapparna"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tryck snabbt tre gånger på skärmen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Redigera genvägar till tillgänglighetsfunktioner"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Välj kortkommandot för %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Fortsätt"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hörhjälpmedel"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Konfigurera och hantera ASHA- eller LE Audio-hörapparater, cochleaimplantat och andra ljudförstärkande enheter"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Inga hörhjälpmedel har anslutits"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Lägg till hörapparater"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Parkoppla hörapparater"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilitet med hörapparat"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Förbättrar kompatibiliteten med telespolar och minskar oönskade ljud"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Om hörapparater"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Om du vill hitta andra hörhjälpmedel som inte stöds av ASHA eller LE Audio trycker du på "<b>"Parkoppla en ny enhet"</b>" &gt; "<b>"Visa fler enheter"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Parkoppla hörapparat"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Du kan parkoppla hörhjälpmedel från ASHA och LE Audio på den här sidan. Kontrollera att hörhjälpmedlet är på och redo för parkoppling."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Tillgängliga hörapparater"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Sms"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Automatiskt databyte"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Använd data från båda SIM-korten beroende på täckning och tillgänglighet"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Endast data"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Ställ in"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Nästa"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Hjälper till att identifiera den relativa positionen för enheter i närheten som har UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Inaktivera flygplansläge för att använda UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB är inte tillgängligt på den aktuella platsen"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Anslut till kompatibla enheter via Thread för en sömlös smart hemupplevelse"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Inaktivera flygplansläge för att använda Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kameraåtkomst"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofonåtkomst"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"För appar och tjänster"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Avbryt"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Standard"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Medelhög"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Hög"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Denna app kan bara vara öppen i ett fönster"</string>
diff --git a/res/values-sw/arrays.xml b/res/values-sw/arrays.xml
index 947c928..d0e6cf1 100644
--- a/res/values-sw/arrays.xml
+++ b/res/values-sw/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Tumia kama mtandao unaopima data"</item>
     <item msgid="2047166446768045816">"Tumia kama mtandao usiopima data"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Anwani ya MAC ya nasibu (chaguomsingi)"</item>
-    <item msgid="741680937828608749">"Tumia anwani ya MAC ya kifaa"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Hapana"</item>
     <item msgid="2163015208097377388">"Ndiyo"</item>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index b7837d1..4d36f3d 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Unganisha kisaidizi cha kulia"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Unganisha kisaidizi cha kushoto"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Kwa vifaa vyote vya kusikia vinavyopatikana"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Mipangilio zaidi ya vifaa vya kusikilizia"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Badilisha mipangilio ya kifaa kilichounganishwa kwingine kama vile vidhibiti vya koili ya shaba na njia ya mkato"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Katika kifaa hiki"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Vifaa vya kutoa sauti"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Kuhusu vifaa vya kutoa sauti"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Inaweka mipangilio ya sehemu ya faragha…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Arifa kutoka programu za sehemu ya faragha hufichwa ukiwa umeifunga"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Gundua mipangilio ya sehemu ya faragha ili ufiche sehemu ya faragha na uweke mipangilio ya kufunga skrini kiotomatiki"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Programu zinazotakikana tayari zimewekwa katika sehemu yako ya faragha"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Imeshindwa kuweka mipangilio ya sehemu ya faragha"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Jaribu Tena"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Ungependa kutumia kipengele cha kufunga skrini kufungua sehemu ya faragha?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Programu na arifa"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Arifa nyeti kwenye skrini iliyofungwa"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Onyesha maudhui nyeti wakati sehemu ya faragha imefunguliwa"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Fungua Akaunti ya Google ili usaidie kudumisha faragha ya data yako"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Kwenye skrini inayofuata, unaweza kuingia katika akaunti ambako utatumia sehemu yako ya faragha"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Fungua akaunti maalum ili usaidie kuzuia data isionekane nje ya sehemu ya faragha, kama vile:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Picha, faili, barua pepe, anwani, matukio ya kalenda na data nyingine iliyosawazishwa"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Mapendekezo na historia ya upakuaji wa programu"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Historia ya kuvinjari, alamisho na manenosiri uliyohifadhi"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Maudhui yanayopendekezwa yanayohusu shughuli zako kwenye programu za sehemu ya faragha"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Nimeelewa"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Unaweza kuongeza hadi alama za vidole <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Umeongeza idadi ya juu inayoruhusiwa ya alama za kidole"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Haiwezi kuongeza alama zaidi za kidole"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Mtoa huduma wako hakuruhusu kuunganisha kwenye mtandao huu kwa sababu unatumia itifaki ya usalama ya zamani ambayo si salama sana"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Ruhusu WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Funga"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Ungependa kutenganisha kutoka kwenye <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Umeunganishwa kwenye mtandao wa WEP. Ukizuia mitandao hii, utatenganishwa."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Chaguo za kina"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Chaguo za Kina za Orodha Kunjuzi"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"panua"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Ungependa kutumia <xliff:g id="NEW_APP">%s</xliff:g> kusimamia miunganisho yako ya mtandao?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Maombi ya hivi karibuni ya kutambua mahali"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Wasifu wa kazi kutambua mahali"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Ruhusa za programu kufikia mahali"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Utambuzi wa mahali umezimwa"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Programu # kati ya {total} ina idhini ya kufikia data ya mahali}other{Programu # kati ya {total} zina idhini ya kufikia data ya mahali}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Tumia kibodi ya skrini"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Ionyeshe kwenye skrini wakati kibodi halisi inatumika"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Vitufe vinavyoduta"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Kibodi hupuuza vitendo vya kurudia kubonyeza kitufe kimoja haraka na mara nyingi ndani ya milisekunde <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g>"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Vitufe vya polepole"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Hurekebisha muda unaochukua kitendo cha kubofya kitufe ili kuwasha uwe milisekunde <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g>"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Vitufe vinavyonata"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Bonyeza kitufe kimoja baada ya kingine ili upate njia za mkato badala ya kubonyeza na kushikilia vitufe kwa pamoja"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Mikato ya kibodi"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Onyesha orodha ya njia za mkato"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Zana na kibodi za wasifu wa kazini"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Weka upya"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Chagua kitufe cha kurekebisha"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Chagua kitufe kipya cha kurekebisha cha <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Muundo wa <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Chaguomsingi"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Otomatiki: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Uliochaguliwa na mtumiaji: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Kutamka"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Kasi ya kiashiria"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Kidhibiti cha Mchezo"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Unaweza kubadilisha mipangilio ya kifaa hiki kulingana na mahitaji yako. Vipengele hivi vya ufikivu vinaweza kubadilishwa baadaye kwenye Mipangilio."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Badilisha ukubwa wa fonti"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Kisoma skrini"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Chaguo za kibodi halisi"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Manukuu"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Sauti"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Jumla"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Skrini"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Rangi na picha katika mwendo"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Utofautishaji wa rangi"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Utofautishaji wa juu hufanya maandishi, vitufe na aikoni kuonekana vizuri zaidi. Chagua utofautishaji unaokufaa zaidi."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Huenda programu nyingine zisitumie mipangilio yote ya utofautishaji wa maandishi na rangi"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Rekebisha jinsi rangi na maandishi yanavyoonekana kwenye rangi ya mandharinyuma ya skrini yako"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Toleo la kukagua"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Siku 2 zilizopita"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Utafuatilia?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Ripoti ya safari ya kikazi"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Kwa usaidizi zaidi, tafadhali wasiliana \nnami au Helen. Ripoti hii"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Gharama za Mteja"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Geuza skrini iwe nyeusi"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Vidhibiti vya mawasiliano"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Vidhibiti vya muda"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Endelea tu"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Ghairi"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Mipangilio ya ukuzaji"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Kuza kwa njia ya mkato"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Kuza ukitumia njia ya mkato na kugonga mara tatu"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Kuhusu <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Kutopenyeza mwangaza"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Maandishi yenye utofautishaji bora"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Badilisha rangi ya maandishi kuwa nyeusi au nyeupe. Ongeza utofautishaji ukitumia mandharinyuma."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Imarisha utofautishaji wa matini"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Badilisha rangi ya maandishi iwe nyeusi au nyeupe ili uongeze utofautishaji kwenye mandharinyuma."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Sasisha otomatiki ukuzaji wa skrini"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Sasisha ukuzaji wa skrini kwenye mipito ya  programu"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Kata simu kwa kitufe cha kuwasha/kuzima"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Shikilia vitufe vya kuongeza sauti"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Gusa skrini mara tatu"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Badilisha njia za mkato za ufikivu"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Chagua njia ya mkato ya %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Endelea"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Vifaa vya kusaidia kusikia"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Weka mipangilio na udhibiti visaidizi vya kusikia vya ASHA na LE Audio, vifaa vinavyosaidia kusikia vinavyopachikwa ndani ya sikio na vifaa vya kukuza sauti"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Hujaunganisha vifaa vyovyote vya kusikilizia"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Ongeza vifaa vya kusaidia kusikia"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Unganisha visaidizi vya kusikia"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Uoanifu wa vifaa vya kusaidia kusikia"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Huboresha uoanifu na zana za kudukiza umeme katika visaidizi vya kusikia na kupunguza kelele zisizotakiwa"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Kuhusu vifaa vya kusikiliza"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Ili upate vifaa vingine vya kusikilizia ambavyo havitumii ASHA au LE Audio, gusa "<b>"Unganisha kifaa kipya"</b>" &gt; "<b>"Angalia vifaa zaidi"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Unganisha vifaa vya kusaidia kusikia"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Unaweza kuunganisha vifaa vya kusikilizia vya ASHA na LE Audio kwenye ukurasa huu. Hakikisha vifaa vyako vya kusikilizia vimewashwa na viko tayari kuoanishwa."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Vifaa vya kusaidia kusikia vinavyopatikana"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Ujumbe"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Kubadilisha muunganisho wa data kiotomatiki"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Tumia muunganisho wa data wa SIM yoyote kulingana na ufikiaji na upatikanaji"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data pekee"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Weka mipangilio"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Endelea"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Inasaidia kutambua mahali vilipo vifaa vyenye Bendi Pana Zaidi (UWB) vilivyo karibu"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Zima hali ya ndegeni ili utumie Bendi Pana Zaidi"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB haipatikani katika mahali pa sasa"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Unganisha kwenye vifaa oanifu ukitumia Thread ili utumie vipengele vya nyumba yenye vifaa mahiri kwa urahisi"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Zima hali ya ndegeni ili utumie Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Ufikiaji wa kamera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Ufikiaji wa maikrofoni"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Kwa ajili ya programu na huduma"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Ghairi"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Utofautishaji"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Kawaida"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Chaguomsingi"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Wastani"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Juu"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Programu hii inaweza kufunguliwa katika dirisha 1 pekee"</string>
diff --git a/res/values-ta/arrays.xml b/res/values-ta/arrays.xml
index 0419f0d..a2d119c 100644
--- a/res/values-ta/arrays.xml
+++ b/res/values-ta/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"டேட்டா அளவிடப்பட்டது"</item>
     <item msgid="2047166446768045816">"டேட்டா அளவிடப்படாதது"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ரேண்டம் MACகைப் பயன்படுத்து (இயல்புநிலை)"</item>
-    <item msgid="741680937828608749">"சாதன MACகைப் பயன்படுத்து"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"இல்லை"</item>
     <item msgid="2163015208097377388">"ஆம்"</item>
diff --git a/res/values-ta/strings.xml b/res/values-ta/strings.xml
index d96c8e2..1847871 100644
--- a/res/values-ta/strings.xml
+++ b/res/values-ta/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"வலதுபுற கருவியை இணை"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"இடதுபுற கருவியை இணை"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"கிடைக்கும் செவித்துணைக் கருவிகள் அனைத்திற்கும்"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"கூடுதல் செவித்துணைக் கருவி அமைப்புகள்"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"ஷார்ட்கட், டெலிகாயில் கட்டுப்பாடுகள் போன்ற பன்முகச் சாதன அமைப்புகளை மாற்றலாம்"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"இந்தச் சாதனத்திற்கு"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ஆடியோ வெளியீடு"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ஆடியோ அவுட்புட் - அறிமுகம்"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"தனிப்பட்ட இடத்தை அமைக்கிறது…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ரகசிய இடத்திற்கான ஆப்ஸ் பூட்டப்பட்டிருக்கும்போது அதிலிருந்து வரும் அறிவிப்புகள் மறைக்கப்படும்"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"ரகசிய இடத்தை மறைக்கவும் தானாகப் பூட்டும் அம்சத்தை அமைக்கவும் ரகசிய இட அமைப்புகளுக்குச் செல்லுங்கள்"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"உங்கள் ரகசிய இடத்தில் ஏற்கெனவே தேவையான ஆப்ஸ் நிறுவப்பட்டுள்ளன"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"ரகசிய இடத்தை அமைக்க முடியவில்லை"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"மீண்டும் முயல்க"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"திரைப்பூட்டால் தனிப்பட்ட இடத்தைத் திறக்க வேண்டுமா?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"ஆப்ஸும் அறிவிப்புகளும்"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"பூட்டுத் திரையில், பாதுகாக்கவேண்டிய அறிவிப்புகள்"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"ரகசிய இடம் அன்லாக் செய்யப்படும்போது, பாதுகாக்க வேண்டிய உள்ளடக்கத்தைக் காட்டும்"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"உங்கள் தரவை தனிப்பட்டதாக வைத்திருக்க உதவ ஒரு Google கணக்கை உருவாக்குங்கள்"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"அடுத்த திரையில் உங்கள் ரகசிய இடத்தைப் பயன்படுத்த, கணக்கில் உள்நுழையலாம்"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"ரகசிய இடத்திற்கு வெளியே தரவு தோன்றுவதைத் தடுக்க உதவ ஒரு பிரத்தியேகக் கணக்கை உருவாக்குங்கள்:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"ஒத்திசைக்கப்பட்ட படங்கள், ஃபைல், மின்னஞ்சல், தொடர்பு, கேலெண்டர் நிகழ்வு மற்றும் பிற தரவு"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"இதுவரை பதிவிறக்கிய ஆப்ஸும் பரிந்துரைகளும்"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"இதுவரை இணையத்தில் பார்த்தவை, புக்மார்க் &amp; சேமித்த கடவுச்சொல்"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"ரகசிய இடம் ஆப்ஸில் உங்கள் செயல்பாடு தொடர்பாகப் பரிந்துரைக்கப்படும் உள்ளடக்கம்"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"சரி"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"<xliff:g id="COUNT">%d</xliff:g> கைரேகைகள் வரை சேர்க்கலாம்"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"அனுமதிக்கப்படும் அதிகபட்சக் கைரேகைகளைச் சேர்த்துவிட்டீர்கள்"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"மேலும் கைரேகைகளைச் சேர்க்க முடியவில்லை"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"பாதுகாப்பு குறைவான பழைய பாதுகாப்பு நெறிமுறையை இந்த நெட்வொர்க் பயன்படுத்துவதால் இதனுடன் இணைப்பதற்கு உங்கள் மொபைல் நிறுவனம் அனுமதிக்கவில்லை"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP ஐ அனுமதி"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"மூடு"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> நெட்வொர்க்கிலிருந்து துண்டிக்கவா?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"நீங்கள் WEP நெட்வொர்க்குடன் இணைக்கப்பட்டுள்ளீர்கள். இந்த நெட்வொர்க்குகளை நீங்கள் தடுத்தால், இணைப்பில் இருந்து துண்டிக்கப்படுவீர்கள்."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"மேம்பட்ட விருப்பங்கள்"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"கீழ் தோன்றும் பட்டியின் மேம்படுத்தப்பட்ட விருப்பங்கள்"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"விரி"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"நெட்வொர்க் இணைப்புகளை நிர்வகிக்க <xliff:g id="NEW_APP">%s</xliff:g>ஐப் பயன்படுத்தவா?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"சமீபத்திய இருப்பிடக் கோரிக்கைகள்"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"பணி சுயவிவரத்திற்கான இருப்பிடம்"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ஆப்ஸுக்கான இருப்பிட அனுமதிகள்"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"இருப்பிடம் ஆஃப் செய்யப்பட்டுள்ளது"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} ஆப்ஸில் # ஆப்ஸ் இருப்பிட அணுகலைப் பெற்றுள்ளது}other{{total} ஆப்ஸில் # ஆப்ஸ் இருப்பிட அணுகலைப் பெற்றுள்ளன}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ஸ்கிரீன் கீபோர்டைப் பயன்படுத்து"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"கைமுறை கீபோர்டு இயக்கத்தில் இருக்கும் போது இதைத் திரையில் வைத்திருக்கும்"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"பவுன்ஸ் விசைகள்"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> மில்லி வினாடிக்குள் ஒரே பட்டனைத் தொடர்ச்சியாக அழுத்துவதைக் கீபோர்டு புறக்கணிக்கிறது"</string>
     <string name="slow_keys" msgid="2891452895499690837">"ஸ்லோ கீஸ்"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"ஒரு பட்டனை அழுத்துவதற்கு எடுக்கும் நேரத்தை <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> மில்லி வினாடியாகச் சரிசெய்துகொள்கிறது"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"ஸ்டிக்கி கீஸ்"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"ஷார்ட்கட்களுக்கு பட்டன்களை ஒன்றாகப் பிடிப்பதற்குப் பதிலாக ஒரு நேரத்தில் ஒரு பட்டனை அழுத்தலாம்"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"கீபோர்டு ஷார்ட்கட்கள்"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"ஷார்ட்கட்களின் பட்டியலைக் காட்டும்"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"பணிக் கணக்கிற்கான கீபோர்டுகள் &amp; கருவிகள்"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ரீசெட்"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"மாற்றி விசையைத் தேர்வுசெய்தல்"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>க்கு புதிய விசையை தேர்வுசெய்யலாம்:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> தளவமைப்பு"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"இயல்பு"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"தானியங்கு: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"பயனர் தேர்ந்தெடுத்தது: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"பேச்சு"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"குறிப்பான் வேகம்"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"கேம் கன்ட்ரோலர்"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"உங்கள் தேவைகளுக்கேற்ப இந்தச் சாதனத்தைப் பிரத்தியேகமாக்கலாம். அணுகல் அம்சங்களை பின்னர் அமைப்புகளில் மாற்றி கொள்ளலாம்"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"எழுத்து அளவை மாற்று"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"ஸ்கிரீன் ரீடர்"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"கீபோர்டு விருப்பங்கள்"</string>
     <string name="captions_category_title" msgid="574490148949400274">"வசனங்கள்"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ஆடியோ"</string>
     <string name="general_category_title" msgid="6298579528716834157">"பொது"</string>
     <string name="display_category_title" msgid="6638191682294461408">"திரை அமைப்பு"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"கலர் மற்றும் மோஷன்"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"வண்ண வேறுபாடு"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"அதிக வண்ண மாறுபாடு வார்த்தை, பட்டன்கள், ஐகான்கள் ஆகியவற்றை மேலும் தனித்துக் காட்டுகிறது. உங்களுக்கு ஏற்ற வண்ண மாறுபாட்டைத் தேர்ந்தெடுங்கள்."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"சில வண்ணம் மற்றும் வார்த்தை மாறுபாடு அமைப்புகளைச் சில ஆப்ஸ் ஆதரிக்கலாம் இருக்கலாம்"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"உங்கள் திரையின் பின்னணி வண்ணத்திற்கு ஏற்ப வார்த்தையும் வண்ணங்களும் எப்படித் தோன்றும் என்பதைச் சரிசெய்யலாம்"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"மாதிரிக்காட்சி"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"ஹெலன், ஆடம்"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 நாளுக்கு முன்"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"பின்தொடரவா?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"பிசினஸ் பயண அறிக்கை"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"கூடுதல் உதவிக்கு, \nஎன்னை அல்லது ஹெலனைத் தொடர்புகொள்ளுங்கள். இந்த அறிக்கை"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"கிளையண்ட் செலவுகள்"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"திரையின் ஒளிர்வைக் குறைத்தல்"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ஊடாடல் கட்டுப்பாடுகள்"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"நேரக் கட்டுப்பாடுகள்"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"பரவாயில்லை, தொடர்க"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"ரத்துசெய்"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"பெரிதாக்கல் அமைப்புகள்"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ஷார்ட்கட் மூலம் பெரிதாக்குதல்"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ஷார்ட்கட் &amp; 3 முறை தட்டுவதன் மூலம் பெரிதாக்கலாம்"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> பற்றிய அறிமுகம்"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"தெளிவுத்திறன் அற்றது"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"மிகை ஒளிமாற்ற எழுத்து"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"வார்த்தையின் வண்ணத்தைக் கருப்பு/வெள்ளைக்கு மாற்றும். பின்னணியில் ஒளி மாறுபாட்டை அதிகரிக்கும்."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"வார்த்தை நிற மாறுபாட்டை அதிகரித்தல்"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"பின்னணியுடன் மாறுபாட்டை அதிகரிக்க, வார்த்தையின் வண்ணத்தைக் கருப்பு/வெள்ளைக்கு மாற்றலாம்."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"திரை உருப்பெருக்கத்தைத் தானாகப் புதுப்பி"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"ஆப்ஸ் மாற்றங்களில் திரை உருப்பெருக்கத்தைப் புதுப்பிக்கவும்"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"பவர் பட்டன் மூலம் அழைப்பை நிறுத்து"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"ஒலியளவுக்கான விசைகளைப் பிடிக்கவும்"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"திரையில் மூன்று முறை தட்டவும்"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"அணுகலம்சங்கள் ஷார்ட்கட்களைத் திருத்துதல்"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$sக்கான உங்கள் ஷார்ட்கட்டைத் தேர்வுசெய்யுங்கள்"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"தொடர்க"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"செவித்துணைக் கருவிகள்"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA மற்றும் LE ஆடியோ செவித்துணைக் கருவிகள், கோக்லியார் இம்பிளான்ட் சாதனங்கள், பிற ஒலிபெருக்கிச் சாதனங்கள் ஆகியவற்றை அமைத்து நிர்வகியுங்கள்"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"செவித்துணைக் கருவிகள் எதுவும் இணைக்கப்படவில்லை"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"செவித்துணை கருவிகளைச் சேர்க்கவும்"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"துணைக் கருவிகளை இணைத்தல்"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"செவித்துணை கருவியுடனான இணக்கத்தன்மை"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"டெலிகாயில்களுடனான இணக்கத்தன்மையை மேம்படுத்தி தேவையற்ற இரைச்சலைக் குறைக்கும்"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"செவித்துணை கருவிகள் குறித்த அறிமுகம்"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA அல்லது LE ஆடியோ ஆதரிக்காத பிற செவித்துணைக் கருவிகளைக் கண்டறிய, "<b>"புதிய சாதனத்தை இணை"</b>" &gt; "<b>"மேலும் சாதனங்களைக் காட்டு"</b>" என்பதைத் தட்டவும்"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"செவித்துணைக் கருவியை இணை"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"இந்தப் பக்கத்தில் ASHA மற்றும் LE ஆடியோ செவித்துணைக் கருவிகளை நீங்கள் இணைக்கலாம். உங்கள் செவித்துணைக் கருவி இயக்கப்பட்டு இணைப்பதற்குத் தயாராக உள்ளதை உறுதிசெய்துகொள்ளுங்கள்."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"கிடைக்கும் செவித்துணை கருவிகள்"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"மெசேஜ்கள்"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"தானியங்கு டேட்டா மாற்றம்"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"கவரேஜ் மற்றும் கிடைக்கும் நிலையைப் பொறுத்து சிம்மில் இருந்து டேட்டாவைப் பயன்படுத்தும்"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"டேட்டா மட்டும்"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"அமை"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"அடுத்து"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWBயைக் கொண்டுள்ள அருகிலுள்ள சாதனங்கள், எவ்வளவு தூரத்தில் எந்தத் திசையில் உள்ளன என்பதைக் கண்டறிய உதவுகிறது"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWBயைப் பயன்படுத்த விமானப் பயன்முறையை ஆஃப் செய்ய வேண்டும்"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"தற்போதைய இருப்பிடத்தில் UWB கிடைக்கவில்லை"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"தடையற்ற ஸ்மார்ட் வீடு அனுபவத்தைப் பெற Threadஐப் பயன்படுத்தி இணக்கமான சாதனங்களுடன் இணைக்கலாம்"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Threadஐப் பயன்படுத்த விமானப் பயன்முறையை முடக்க வேண்டும்"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"கேமரா அணுகல்"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"மைக்ரோஃபோன் அணுகல்"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ஆப்ஸுக்கும் சேவைகளுக்கும்"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"ரத்துசெய்"</string>
     <string name="contrast_title" msgid="6885768151336508075">"ஒளி மாறுபாடு"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"இயல்புநிலை"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"இயல்பு"</string>
     <string name="contrast_medium" msgid="384414510709285811">"நடுத்தரம்"</string>
     <string name="contrast_high" msgid="3988567609694797696">"அதிகம்"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"இந்த ஆப்ஸை 1 சாளரத்தில் மட்டுமே திறக்க முடியும்"</string>
diff --git a/res/values-te/arrays.xml b/res/values-te/arrays.xml
index a8ff15b..fd6ec91 100644
--- a/res/values-te/arrays.xml
+++ b/res/values-te/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"లెక్కించబడేదానిగా పరిగణించండి"</item>
     <item msgid="2047166446768045816">"లెక్కించబడనిదిగా పరిగణించండి"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ర్యాండ‌మ్‌గా రూపొందించిన MAC అడ్రస్‌ను ఉపయోగించండి (ఆటోమేటిక్‌)"</item>
-    <item msgid="741680937828608749">"పరికర MAC అడ్రస్‌ని ఉపయోగించండి"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"లేదు"</item>
     <item msgid="2163015208097377388">"అవును"</item>
diff --git a/res/values-te/strings.xml b/res/values-te/strings.xml
index 3b92d40..0b0665c 100644
--- a/res/values-te/strings.xml
+++ b/res/values-te/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"కుడి చెవి పెయిర్"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"ఎడమ చెవి పెయిర్ చేయి"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"అందుబాటులో ఉన్న అన్ని వినికిడి పరికరాల కోసం"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"మరిన్ని వినికిడి పరికర సెట్టింగ్‌లు"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"షార్ట్‌కట్, టెలికాయిల్ కంట్రోల్స్ వంటి క్రాస్-డివైజ్ సెట్టింగ్‌లను మార్చండి"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"ఈ పరికరం కోసం"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"ఆడియో అవుట్‌పుట్"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"ఆడియో అవుట్‌పుట్ గురించి"</string>
@@ -591,15 +589,14 @@
     <string name="private_space_setup_title" msgid="2272968244329821450">"ప్రైవేట్ స్పేస్"</string>
     <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"ప్రైవేట్ యాప్‌లను ప్రత్యేక స్పేస్‌లో దాచండి లేదా లాక్ చేయండి. అదనపు సెక్యూరిటీ కోసం ప్రత్యేక Google ఖాతాను ఉపయోగించండి."</string>
     <string name="private_space_setup_sub_header" msgid="5454598292017819146">"మీ ప్రైవేట్ స్పేస్‌ను సెటప్ చేయండి"</string>
-    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"మీ స్పేస్ కోసం Google ఖాతాను ఎంచుకోండి"</b>\n"డెడికేటెడ్ ఖాతాను ఉపయోగించడం ద్వారా సింక్ చేయబడిన ఫైల్స్, ఫోటోలు, అలాగే ఈమెయిల్స్ మీ స్పేస్ వెలుపల కనిపించకుండా ఆపడానికి సహాయపడుతుంది"</string>
+    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"మీ స్టోరేజీ కోసం ఒక Google ఖాతాను ఎంచుకోండి"</b>\n"నిర్దిష్టంగా కేటాయించిన ఖాతాను ఉపయోగించడం వల్ల సింక్ అయిన ఫైల్స్, ఫోటోలు, ఈమెయిల్స్ మీ స్టోరేజీని దాటి బయటకు వెళ్లకుండా ఉంటాయి."</string>
     <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"లాక్‌ను సెట్ చేయండి"</b>\n"మీ స్పేస్‌ను ఇతర వ్యక్తులు తెరవకుండా ఆపడానికి దాన్ని లాక్ చేయండి"</string>
     <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"యాప్‌లను ఇన్‌స్టాల్ చేయండి"</b>\n"మీ ప్రైవేట్ స్పేస్‌కు దాని స్వంత Play Store ఉంది కాబట్టి మీరు యాప్‌లను సులభంగా ఇన్‌స్టాల్ చేసుకోవచ్చు."</string>
     <string name="private_space_apps_permission_text" msgid="7030946025253366172">"మీ ప్రైవేట్ స్పేస్ లాక్ అయి ఉన్నప్పుడు, అందులో ఉన్న యాప్‌లు అనుమతి మేనేజర్‌లో, గోప్యతా డ్యాష్‌బోర్డ్‌లో, ఇతర సెట్టింగ్‌లలో కనిపించవు.\n\nమీ ప్రైవేట్ స్పేస్‌ను కొత్త పరికరానికి తరలించడం సాధ్యం కాదు. మీరు దానిని మరొక పరికరంలో ఉపయోగించాలంటే, మరొక ప్రైవేట్ స్పేస్‌ను సెటప్ చేయవలసి ఉంటుంది.\n\nమీ పరికరాన్ని కంప్యూటర్‌కు కనెక్ట్ చేసే లేదా మీ పరికరంలో హానికరమైన యాప్‌లను ఇన్‌స్టాల్ చేసే ఎవరైనా మీ ప్రైవేట్ స్పేస్‌ను యాక్సెస్ చేయగలరు."</string>
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"ప్రైవేట్ స్పేస్ సెటప్ ప్రోగ్రెస్‌లో ఉంది…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"ప్రైవేట్ స్పేస్ లాక్ అయ్యి ఉన్నప్పుడు, అందులోని యాప్‌ల నుండి నోటిఫికేషన్‌లు రావు"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"ప్రైవేట్ స్పేస్‌ను దాచడానికి, ఆటోమేటిక్ లాకింగ్‌ను సెటప్ చేయడానికి ప్రైవేట్ స్పేస్ సెట్టింగ్‌లను అన్వేషించండి"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"అవసరమైన యాప్‌లు ఇప్పటికే మీ ప్రైవేట్ స్పేస్‌లో ఇన్‌స్టాల్ చేయబడ్డాయి"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"ప్రైవేట్ స్పేస్‌ను సెటప్ చేయడం సాధ్యపడలేదు"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"మళ్లీ ట్రై చేయండి"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"ప్రైవేట్ స్పేస్ అన్లాకింగ్‌కు స్క్రీన్లాక్ వాడాలా?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"యాప్‌లు, నోటిఫికేషన్‌లు"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"లాక్ స్క్రీన్‌లో గోప్యమైన నోటిఫికేషన్‌లు"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"ప్రైవేట్ స్పేస్ అన్‌లాక్ చేయబడినప్పుడు సున్నితమైన కంటెంట్‌ను చూడండి"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"మీ డేటాను ప్రైవేట్‌గా ఉంచడంలో సహాయపడటానికి Google ఖాతాను క్రియేట్ చేయండి"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"తర్వాత స్క్రీన్‌లో మీరు మీ ప్రైవేట్ స్పేస్‌తో ఉపయోగించడానికి ఖాతాకు సైన్ ఇన్ చేయవచ్చు"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"ప్రైవేట్ స్పేస్ వెలుపల డేటా కనిపించకుండా చేయడంలో సహాయపడటానికి ప్రత్యేక ఖాతాను క్రియేట్ చేయండి, ఉదాహరణకు:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"సింక్ చేయబడిన ఫోటోలు, ఫైల్స్, ఈమెయిల్స్, కాంటాక్ట్‌లు, క్యాలెండర్ ఈవెంట్‌లు, ఇతర డేటా"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"యాప్ డౌన్‌లోడ్ హిస్టరీ, సిఫార్సులు"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"బ్రౌజింగ్ హిస్టరీ, బుక్‌మార్క్‌లు, సేవ్ చేసిన పాస్‌వర్డ్‌లు"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"ప్రైవేట్ స్పేస్ యాప్‌లలో మీ యాక్టివిటీకి సంబంధించి సూచించబడిన కంటెంట్"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"సరే"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"మీరు గరిష్ఠంగా <xliff:g id="COUNT">%d</xliff:g> వేలిముద్రలను జోడించవచ్చు"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"మీరు గరిష్ట సంఖ్యలో వేలిముద్రలను జోడించారు"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"మరిన్ని వేలిముద్రలను జోడించడం సాధ్యపడదు"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"మీ క్యారియర్ మిమ్మల్ని ఈ నెట్‌వర్క్‌కు కనెక్ట్ చేయడానికి అనుమతించదు ఎందుకంటే ఇది తక్కువ సురక్షితమైన పాత సెక్యూరిటీ ప్రోటోకాల్‌ను ఉపయోగిస్తుంది"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEPను అనుంతించండి"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"మూసివేయండి"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> నుండి డిస్‌కనెక్ట్ చేయాలా?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"మీరు WEP నెట్‌వర్క్‌కు కనెక్ట్ అయ్యారు. మీరు ఈ నెట్‌వర్క్‌లను బ్లాక్ చేస్తే, డిస్‌కనెక్ట్ చేయబడతారు."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"అధునాతన ఆప్షన్‌లు"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"డ్రాప్-డౌన్ లిస్ట్‌ అధునాతన ఎంపికలు"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"విస్తరించు"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"మీ నెట్‌వర్క్ కనెక్షన్‌లను మేనేజ్ చేయడానికి <xliff:g id="NEW_APP">%s</xliff:g>ని ఉపయోగించాలా?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"లొకేషన్‌ను ఇటీవల రిక్వెస్ట్ చేసినవి"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ఆఫీస్ ప్రొఫైల్ కోసం లొకేషన్"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"యాప్ లొకేషన్ అనుమతులు"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"లొకేష‌న్ ఆఫ్‌లో ఉంది"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} యాప్‌లలో # యాప్‌నకు లొకేషన్‌కు యాక్సెస్ ఉంది}other{{total} యాప్‌లలో # యాప్‌లకు లొకేషన్‌కు యాక్సెస్ ఉంది}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"స్క్రీన్‌పై కీబోర్డ్‌ను ఉపయోగించండి"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"భౌతిక కీబోర్డ్ యాక్టివ్‌గా ఉన్నప్పుడు దీన్ని స్క్రీన్‌పై ఉంచుతుంది"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"బౌన్స్ కీలు"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"కీబోర్డ్ <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> మిల్లీ సెకన్ల లోపు అదే కీని త్వరగా రిపీట్ చేస్తూ నొక్కడాన్ని విస్మరిస్తుంది"</string>
     <string name="slow_keys" msgid="2891452895499690837">"నిదానంగా పనిచేసే కీలు"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"కీని నొక్కడాన్ని <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> మిల్లీ సెకన్లకు యాక్టివేట్ చేయడానికి పట్టే సమయాన్ని మారుస్తుంది"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"స్టిక్కీ కీలు"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"షార్ట్‌కట్‌ల కోసం కీలను కలిపి హోల్డ్ చేయడానికి బదులు ఒకసారి ఒక కీని నొక్కండి"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"కీబోర్డ్ షార్ట్‌కట్‌లు"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"షార్ట్‌కట్‌ల లిస్ట్‌ను చూడండి"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"కార్యాలయ ప్రొఫైల్ కీబోర్డ్‌లు &amp; సాధనాలు"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"రీసెట్ చేయండి"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"మోడిఫయర్ కీని ఎంచుకోండి"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> కొసం కొత్త కీని ఎంచుకోండి:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ఆటోమేటిక్"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"స్పీచ్"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"పాయింటర్ వేగం"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"గేమ్ కంట్రోలర్"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"మీ అవసరాలకు అనుగుణంగా ఈ పరికరాన్ని అనుకూలంగా మార్చవచ్చు. ఈ యాక్సెసిబిలిటీ ఫీచర్లను సెట్టింగ్స్‌లో తర్వాత మార్చవచ్చు."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"ఫాంట్ సైజ్‌ను మార్చండి"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"స్క్రీన్ రీడర్"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ఫిజికల్ కీబోర్డ్ ఆప్షన్‌లు"</string>
     <string name="captions_category_title" msgid="574490148949400274">"క్యాప్షన్‌లు"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"ఆడియో"</string>
     <string name="general_category_title" msgid="6298579528716834157">"సాధారణం"</string>
     <string name="display_category_title" msgid="6638191682294461408">"డిస్‌ప్లే"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"రంగు, మోషన్"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"రంగు కాంట్రాస్ట్"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"అధిక కాంట్రాస్ట్ టెక్స్ట్, బటన్‌లు మరియు చిహ్నాలను మరింత ప్రత్యేకంగా చేస్తుంది. మీకు ఉత్తమంగా కనిపించే కాంట్రాస్ట్‌ను ఎంచుకోండి."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"కొన్ని యాప్‌లు అన్ని రంగు, టెక్స్ట్ కాంట్రాస్ట్ సెట్టింగ్‌లకు సపోర్ట్ చేయకపోవచ్చు"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"మీ స్క్రీన్ బ్యాక్‌గ్రౌండ్ రంగుకు వ్యతిరేకంగా రంగులు, టెక్స్ట్ ఎలా కనిపించాలో సర్దుబాటు చేయండి"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"ప్రివ్యూ"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"హెలెన్, ఆడమ్"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 రోజుల క్రితం"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ఫాలోఅప్ చేయాలా?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"బిజినెస్ ట్రిప్ రిపోర్ట్"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"తదుపరి సహాయం కోసం, దయచేసి నన్ను లేదా హెలెన్‌ను \nసంప్రదించండి. ఈ రిపోర్ట్"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"క్లయింట్ ఖర్చులు"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"స్క్రీన్‌ను ముదురు రంగులో కనిపించేలా చేయండి"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ఇంటరాక్షన్ కంట్రోల్స్"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"టైమింగ్ కంట్రోల్స్"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"ఏదేమైనా కొనసాగించండి"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"రద్దు చేయండి"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"మ్యాగ్నిఫికేషన్ సెట్టింగ్‌లు"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"షార్ట్‌కట్‌తో మ్యాగ్నిఫై చేయండి"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"షార్ట్‌కట్‌తో, మూడుసార్లు నొక్కి మ్యాగ్నిఫై చేయండి"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"\'<xliff:g id="SERVICE">%1$s</xliff:g>\' పరిచయం"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"పారదర్శకం కాని"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"అధిక కాంట్రాస్ట్ టెక్స్ట్"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"టెక్స్ట్ రంగును నలుపు లేదా తెలుపు రంగుకు మార్చండి. బ్యాక్‌గ్రౌండ్‌తో కాంట్రాస్ట్‌ను పెంచుతుంది."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"టెక్స్ట్ కాంట్రాస్ట్‌ను పెంచండి"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"బ్యాక్‌గ్రౌండ్‌తో కాంట్రాస్ట్‌ను పెంచడానికి టెక్స్ట్ రంగును నలుపు లేదా తెలుపు రంగుకు మార్చండి."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"స్క్రీన్ వర్ధనాన్ని ఆటోమేటిక్‌గా అప్‌డేట్ చేయండి"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"యాప్‌ పరివర్తనాల్లో స్క్రీన్ వర్ధనాన్ని అప్‌డేట్ చేయండి"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"పవర్ బటన్ కాల్‌ను ముగిస్తుంది"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"వాల్యూమ్ కీలను నొక్కి, ఉంచడం"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"స్క్రీన్‌పై మూడు సార్ల నొక్కడం"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"యాక్సెసిబిలిటీ షార్ట్‌కట్‌లను ఎడిట్ చేయండి"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s కోసం మీ షార్ట్‌కట్‌ను ఎంచుకోండి"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"కొనసాగించండి"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"వినికిడి పరికరాలు"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA, LE ఆడియో వినికిడి పరికరాలు, కోక్లియర్ ఇంప్లాంట్‌లు, అలాగే ఇతర యాంప్లిఫికేషన్ పరికరాలను సెటప్ చేసి, మేనేజ్ చేయండి"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"వినికిడి పరికరాలు కనెక్ట్ కాలేదు"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"వినికిడి మద్దతు ఉపకరణాలను జోడించండి"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"వినికిడి పరికరాల పెయిర్"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"వినికిడి పరికరంతో అనుకూలత"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"టెలికాయిల్స్‌తో అనుకూలతను మెరుగుపరుస్తుంది, అవాంఛిత శబ్దాన్ని తగ్గిస్తుంది"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"వినికిడి పరికరాల గురించి పరిచయం"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA లేదా LE ఆడియో సపోర్ట్ చేయని ఇతర వినికిడి పరికరాలను కనుగొనడానికి, "<b>"కొత్త పరికరాన్ని పెయిర్ చేయండి"</b>" &gt; "<b>"మరిన్ని పరికరాలను చూడండి"</b>"ని ట్యాప్ చేయండి"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"వినికిడి పరికరాన్ని పెయిర్ చేయండి"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"మీరు ఈ పేజీలో ASHA, LE ఆడియో వినికిడి పరికరాలను పెయిర్ చేయవచ్చు. మీ వినికిడి పరికరం ఆన్ చేయబడిందని, పెయిర్ చేయడానికి సిద్ధంగా ఉందని నిర్ధారించుకోండి."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"అందుబాటులోని వినికిడి పరికరాలు"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"టెక్స్ట్‌లు"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"ఆటోమేటిక్‌గా డేటాను మార్చడం"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"కవరేజ్, లభ్యత ఆధారంగా ఏదైనా SIM నుండి డేటాను ఉపయోగించండి"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"డేటా మాత్రమే"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"సెటప్ చేయండి"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"తర్వాత"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"UWBని కలిగి ఉన్న సమీపంలోని పరికరాల సంబంధిత స్థానాన్ని గుర్తించడంలో సహాయపడుతుంది"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWBని ఉపయోగించడానికి విమానం మోడ్‌ను ఆఫ్ చేయండి"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"ప్రస్తుత లొకేషన్‌లో UWB అందుబాటులో లేదు"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"అంతరాయం లేని స్మార్ట్ హోమ్ ఎక్స్‌పెరియన్స్ కోసం Threadను ఉపయోగించి అనుకూల పరికరాలకు కనెక్ట్ చేయండి"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Threadను ఉపయోగించడానికి విమానం మోడ్‌ను ఆఫ్ చేయండి"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"కెమెరా యాక్సెస్"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"మైక్రోఫోన్ యాక్సెస్"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"యాప్‌లు, సర్వీస్‌ల కోసం"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"రద్దు చేయండి"</string>
     <string name="contrast_title" msgid="6885768151336508075">"కాంట్రాస్ట్"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"స్టాండర్డ్"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ఆటోమేటిక్ సెట్టింగ్"</string>
     <string name="contrast_medium" msgid="384414510709285811">"మధ్యస్థం"</string>
     <string name="contrast_high" msgid="3988567609694797696">"అధికం"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"ఈ యాప్‌ను 1 విండోలో మాత్రమే తెరవవచ్చు"</string>
diff --git a/res/values-th/arrays.xml b/res/values-th/arrays.xml
index b152cc0..c5d5457 100644
--- a/res/values-th/arrays.xml
+++ b/res/values-th/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"ถือว่ามีการจำกัดปริมาณอินเทอร์เน็ต"</item>
     <item msgid="2047166446768045816">"ถือว่าไม่มีการจำกัดปริมาณอินเทอร์เน็ต"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"ใช้ที่อยู่ MAC แบบสุ่ม (ค่าเริ่มต้น)"</item>
-    <item msgid="741680937828608749">"ใช้ที่อยู่ MAC ของอุปกรณ์"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"ไม่"</item>
     <item msgid="2163015208097377388">"ใช่"</item>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 1d949fa..7244d70 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"จับคู่หูฟังข้างขวา"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"จับคู่หูฟังข้างซ้าย"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"สำหรับเครื่องช่วยฟังทั้งหมดที่พร้อมใช้งาน"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"การตั้งค่าเครื่องช่วยฟังเพิ่มเติม"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"เปลี่ยนการตั้งค่าข้ามอุปกรณ์ เช่น การควบคุมทางลัดและเทเลคอยล์"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"สำหรับอุปกรณ์นี้"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"เอาต์พุตเสียง"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"เกี่ยวกับเอาต์พุตเสียง"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"กำลังตั้งค่าพื้นที่ส่วนตัว…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"การแจ้งเตือนจากแอปในพื้นที่ส่วนตัวจะถูกซ่อนเมื่อล็อกไว้"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"สำรวจการตั้งค่าพื้นที่ส่วนตัวเพื่อซ่อนพื้นที่ส่วนตัวและตั้งค่าการล็อกอัตโนมัติ"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"แอปที่จำเป็นได้รับการติดตั้งในพื้นที่ส่วนตัวอยู่แล้ว"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"ตั้งค่าพื้นที่ส่วนตัวไม่ได้"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"ลองอีกครั้ง"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"ใช้การล็อกหน้าจอเพื่อปลดล็อกพื้นที่ส่วนตัวใช่ไหม"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"แอปและการแจ้งเตือน"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"การแจ้งเตือนที่มีความละเอียดอ่อนบนหน้าจอล็อก"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"แสดงเนื้อหาที่ละเอียดอ่อนเมื่อพื้นที่ส่วนตัวปลดล็อกอยู่"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"สร้างบัญชี Google เพื่อช่วยรักษาข้อมูลของคุณให้เป็นส่วนตัว"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"คุณจะลงชื่อเข้าใช้บัญชีเพื่อใช้กับพื้นที่ส่วนตัวได้ในหน้าจอถัดไป"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"สร้างบัญชีเฉพาะเพื่อช่วยไม่ให้ข้อมูลปรากฏนอกพื้นที่ส่วนตัว เช่น"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"รูปภาพ ไฟล์ อีเมล รายชื่อติดต่อ กิจกรรมในปฏิทิน และข้อมูลอื่นๆ ที่ซิงค์ไว้"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"ประวัติและคำแนะนำในการดาวน์โหลดแอป"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"ประวัติการท่องเว็บ บุ๊กมาร์ก และรหัสผ่านที่บันทึกไว้"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"เนื้อหาแนะนำที่เกี่ยวข้องกับกิจกรรมของคุณในแอปพื้นที่ส่วนตัว"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"รับทราบ"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"คุณสามารถเพิ่มได้ถึง <xliff:g id="COUNT">%d</xliff:g> ลายนิ้วมือ"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"คุณได้เพิ่มลายนิ้วมือถึงขีดจำกัดสูงสุดแล้ว"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"เพิ่มลายนิ้วมืออีกไม่ได้แล้ว"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"ผู้ให้บริการของคุณไม่อนุญาตให้เชื่อมต่อกับเครือข่ายนี้เนื่องจากใช้โปรโตคอลความปลอดภัยเวอร์ชันเก่าซึ่งมีความปลอดภัยน้อยกว่า"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"อนุญาต WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"ปิด"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"ยกเลิกการเชื่อมต่อกับ <xliff:g id="NAME">%1$s</xliff:g> ไหม"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"คุณเชื่อมต่อกับเครือข่าย WEP อยู่ หากคุณบล็อกเครือข่ายเหล่านี้ ระบบจะยกเลิกการเชื่อมต่อคุณ"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"ตัวเลือกขั้นสูง"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ตัวเลือกขั้นสูงที่เป็นรายการแบบเลื่อนลง"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"ขยาย"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"ใช้ <xliff:g id="NEW_APP">%s</xliff:g> ในการจัดการการเชื่อมต่อเครือข่ายใช่ไหม"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"คำขอตำแหน่งล่าสุด"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"ตำแหน่งสำหรับโปรไฟล์งาน"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"สิทธิ์เข้าถึงตำแหน่งสำหรับแอป"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"ตำแหน่งปิดอยู่"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# จาก {total} แอปมีสิทธิ์เข้าถึงตำแหน่ง}other{# จาก {total} แอปมีสิทธิ์เข้าถึงตำแหน่ง}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"ใช้แป้นพิมพ์บนหน้าจอ"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"เปิดทิ้งไว้บนหน้าจอในระหว่างใช้งานแป้นพิมพ์จริง"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"คีย์ตีกลับ"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"แป้นพิมพ์จะละเว้นการกดคีย์เดียวกันซ้ำๆ อย่างรวดเร็วภายใน <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> มิลลิวินาที"</string>
     <string name="slow_keys" msgid="2891452895499690837">"เพิ่มระยะเวลาในการกดปุ่ม"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"ปรับเวลาที่ใช้ในการกดคีย์เพื่อเปิดใช้เป็น <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> มิลลิวินาที"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"คีย์ติดหนึบ"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"กดทีละปุ่มเพื่อใช้แป้นพิมพ์ลัดแทนการกดปุ่มค้างไว้พร้อมกัน"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"แป้นพิมพ์ลัด"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"แสดงรายการแป้นพิมพ์ลัด"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"แป้นพิมพ์และเครื่องมือของโปรไฟล์งาน"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"รีเซ็ต"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"เลือกแป้นกดร่วม"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"เลือกคีย์ใหม่สำหรับ <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"เลย์เอาต์ <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ค่าเริ่มต้น"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"อัตโนมัติ: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"ผู้ใช้เลือก: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"เสียงพูด"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"ความเร็วของตัวชี้"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"อุปกรณ์ควบคุมเกม"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"คุณปรับแต่งอุปกรณ์นี้ให้ตรงกับความต้องการได้ และเปลี่ยนฟีเจอร์การช่วยเหลือพิเศษเหล่านี้ได้ภายหลังในการตั้งค่า"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"เปลี่ยนขนาดแบบอักษร"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"โปรแกรมอ่านหน้าจอ"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"ตัวเลือกแป้มพิมพ์จริง"</string>
     <string name="captions_category_title" msgid="574490148949400274">"คำบรรยายแทนเสียง"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"เสียง"</string>
     <string name="general_category_title" msgid="6298579528716834157">"ทั่วไป"</string>
     <string name="display_category_title" msgid="6638191682294461408">"การแสดงผล"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"สีและการเคลื่อนไหว"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"คอนทราสต์ของสี"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"คอนทราสต์ที่สูงขึ้นทำให้ข้อความ ปุ่ม และไอคอนโดดเด่นกว่าเดิม เลือกคอนทราสต์ที่เหมาะกับคุณที่สุด"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"บางแอปอาจไม่รองรับการตั้งค่าคอนทราสต์ของสีและข้อความบางรูปแบบ"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"ปรับการแสดงสีและข้อความให้ตัดกับสีพื้นหลังของหน้าจอ"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"ตัวอย่าง"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 วันที่แล้ว"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"ติดตามผลไหม"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"รายงานการเดินทางเพื่อธุรกิจ"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"หากต้องการความช่วยเหลือเพิ่มเติม โปรดติดต่อมาที่\nฉันหรือ Helen รายงานนี้จะ"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Client Expenses"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"ปรับแสงหน้าจอให้มืดลง"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"ส่วนควบคุมการโต้ตอบ"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"การควบคุมเวลา"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"ดำเนินการต่อ"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"ยกเลิก"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"การตั้งค่าการขยาย"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"ขยายโดยใช้ทางลัด"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"ขยายโดยใช้ทางลัดและการแตะ 3 ครั้ง"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"เกี่ยวกับ \"<xliff:g id="SERVICE">%1$s</xliff:g>\""</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"ไม่โปร่งใส"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"ข้อความคอนทราสต์สูง"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"เปลี่ยนสีข้อความเป็นสีดำหรือสีขาว เพิ่มความ​คอนทราสต์เมื่อเทียบกับพื้นหลังให้สูงสุด"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"เพิ่มคอนทราสต์ของข้อความให้สูงสุด"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"เปลี่ยนสีข้อความเป็นสีดำหรือสีขาวเพื่อเพิ่มคอนทราสต์กับพื้นหลัง"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"อัปเดตการขยายหน้าจอโดยอัตโนมัติ"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"อัปเดตการขยายหน้าจอเมื่อเปลี่ยนแอปพลิเคชัน"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"กดปุ่มเปิด/ปิดเพื่อวางสาย"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"กดปุ่มปรับระดับเสียงค้างไว้"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"แตะหน้าจอ 3 ครั้ง"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"แก้ไขทางลัดสำหรับการช่วยเหลือพิเศษ"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"เลือกแป้มพิมพ์ลัดสำหรับ %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"ต่อไป"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"เครื่องช่วยฟัง"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ตั้งค่าและจัดการเครื่องช่วยฟังของ ASHA และLE Audio, ประสาทหูเทียม และอุปกรณ์ขยายเสียงอื่ยๆ"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"ไม่ได้เชื่อมต่อเครื่องช่วยฟังไว้"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"เพิ่มเครื่องช่วยฟัง"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"จับคู่เครื่องช่วยฟัง"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"ความเข้ากันได้กับเครื่องช่วยฟัง"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ปรับปรุงความเข้ากันได้ด้วยเทเลคอยล์และลดเสียงรบกวนที่ไม่พึงประสงค์"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"เกี่ยวกับเครื่องช่วยฟัง"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"หากต้องการค้นหาเครื่องช่วยฟังอื่นๆ ที่ ASHA หรือ LE Audio ไม่รองรับ ให้แตะ"<b>"จับคู่อุปกรณ์ใหม่"</b>"และ"<b>"ดูอุปกรณ์เพิ่มเติม"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"จับคู่เครื่องช่วยฟัง"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"คุณสามารถจับคู่เครื่องช่วยฟัง ASHA และ LE Audio ในหน้านี้ ตรวจสอบว่าเครื่องช่วยฟังเปิดอยู่และพร้อมจับคู่แล้ว"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"เครื่องช่วยฟังที่พร้อมใช้งาน"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ข้อความ"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"การเปลี่ยนการเชื่อมต่ออินเทอร์เน็ตอัตโนมัติ"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"ใช้การเชื่อมต่ออินเทอร์เน็ตจากซิมใดก็ได้โดยขึ้นอยู่กับการครอบคลุมและความพร้อมใช้งาน"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"ใช้เชื่อมต่ออินเทอร์เน็ตเท่านั้น"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"ตั้งค่า"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"ถัดไป"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"ช่วยระบุตำแหน่งซึ่งสัมพัทธ์กับอุปกรณ์ใกล้เคียงที่มี UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"ปิดโหมดบนเครื่องบินเพื่อใช้ UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB ไม่พร้อมใช้งานในตำแหน่งปัจจุบัน"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"เชื่อมต่อกับอุปกรณ์ที่เข้ากันได้โดยใช้ Thread เพื่อประสบการณ์ใช้งานสมาร์ทโฮมที่ราบรื่น"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"ปิดโหมดบนเครื่องบินเพื่อใช้ Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"สิทธิ์เข้าถึงกล้อง"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"สิทธิ์เข้าถึงไมโครโฟน"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"สำหรับแอปและบริการ"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"ยกเลิก"</string>
     <string name="contrast_title" msgid="6885768151336508075">"คอนทราสต์"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"มาตรฐาน"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"ค่าเริ่มต้น"</string>
     <string name="contrast_medium" msgid="384414510709285811">"ปานกลาง"</string>
     <string name="contrast_high" msgid="3988567609694797696">"สูง"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"แอปนี้เปิดได้ใน 1 หน้าต่างเท่านั้น"</string>
diff --git a/res/values-tl/arrays.xml b/res/values-tl/arrays.xml
index 65183a2..cca3a6b 100644
--- a/res/values-tl/arrays.xml
+++ b/res/values-tl/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Ituring bilang nakametro"</item>
     <item msgid="2047166446768045816">"Ituring bilang hindi nakametro"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Gamitin ang na-randomize na MAC (default)"</item>
-    <item msgid="741680937828608749">"Gamitin ang device MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Hindi"</item>
     <item msgid="2163015208097377388">"Oo"</item>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index 0035783..41c6587 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Ipares ang kanan"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Ipares ang kaliwa"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Para sa lahat ng available na hearing device"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Higit pang setting ng hearing device"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Baguhin ang mga setting ng cross-device tulad ng shortcut, at mga kontrol sa telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Para sa device na ito"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio output"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Tungkol sa audio output"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Sine-set up ang pribadong space…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Nakatago ang mga notification mula sa mga app sa pribadong space kapag naka-lock ito"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"I-explore ang mga setting ng pribadong space para itago ang pribadong space at mag-set up ng awtomatikong pag-lock"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Naka-install na ang mga kinakailangang app sa iyong pribadong space"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Hindi na-set up ang pribadong space"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Subukan Ulit"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Gamitin ang lock ng screen para i-unlock ang pribadong space?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Mga app at notification"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Mga notification ng sensitibong content sa lock screen"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Ipakita ang sensitibong content kapag naka-unlock ang pribadong space"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Gumawa ng Google Account para matulungan kang panatilihing pribado ang iyong data"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Sa susunod na screen, puwede kang mag-sign in sa account na gagamitin sa iyong pribadong space"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Gumawa ng nakalaang account para makatulong sa paghinto ng paglabas ng data sa labas ng pribadong space, gaya ng:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Mga naka-sync na larawan, file, email, contact, event sa kalendaryo, at iba pang data"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"History at rekomendasyon sa pag-download ng app"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"History ng pag-browse, bookmark, at naka-save na password"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Iminumungkahing content na nauugnay sa iyong aktibidad sa mga pribadong space na app"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Puwede kang magdagdag ng hanggang <xliff:g id="COUNT">%d</xliff:g> (na) fingerprint"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Naidagdag mo na ang maximum na bilang ng mga fingerprint"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Hindi na makapagdagdag ng higit pang fingerprint"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Hindi ka pinapayagan ng iyong carrier na kumonekta sa network na ito dahil gumagamit ito ng mas lumang protocol ng seguridad na hindi gaanong secure"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Payagan ang WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Isara"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Magdiskonekta sa <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Sa isang WEP network ka nakakonekta. Kung iba-block mo ang mga network na ito, madidiskonekta ka."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Mga advanced na opsyon"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Mga Advanced na Opsyon sa drop down na listahan"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"i-expand"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Gamitin ang <xliff:g id="NEW_APP">%s</xliff:g> upang pamahalaan ang iyong mga koneksyon sa network?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Kamakailang hiling sa lokasyon"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokayon ng profile sa trabaho"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Pahintulot sa lokasyon ng app"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Naka-off ang lokasyon"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# sa {total} app ang may access sa lokasyon}one{# sa {total} app ang may access sa lokasyon}other{# sa {total} na app ang may access sa lokasyon}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Gumamit ng on-screen na keyboard"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Panatilihin ito sa screen habang aktibo ang pisikal na keyboard"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Mga bounce key"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Binabalewala ng keyboard ang mabilis na paulit-ulit na pagpindot sa parehong key sa loob ng <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Mga slow key"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Ina-adjust sa <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms kung gaano dapat katagal pindutin ang key para mag-activate"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Mga sticky key"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Paisa-isang pumindot ng key para sa mga shortcut sa halip na sabay-sabay na pindutin ang mga key"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Mga keyboard shortcut"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Ipakita ang listahan ng mga shortcut"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Mga keyboard at tool ng profile sa trabaho"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"I-reset"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Pumili ng modifier key"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Pumili ng bagong key para sa <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Layout na <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Default"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Awtomatiko: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Napiling user: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Pagsasalita"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Bilis ng pointer"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Game Controller"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Maaari mong i-customize ang device na ito upang maging angkop sa iyong mga pangangailangan. Maaaring baguhin ang mga feature sa accessibility na ito sa ibang pagkakataon sa Mga Setting."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Baguhin ang laki ng font"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Screen reader"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Mga opsyon sa pisikal na keyboard"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Mga Caption"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Pangkalahatan"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Display"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Kulay at paggalaw"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contrast ng kulay"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Pinapatingkad ng mas mataas na contrast ang text, mga button, at mga icon. Piliin ang contrast na pinakamainam para sa iyo."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Posibleng hindi sinusuportahan ng ilang app ang lahat ng setting ng contrast ng kulay at text"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"I-adjust ang hitsura ng mga kulay at text kumpara sa kulay ng background ng iyong screen"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Preview"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Nakalipas na 2 araw"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"I-follow up?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Ulat sa biyahe sa negosyo"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Para sa karagdagang tulong, makipag-ugnayan sa \nakin o kay Helen. Ang ulat na ito ay"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Mga Gastos ng Kliyente"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Gawing mas madilim ang screen"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Mga kontrol ng pakikipag-ugnayan"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Mga kontrol sa timing"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Magpatuloy pa rin"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Kanselahin"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Mga setting ng pag-magnify"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Mag-magnify gamit ang shortcut"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Mag-magnify gamit ang shortcut at pag-triple tap"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Tungkol sa <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Hindi transparent"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text na high contrast"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Gawing itim o puti ang kulay ng text. Nagpapaigting ng contrast sa background."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"I-maximize ang contrast ng text"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Baguhin ang kulay ng text sa itim o puti para madagdagan ang contrast sa background."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"I-auto update pag-magnify ng screen"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"I-update pag-magnify ng screen sa app transition"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Tatapusin ng power button ang tawag"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"I-hold ang mga volume key"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"I-triple tap ang screen"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"I-edit ang mga shortcut sa accessibility"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Piliin ang iyong shortcut para sa %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Magpatuloy"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Mga hearing device"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Mag-set up at mamahala ng mga ASHA at LE Audio na hearing aid, cochlear implant, at iba pang amplification device"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Walang nakakonektang hearing device"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Magdagdag ng mga hearing aid"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Ipares ang hearing aid"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibility ng hearing aid"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Pinapahusay ang compatibility sa mga telecoil at binabawasan ang hindi gustong ingay"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Tungkol sa mga hearing device"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Para makahanap ng iba pang hearing device na hindi sinusuportahan ng ASHA o LE Audio, i-tap ang "<b>"Magpares ng bagong device"</b>" &gt; "<b>"Tumingin ng higit pang device"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Magpares ng hearing device"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Puwede mong ipares ang mga ASHA at LE Audio hearing device sa page na ito. Tiyaking naka-on at handang ipares ang iyong hearing device."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Available na hearing device"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mga Text"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Awtomatikong paglipat ng data"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Gumamit ng data mula sa alinmang SIM depende sa sakop at availability"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Data lang"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"I-set up"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Susunod"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Nakakatulong sa pagtukoy ng relatibong posisyon ng mga kalapit na device na may UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"I-off ang airplane mode para magamit ang UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Hindi available sa kasalukuyang lokasyon ang UWB"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Kumonekta sa mga compatible na device gamit ang Thread para sa seamless na experience sa smart na tahanan"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"I-off ang airplane mode para magamit ang Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Access sa camera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Access sa mikropono"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Para sa mga app at serbisyo"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Kanselahin"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Contrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Default"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Katamtaman"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Mataas"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Sa 1 window lang puwedeng buksan ang app na ito"</string>
diff --git a/res/values-tr/arrays.xml b/res/values-tr/arrays.xml
index aadd3bb..8545083 100644
--- a/res/values-tr/arrays.xml
+++ b/res/values-tr/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Sayaçlı gibi kullan"</item>
     <item msgid="2047166446768045816">"Sayaçsız gibi kullan"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Rastgele MAC adresi kullan (varsayılan)"</item>
-    <item msgid="741680937828608749">"Cihazın MAC adresini kullan"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Hayır"</item>
     <item msgid="2163015208097377388">"Evet"</item>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 8dc8e8b..883c940 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Sağ kulağı eşle"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Sol kulağı eşle"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Mevcut tüm işitme cihazları için"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Diğer işitme cihazı ayarları"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Kısayol ve T bobini kontrolleri gibi cihazlar arası ayarları değiştirin"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Bu cihaz için"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Ses çıkışı"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Ses çıkışı hakkında"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Özel alan kuruluyor…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Kilitli olduğunda özel alan uygulamalarının gönderdiği bildirimler gizlenir"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Özel alanı gizlemek ve otomatik kilitlemeyi ayarlamak için özel alan ayarlarını keşfedin"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Gerekli uygulamalar, özel alanınıza önceden yüklenmiştir"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Özel alan kurulamadı"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Tekrar Dene"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Özel alanın kilidini açmak için ekran kilidi kullanılsın mı?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Uygulamalar ve bildirimler"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Kilit ekranındaki hassas bildirimler"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Özel alanın kilidi açıldığında hassas içerikleri göster"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Verilerinizin gizliliğini korumak için bir Google Hesabı oluşturun"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Sonraki ekranda özel alanınızda kullanacağınız hesapta oturum açabilirsiniz"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Aşağıdaki gibi verilerin özel alan dışında görünmesini durduracak özel bir hesap oluşturun:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Senkronize edilmiş fotoğraf, dosya, e-posta, kişi, takvim etkinliği ve diğer veriler"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Uygulama indirme geçmişi ve öneriler"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Tarama geçmişi, yer işaretleri ve kayıtlı şifreler"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Özel alan uygulamalarındaki etkinliğinizle ilgili önerilen içerik"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Anladım"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"<xliff:g id="COUNT">%d</xliff:g> adede kadar parmak izi ekleyebilirsiniz"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Maksimum sayıda parmak izi eklediniz"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Daha fazla parmak izi eklenemez"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operatörünüz, güvenliği düşük eski bir güvenlik protokolü kullandığından bu ağa bağlanmanıza izin vermiyor"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP\'e izin ver"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Kapat"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> bağlantısı kesilsin mi?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP ağına bağlısınız. Bu ağları engellerseniz bağlantınız kesilir."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Gelişmiş seçenekler"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Açılır liste Gelişmiş Seçenekler"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"genişlet"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Ağ bağlantılarınızı yönetmek için <xliff:g id="NEW_APP">%s</xliff:g> kullanılsın mı?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Son konum istekleri"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"İş profili konumu"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Uygulama konum izinleri"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Konum özelliği kapalı"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{#/{total} uygulamanın konuma erişimi var}other{#/{total} uygulamanın konuma erişimi var}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Ekran klavyesi kullan"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Fiziksel klavye etkin durumdayken ekranda tut"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Geri sekme tuşları"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Klavye, aynı tuşa <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms. içinde hızlı bir şekilde tekrarlanan basma işlemlerini yoksayar"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Yavaş tuşlar"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Bir tuşa basma işleminin etkinleştirileceği süreyi <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms. olarak ayarlar"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Yapışkan tuşlar"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Tuşları aynı anda basılı tutmak yerine kısayollar için tek seferde bir tuşa basın"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klavye kısayolları"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Kısayol listesini göster"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"İş profili klavyeleri ve araçları"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Sıfırla"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Değiştirici tuşu seçin"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> için yeni bir tuş seçin:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> düzeni"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Varsayılan"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Otomatik: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Kullanıcı tarafından <xliff:g id="LAYOUT_LABEL">%s</xliff:g> seçildi"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Konuşma"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"İşaretçi hızı"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Oyun Denetleyici"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Bu cihazı ihtiyaçlarınıza uygun şekilde özelleştirebilirsiniz. Bu erişilebilirlik özellikleri daha sonra Ayarlar\'dan değiştirilebilir."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Yazı tipi boyutunu değiştir"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekran okuyucu"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Fiziksel klavye seçenekleri"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Altyazılar"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Ses"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Genel"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Ekran"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Renk ve hareket"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Renk kontrastı"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Kontrast daha yüksek olduğunda metinler, düğmeler ve simgeler daha belirgin hale gelir. Kendinize en uygun kontrastı seçin."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Bazı uygulamalar tüm renk ve metin kontrastı ayarlarını desteklemiyor olabilir"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Renklerin ve metnin, ekranınızın arka plan rengine göre nasıl görüneceğini ayarlayın"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Önizleme"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 gün önce"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Takip edilsin mi?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"İş gezisi raporu"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Daha fazla yardım almak için lütfen \nbana veya Helen\'a ulaşın. Bu rapor"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Müşteri Masrafları"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekranı koyulaştır"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Etkileşim denetimleri"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Zamanlama kontrolleri"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Yine de devam et"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"İptal"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Büyütme ayarları"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Kısayolla büyütme"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Kısayolla ve üç kez dokunarak büyütme"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> hakkında"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Opak"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Yüksek kontrastlı metin"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Metin rengini siyah veya beyaz olarak değiştirin. Arka planla kontrast en üst düzeye çıkar."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Metin kontrastını maksimuma çıkarın"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Arka plandaki kontrastı artırmak için metin rengini siyah veya beyaz olarak değiştirin."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ekran büyütmeyi otomatik güncelle"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Uygulama geçişlerinde ekran büyütmeyi güncelle"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Güç düğmesi çağrıyı sonlandırır"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Ses seviyesi tuşlarını basılı tut"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Ekrana üç kez dokun"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Erişilebilirlik kısayollarını düzenleyin"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s kısayolunuzu seçin"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Devam"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"İşitme cihazları"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA ve LE Audio işitme cihazları, koklear implantları ve diğer ses yükseltme cihazlarını kurup yönetin"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Bağlı işitme cihazı yok"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"İşitme cihazı ekle"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"İşitme cihazlarını eşleyin"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"İşitme cihazı uyumluluğu"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Telecoil\'lerle uyumluluğu artırır ve istenmeyen gürültüyü azaltır"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"İşitme cihazları hakkında"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA veya LE Audio tarafından desteklenmeyen diğer işitme cihazlarını bulmak için "<b>"Yeni cihaz eşle"</b>" &gt; "<b>"Diğer cihazlara bakın"</b>" seçeneğine dokunun"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"İşitme cihazı eşleme"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"ASHA ve LE Audio işitme cihazlarını bu sayfada eşleyebilirsiniz. İşitme cihazınızın açık ve eşlenmeye hazır olduğundan emin olun."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Mevcut işitme cihazları"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Kısa mesajlar"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Otomatik veri geçişi"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Kapsam alanına ve kullanılabilirliğe bağlı olarak iki SIM\'den birindeki verileri kullanın"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Yalnızca veri"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Ayarla"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Sonraki"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Ultra Geniş Bant özelliğine sahip yakındaki cihazların göreli konumunu belirlemeye yardımcı olur"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Ultra Geniş Bant\'ı kullanmak için uçak modunu kapatın"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Ultra Geniş Bant geçerli konumda kullanılamaz"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Sorunsuz bir akıllı ev deneyimi için uyumlu cihazlara Thread kullanarak bağlanın"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread\'i kullanmak için uçak modunu kapatın"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kamera erişimi"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofon erişimi"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Uygulamalar ve hizmetler için"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"İptal"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standart"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Varsayılan"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Orta"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Yüksek"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Bu uygulama yalnızca 1 pencerede açılabilir"</string>
diff --git a/res/values-uk/arrays.xml b/res/values-uk/arrays.xml
index 3e3d152..cfbf474 100644
--- a/res/values-uk/arrays.xml
+++ b/res/values-uk/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Вважати тарифікованою"</item>
     <item msgid="2047166446768045816">"Вважати нетарифікованою"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Довільна MAC-адреса (за умовчанням)"</item>
-    <item msgid="741680937828608749">"MAC-адреса пристрою"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Ні"</item>
     <item msgid="2163015208097377388">"Так"</item>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index ed6a89e..cee25b2 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Підключити правий"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Підключити лівий"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Для всіх доступних слухових апаратів"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Інші налаштування слухового апарата"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Змінюйте налаштування для кількох пристроїв, наприклад швидкі команди й елементи керування індукційною котушкою"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Для цього пристрою"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Аудіовихід"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Про аудіовихід"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Налаштування приватного простору…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Сповіщення з додатків приватного простору приховуються, коли його заблоковано"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Перегляньте налаштування приватного простору, щоб приховати його й налаштувати автоматичне блокування"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Обов’язкові додатки вже встановлено в приватному просторі"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Не вдалося налаштувати приватний простір"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Повторити"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Викор. сп. розбл. екрана для розбл. пр. простору?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Додатки й сповіщення"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Чутливі сповіщення на заблокованому екрані"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Показувати контент делікатного характеру, коли приватний простір розблоковано"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Створіть обліковий запис Google, щоб забезпечити конфіденційність даних"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"На наступному екрані ввійдіть в обліковий запис, який використовуватиметься для приватного простору"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Створіть окремий обліковий запис, щоб дані не синхронізувалися за межами приватного простору, наприклад:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Синхронізовані фотографії, файли, електронні листи, контакти, події в календарі тощо"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Історія завантажень додатків і рекомендації"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Історія вебперегляду, закладки й збережені паролі"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Пропонований контент, пов’язаний із вашими діями в додатках приватного простору"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Можна додати максимум стільки відбитків: <xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Ви додали максимальну кількість відбитків пальців"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Більше не можна додати відбитки пальців"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Ваш оператор не дозволяє підключатися до цієї мережі, оскільки в ній використовується застарілий (менш надійний) протокол безпеки"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Дозволити WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Закрити"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Від’єднатися від мережі \"<xliff:g id="NAME">%1$s</xliff:g>\"?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Вас підключено до мережі з алгоритмом безпеки WEP. Якщо ви заблокуєте такі мережі, з’єднання перерветься."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Додаткові параметри"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Спадний список додаткових параметрів"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"розгорнути"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Використовувати <xliff:g id="NEW_APP">%s</xliff:g> для керування з’єднаннями?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Останні запити на геодані"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Геодані для робочого профілю"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Доступ додатків до геоданих"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Передавання геоданих вимкнено"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# додаток із {total} має доступ до геоданих}one{# додаток із {total} має доступ до геоданих}few{# додатки із {total} мають доступ до геоданих}many{# додатків із {total} мають доступ до геоданих}other{# додатка із {total} мають доступ до геоданих}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Використовувати екранну клавіатуру"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Залишати її на екрані, коли активна фізична клавіатура"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Ігнорувати повторне натискання"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Клавіатура ігнорує кілька натискань однієї клавіші протягом <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> мс"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Повільні клавіші"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Установлює проміжок часу, через який клавіша реагує на натискання: <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> мс"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Залипання клавіш"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Натискайте клавіші по одній, замість того щоб утримувати їх одночасно"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Комбінації клавіш"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Показати список комбінацій клавіш"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Клавіатури та інструменти робочого профілю"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Скинути"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Вибрати клавішу-модифікатор"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Виберіть нову клавішу для <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"За умовчанням"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Мовлення"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Швидкість курсора"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Ігровий контролер"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Ви можете налаштувати цей пристрій для своїх потреб. Ці функції доступності можна пізніше змінити в налаштуваннях."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Змінити розмір шрифту"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Програма зчитування з екрана"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Опції фізичної клавіатури"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Cубтитри"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Аудіо"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Загальні"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Екран"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Кольори та зйомка в русі"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Контраст кольорів"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Якщо збільшити контраст, текст, кнопки й значки більше виділятимуться. Виберіть потрібний рівень контрасту."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Деякі додатки можуть підтримувати не всі налаштування контрасту кольорів і тексту"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Налаштуйте вигляд кольорів і тексту на фоні кольору екрана"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Попередній перегляд"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Олена, Андрій"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 дні тому"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Написати знову?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Звіт про службове відрядження"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Щоб отримати подальшу допомогу, зв’яжіться зі \nмною або Оленою. Цей звіт буде"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Витрати клієнта"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Затемняти екран"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Елементи керування взаємодією"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Налаштування часу реагування"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Усе одно продовжити"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Скасувати"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Налаштування збільшення"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Збільшувати кнопкою/жестом"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Збільшувати кнопкою й потрійним дотиком"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Про сервіс <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Непрозора"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Висококонтрастний текст"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Змініть колір тексту на чорний або білий. Це максимально підвищує контраст із фоном."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Збільшити контраст тексту"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Змініть колір тексту на чорний або білий, щоб зробити його контрастнішим порівняно з фоном."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Автоматично оновлювати збільшення"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Оновлювати збільшення екрана в інших програмах"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Кнопка живлення закінчує виклик"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Утримувати клавіші гучності"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Тричі торкнутися екрана"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Редагування швидкого ввімкнення функцій доступності"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Виберіть спосіб швидкого ввімкнення таких функцій: %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Продовжити"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Слухові апарати"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Налаштовуйте й контролюйте слухові апарати з підтримкою ASHA і LE Audio, кохлеарні імплантати й інші пристрої для підсилення звуку"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Слухові апарати не підключено"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Додати слухові апарати"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Підключіть слух. апарати"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Сумісність зі слуховими апаратами"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Покращує сумісність з індукційними котушками й зменшує небажаний шум"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Про слухові апарати"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Щоб знайти інші слухові апарати, які не підтримують технологію ASHA або LE Audio, натисніть "<b>"Новий пристрій"</b>" &gt; "<b>"Переглянути інші пристрої"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Підключення пристрою"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"На цій сторінці можна створити пару зі слуховими апаратами ASHA і LE Audio. Переконайтеся, що ваш слуховий апарат увімкнений і готовий до підключення."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Доступні слухові апарати"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Автом. перемикання моб. даних"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Використовувати мобільний трафік із будь-якої SIM-карти залежно від покриття й доступності"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Лише мобільний Інтернет"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Налаштувати"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Далі"</string>
@@ -4943,12 +4930,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Допомагає визначати відносне розташування пристроїв із UWB поблизу"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Коли пристрій використовує UWB, режим польоту вимикається"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Надширокосмуговий зв’язок (UWB) недоступний у цьому регіоні"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Протокол Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Для безперебійної роботи розумного дому підключайтеся до сумісних пристроїв за допомогою протоколу Thread"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Коли використовується протокол Thread, режим польоту вимикається"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Доступ до камери"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Доступ до мікрофона"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Для додатків і сервісів"</string>
@@ -5125,8 +5109,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Скасувати"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Контраст"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Стандартний"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"За умовчанням"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Середній"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Високий"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Цей додаток можна відкрити лише в одному вікні"</string>
diff --git a/res/values-ur/arrays.xml b/res/values-ur/arrays.xml
index f7d90a7..89358e2 100644
--- a/res/values-ur/arrays.xml
+++ b/res/values-ur/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"میٹر شدہ کے بطور خیال کریں"</item>
     <item msgid="2047166446768045816">"غیر میٹر شدہ کے بطور خیال کریں"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"‏بے ترتیب MAC کا استعمال کریں (ڈیفالٹ)"</item>
-    <item msgid="741680937828608749">"‏آلہ کا MAC استعمال کریں"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"نہیں"</item>
     <item msgid="2163015208097377388">"ہاں"</item>
diff --git a/res/values-ur/strings.xml b/res/values-ur/strings.xml
index 8fbd7e1..6bcde0c 100644
--- a/res/values-ur/strings.xml
+++ b/res/values-ur/strings.xml
@@ -915,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"آپ کا کیریئر آپ کو اس نیٹ ورک سے منسلک ہونے کی اجازت نہیں دیتا ہے کیونکہ یہ ایک پرانا سیکیورٹی پروٹوکول استعمال کرتا ہے جو کم محفوظ ہے"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"‏WEP کی اجازت دیں"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"بند کریں"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> سے غیر منسلک کریں؟"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"‏آپ ایک WEP نیٹ ورک سے منسلک ہیں۔ اگر آپ ان نیٹ ورکس کو بلاک کرتے ہیں تو آپ غیر منسلک ہو جائیں گے۔"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"جدید ترین اختیارات"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"ڈراپ ڈاؤن فہرست کے اعلی درجے کے اختیارات"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"پھیلائیں"</string>
@@ -1542,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"اپنے نیٹ ورک کنکشنز کا نظم کرنے کیلئے <xliff:g id="NEW_APP">%s</xliff:g> کا استعمال کریں؟"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"حالیہ مقام کی درخواستیں"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"دفتری پروفائل کیلئے مقام"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"ایپ کے لیے مقام کی اجازتیں"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"مقام آف ہے"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{{total} میں سے # ایپس کو مقام تک رسائی حاصل ہے}other{{total} میں سے # ایپس کو مقام تک رسائی حاصل ہے}}"</string>
@@ -1875,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"آن اسکرین کی بورڈ کا استعمال کریں"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"جب فزیکل کی بورڈ فعال ہو تو اس کو اسکرین پر رکھیں"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"باؤنس کلیدیں"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"‏کی بورڈ ‎<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms‎ کے اندر ایک ہی کلید کو فوری طور پر بار بار دبائے جانے کو نظر انداز کرتا ہے"</string>
     <string name="slow_keys" msgid="2891452895499690837">"سلو کلیدیں"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"‏کسی کلید کے دبانے پر اس کے فعال ہونے میں لگنے والے وقت کو ‎<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms‎ میں ایڈجسٹ کرتا ہے"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"دبی رہنے والی کلیدیں"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"کلیدوں کو ایک ساتھ نیچے کی طرف پکڑے رکھنے کے بجائے، شارٹ کٹس کیلئے ایک وقت میں ایک کلید دبائیں"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"کی بورڈ شارٹ کٹس"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"شارٹ کٹس کی فہرست دکھائیں"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"دفتری پروفائل کے کی بورڈز اور ٹولز"</string>
@@ -1936,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"ری سیٹ کریں"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"موڈیفائر کلید منتخب کریں"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"‫<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> کے لیے نئی کلید منتخب کریں:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"ڈیفالٹ"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"اسپیچ"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"پوائنٹر کی رفتار"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"گیم کنٹرولر"</string>
@@ -1992,8 +1995,7 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"آپ اس آلہ کو اپنی ضروریات کے مطابق حسب ضرورت بنا سکتے ہیں۔ یہ ایکسیسبیلٹی خصوصیات بعد میں ترتیبات میں تبدیل ہو سکتی ہیں۔"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"فونٹ سائز تبدیل کریں"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"اسکرین قاری"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"طبعی کی بورڈ کے اختیارات"</string>
     <string name="captions_category_title" msgid="574490148949400274">"کیپشنز"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"آڈیو"</string>
     <string name="general_category_title" msgid="6298579528716834157">"عام"</string>
@@ -2059,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"بہر حال جاری رکھیں"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"منسوخ کریں"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"میگنیفکیشن کی ترتیبات"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"شارٹ کٹ سے بڑا کریں"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"شارٹ کٹ اور تین بار تھپتھپانے سے بڑا کریں"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> کے بارے میں"</string>
@@ -2243,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"والیوم کی کلیدوں کو دبائیں رکھیں"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"اسکرین پر تین بار تھپتھپائیں"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"ایکسیسبیلٹی شارٹ کٹس میں ترمیم کریں"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"‏%1$s کیلئے اپنے شارٹ کٹ کا انتخاب کریں"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"جاری رکھیں"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"سماعتی آلات"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"‏ASHA اور LE آڈیو سماعتی آلات، کوکلیئر امپلانٹس اور دیگر ایمپلیفیکیشن آلات سیٹ اپ اور ان کا نظم کریں"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"کوئی سماعت کا آلہ منسلک نہیں ہے"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"سماعتی آلات شامل کریں"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"سماعتی آلات کا جوڑا بنائیں"</string>
@@ -2266,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"سماعتی آلہ کی موافقت"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"ٹیلی کوائلز کے ساتھ مطابقت کو بہتر بناتا ہے اور غیر ضروری شور کو کم کرتا ہے"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"آلات کو سننے کے بارے میں"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"‏ایسے دیگر آلات سماعت تلاش کرنے کیلئے جو ASHA یا LE آڈیو سے تعاون یافتہ نہیں ہیں، "<b>"نئے آلے کا جوڑا بنائیں"</b>" ‎&gt;‎ "<b>"مزید آلات دیکھیں"</b>" پر تھپتھپائیں"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"سماعتی آلہ کا جوڑا بنائیں"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"‏آپ اس صفحہ پر ASHA اور LE آڈیو سماعت کے آلات کا جوڑا بنا سکتے ہیں۔ یقینی بنائیں کہ آپ کا سماعتی آلہ آن ہے اور جوڑا بنانے کے لیے تیار ہے۔"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"دستیاب سماعتی آلات"</string>
@@ -4639,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"ٹیکسٹس"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"خودکار طور پر ڈیٹا سوئچ کرنا"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"‏کوریج اور دستیابی کے لحاظ سے کسی بھی SIM سے ڈیٹا کا استعمال کریں"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"صرف ڈیٹا"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"سیٹ اپ کریں"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"آگے جائیں"</string>
@@ -4917,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"‏اس سے UWB والے قریبی آلات کی متعلقہ پوزیشن کی شناخت کرنے میں مدد ملتی ہے"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"‏UWB کا استعمال کرنے کیلئے ہوائی جہاز وضع آف کریں"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"‏UWB موجودہ مقام پر دستیاب نہیں ہے"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"تھریڈ"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"ایک بے جوڑ اسمارٹ گھر تجربے کیلئے، تھریڈ کا استعمال کرتے ہوئے موافق آلات سے منسلک ہوں"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"تھریڈ کا استعمال کرنے کیلئے ہوائی جہاز وضع آف کریں"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"کیمرا تک رسائی"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"مائیکروفون تک رسائی"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"ایپس اور سروسز کے لیے"</string>
diff --git a/res/values-uz/arrays.xml b/res/values-uz/arrays.xml
index c39f5d9..34855cf 100644
--- a/res/values-uz/arrays.xml
+++ b/res/values-uz/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Bu – pulli tarmoq"</item>
     <item msgid="2047166446768045816">"Bu – bepul tarmoq"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Tasodifiy MAC manzil (standart)"</item>
-    <item msgid="741680937828608749">"Qurilmaning MAC manzili"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Yo‘q"</item>
     <item msgid="2163015208097377388">"Ha"</item>
diff --git a/res/values-uz/strings.xml b/res/values-uz/strings.xml
index 1ad1702..c00be2b 100644
--- a/res/values-uz/strings.xml
+++ b/res/values-uz/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Oʻng quloqni ulash"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Chap quloqni ulash"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Barcha mavjud eshitish qurilmalari uchun"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Boshqa eshitish qurilmalari sozlamalari"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Induksion gʻaltak parametrlari va yorliq kabi qurilmalararo sozlamalarni oʻzgartiring"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Shu qurilma uchun"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio chiqishi"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Audio chiqishi haqida"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Maxfiy joy sozlanmoqda…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Qulflanganida maxfiy makon ilovalaridan bildirishnomalar berkitiladi"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Shaxsiy makon sozlamalarida siz uni yashirishingiz va avtomatik bloklashni sozlashingiz mumkin"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Kerakli ilovalar maxfiy makonda allaqachon oʻrnatilgan"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Maxfiy makon sozlanmadi"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Qayta urinish"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Maxfiy joy qurilma qulfi bilan ochilsinmi?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Ilovalar va bildirishnomalar"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Ekran qulfida nozik bildirishnomalar"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Maxfiy makon qulflanmaganda maxfiy kontentni koʻrsatish"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Maʼlumotlaringizni maxfiy saqlash uchun Google hisobini yarating"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Keyingi ekranda maxfiy makoningiz bilan foydalanish uchun hisobingizga kirishingiz mumkin"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Maxfiy makondan tashqarida maʼlumotlar chiqib ketishining oldini olish uchun maxsus hisob yarating, masalan:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Sinxronlangan suratlar, fayllar, emaillar, kontaktlar, taqvimdagi tadbirlar va boshqa maʼlumotlar"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Ilovani yuklab olishlar tarixi va tavsiyalar"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Veb-sahifalar tarixi, bukmarklar va saqlangan parollar"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Maxfiy makon ilovalaridagi faoliyatingizga aloqador tavsiya etilgan kontent"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"OK"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Ko’pi bilan <xliff:g id="COUNT">%d</xliff:g> ta barmoq izi qo’shish mumkin"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Barmoq izlari maksimal miqdorda qo‘shildi"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Boshqa barmoq izini qo‘shib bo‘lmaydi"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Operatoringiz ushbu tarmoqqa ulanishingizga ruxsat bermaydi, chunki u past darajadagi xavfsizlikka ega eski xavfsizlik protokolidan foydalanadi."</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"WEP tarmoqqa ruxsat berish"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Yopish"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"<xliff:g id="NAME">%1$s</xliff:g> aloqasi uzilsinmi?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"WEP tarmoqqa ulandi. Bu tarmoqlarni bloklasangiz, aloqa uziladi."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Kengaytirilgan sozlamalar"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Qoʻshimcha parametrlar pastga ochiluvchi roʻyxati"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"yoyish"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Tarmoq ulanishlarini boshqarish uchun “<xliff:g id="NEW_APP">%s</xliff:g>” ilovasidan foydalanilsinmi?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Joylashuv axboroti so‘rovlari"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ish profili uchun geolokatsiya"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Ilovalar uchun joylashuv ruxsati"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Joylashuv xizmati yoqilmagan"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{#/{total} ta ilova joylashuvdan foydalanmoqda}other{#/{total} ta ilova joylashuvdan foydalanmoqda}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Ekrandagi klaviaturadan foydalanish"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Tashqi klaviatura ulanganida ekranda chiqib turadi"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Qayta bosishni nazorat qilish"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms ichida tugmalar takroriy bosilsa, eʼtiborsiz qoldiriladi"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Sekin tugmalar"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms dan keyin tugma bosilsa, qayd etiladi"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Yopishqoq tugmalar"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Barcha tugmalar kombinatsiyasini bosib turish oʻrniga ularni birma-bir bosing"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tezkor tugmalar"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Tezkor tugmalar roʻyxatini ochish"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Ish profili klaviaturalari va vositalari"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Yangilash"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Modifikator tugmasini tanlang"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> uchun yangi tugma tanlang:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> sxemasi"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Standart"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Avtomatik: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Foydalanuvchi tanlagan: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Nutq"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Kursor tezligi"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"O‘yin qurilmasi"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Qurilmangizdan qulay foydalanish uchun maxsus imkoniyatlardan foydalaning. Bu parametrlarni keyinroq sozlamalar orqali o‘zgartirish mumkin."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Shrift o‘lchamini o‘zgartiring"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekrandan oʻqish vositasi"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Tashqi klaviatura sozlamalari"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Taglavhalar"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Umumiy"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Ekran"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Rang va harakat"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Rang kontrasti"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Yuqori kontrast matn, tugmalar va belgilarni yanada ajratib turadi. Oʻzingizga eng mos kontrastni tanlang."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Ayrim ilovalarda barcha rang va matn kontrasti sozlamalari ishlamasligi mumkin"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ranglar va matn ekraningiz fon rangiga nisbatan qanday koʻrinishini sozlang"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Razm solish"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 kun oldin"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Kuzatilsinmi?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Biznes safari hisoboti"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Qoʻshimcha yordam uchun \nmenga yoki Helenga murojaat qiling. Bu hisobot"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Mijoz xarajatlari"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekranni xiralashtirish"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Boshqaruv elementlari"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Vaqt boshqaruvlari"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Baribir davom ettirilsin"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Bekor qilish"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Kattalashtirish sozlamalari"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Tugma yordamida kattalashtirish"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Tugma va uch marta bosish bilan kattalashtirish"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g> haqida"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Noshaffof"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Yuqori kontrastli matn"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Matn rangini qora yoki oq rangga almashtirish. Fon yordamida kontrastni oshirish."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Matn kontrastini maksimallashtiring"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Fon yordamida kontrastni oshirish uchun matn rangini qora yoki oq rangga almashtiring."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ekranda kattalashtirish xususiyatini avtomatik ravishda yangilash"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Bir ilovadan ikkinchisiga o‘tishda ekranda kattalashtirish xususiyatini yangilash"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Quvvat tugmasi chaqiruvni tugatadi"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Tovush tugmalarini bosib turish"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Ekran ustiga uch marta bosing"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Qulaylik buyruqlarini tahrirlash"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"%1$s uchun buyruq tanlang"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Davom etish"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Eshitish qurilmalari"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"ASHA va LE Audio eshitish moslamalari, koxlear implantlar va boshqa kuchaytiruvchi qurilmalarni sozlash va boshqarish"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Hech qanday eshitish moslamasi ulanmagan"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Eshitish apparatlarini kiritish"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Eshitish moslamalarini ulang"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Eshitish apparati bilan moslik"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Induktiv gʻaltaklar bilan moslikni yaxshilaydi va shovqinni kamaytiradi"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Eshitish apparatlari haqida"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"ASHA yoki LE Audio bilan ishlamaydigan boshqa eshitish qurilmalarini topish uchun "<b>"Yangi qurilmani ulash"</b>" &gt; "<b>"Boshqa qurilmalarni koʻrish"</b>" ustiga bosing"</string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Eshitish qurilmasini ulash"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Bu sahifada ASHA va LE Audio eshitish qurilmalarini birlashtirishingiz mumkin. Eshitish qurilmangiz yoniq va ulanishga tayyorligini tekshiring."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Mavjud eshitish qurilmalari"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Matnlar"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Mobil internetni avtoalmashtirish"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Qamrovi va mavjudligiga qarab istalgan SIM kartaning mobil internetidan foydalaning"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Faqat internet"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Sozlash"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Keyingisi"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Yaqin-atrofdagi UWB qurilmalarining nisbiy joylashishini aniqlashga yordam beradi"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"UWB ishlatish uchun parvoz rejimini faolsizlantiring"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Ayni vaqtda joriy hududingizda UWB ishlamaydi"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Thread tarmogʻi orqali mos keluvchi smart uy qurilmalariga ulaning"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Thread ishlatish uchun parvoz rejimini faolsizlantiring"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Kameraga ruxsat"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofonga ruxsat"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Ilovalar va xizmatlar uchun"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Bekor qilish"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Standart"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Birlamchi"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Oʻrtacha"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Yuqori"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Bu ilovani faqat 1 ta oynada ochish mumkin"</string>
diff --git a/res/values-vi/arrays.xml b/res/values-vi/arrays.xml
index 4383d1f..8cb4a95 100644
--- a/res/values-vi/arrays.xml
+++ b/res/values-vi/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Coi như có đo lượng dữ liệu"</item>
     <item msgid="2047166446768045816">"Coi như không đo lượng dữ liệu"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Dùng MAC ngẫu nhiên (mặc định)"</item>
-    <item msgid="741680937828608749">"Dùng MAC của thiết bị"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Không"</item>
     <item msgid="2163015208097377388">"Có"</item>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 0e91ba9..9bf1609 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Ghép nối tai phải"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Ghép nối tai trái"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Cho tất cả các thiết bị trợ thính có sẵn"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Các chế độ cài đặt khác về thiết bị trợ thính"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Thay đổi chế độ cài đặt trên nhiều thiết bị, chẳng hạn như chế độ điều khiển lối tắt và cuộn dây cảm ứng"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Cho thiết bị này"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Đầu ra âm thanh"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Giới thiệu về đầu ra âm thanh"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Đang thiết lập không gian riêng tư…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Thông báo của các ứng dụng trong không gian riêng tư sẽ bị ẩn khi không gian đó bị khoá"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Khám phá các chế độ cài đặt không gian riêng tư để ẩn không gian riêng tư và thiết lập chế độ khoá tự động"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Các ứng dụng bắt buộc đã được cài đặt trong không gian riêng tư của bạn"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Không thiết lập được không gian riêng tư"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Thử lại"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Dùng khoá màn hình để mở khoá không gian riêng tư?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Ứng dụng và thông báo"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Thông báo nhạy cảm trên màn hình khoá"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Hiển thị nội dung nhạy cảm khi không gian riêng tư mở khoá"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Tạo một Tài khoản Google để giúp bảo mật dữ liệu của bạn"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Trên màn hình tiếp theo, bạn có thể đăng nhập vào một tài khoản để dùng không gian riêng tư"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Tạo một tài khoản chuyên biệt để giúp ngăn dữ liệu xuất hiện bên ngoài không gian riêng tư, chẳng hạn như:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Ảnh, tệp, email, danh bạ, sự kiện trên lịch và các dữ liệu khác đã đồng bộ hoá"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Nhật ký ứng dụng đã tải xuống và các đề xuất"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Nhật ký duyệt web, dấu trang và mật khẩu đã lưu"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Nội dung đề xuất liên quan đến hoạt động của bạn ở các ứng dụng trong không gian riêng tư"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Tôi hiểu"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Bạn có thể thêm tối đa <xliff:g id="COUNT">%d</xliff:g> vân tay"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Bạn đã thêm số vân tay tối đa"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Không thể thêm dấu vân tay khác"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Nhà mạng của bạn không cho phép kết nối với mạng này vì mạng này dùng một giao thức bảo mật cũ và kém an toàn hơn"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Cho phép WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Đóng"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Ngắt kết nối khỏi <xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Bạn đang kết nối với một mạng WEP. Nếu chặn các mạng này, bạn sẽ bị ngắt kết nối."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Tùy chọn nâng cao"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Danh sách thả xuống của Tùy chọn nâng cao"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"mở rộng"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Sử dụng <xliff:g id="NEW_APP">%s</xliff:g> để quản lý các kết nối mạng của bạn?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Các yêu cầu gần đây về vị trí"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Vị trí của hồ sơ công việc"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Quyền truy cập thông tin vị trí cho ứng dụng"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Dịch vụ vị trí hiện đang tắt"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{#/{total} ứng dụng có quyền truy cập vào thông tin vị trí}other{#/{total} ứng dụng có quyền truy cập vào thông tin vị trí}}"</string>
@@ -1588,7 +1577,7 @@
     <string name="about_settings_summary" msgid="4831942939227432513">"Xem thông tin pháp lý, trạng thái, phiên bản phần mềm"</string>
     <string name="legal_information" msgid="7509900979811934843">"Thông tin pháp lý"</string>
     <string name="manual" msgid="3651593989906084868">"Hướng dẫn sử dụng"</string>
-    <string name="regulatory_labels" msgid="5960251403367154270">"Nhãn theo quy định"</string>
+    <string name="regulatory_labels" msgid="5960251403367154270">"Nhãn thông tin quy định"</string>
     <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Hướng dẫn về an toàn và quy định"</string>
     <string name="copyright_title" msgid="83245306827757857">"Bản quyền"</string>
     <string name="license_title" msgid="8745742085916617540">"Giấy phép"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Sử dụng bàn phím ảo"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Hiện bàn phím ảo trên màn hình trong khi bàn phím vật lý đang hoạt động"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Phím nảy"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Bàn phím sẽ bỏ qua các lần nhấn nhanh liên tục cùng một phím trong <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> mili giây"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Phím chậm"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Điều chỉnh thời gian cần để kích hoạt lượt nhấn phím thành <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> mili giây"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Phím cố định"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Nhấn từng phím một để dùng phím tắt thay vì giữ các phím cùng lúc"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Phím tắt"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Hiện danh sách phím tắt"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Công cụ và bàn phím hồ sơ công việc"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Đặt lại"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Chọn phím bổ trợ"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Chọn một phím mới cho <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Mặc định"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"Lời nói"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Tốc độ con trỏ"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Trình điều khiển trò chơi"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Bạn có thể tùy chỉnh thiết bị này cho phù hợp với nhu cầu của mình. Bạn có thể thay đổi các tính năng hỗ trợ tiếp cận này trong phần Cài đặt."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Thay đổi cỡ chữ"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Trình đọc màn hình"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Các lựa chọn bàn phím thực"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Phụ đề"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Âm thanh"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Chung"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Màn hình"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Màu sắc và chuyển động"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Độ tương phản màu"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Độ tương phản càng cao thì càng giúp làm nổi bật văn bản, nút và biểu tượng. Hãy chọn độ tương phản phù hợp nhất với bạn."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Một số ứng dụng có thể không hỗ trợ hết tất cả các chế độ cài đặt độ tương phản màu và văn bản"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Điều chỉnh cách hiển thị màu và văn bản dựa vào màu nền của màn hình"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Xem trước"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 ngày trước"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Theo dõi?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Báo cáo về chuyến công tác"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Để được hỗ trợ thêm, hãy liên hệ với \ntôi hoặc Helen. Báo cáo này sẽ"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Chi phí của khách hàng"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Giảm bớt độ sáng màn hình"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Điều khiển tương tác"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Điều khiển có hẹn giờ"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Vẫn tiếp tục"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Huỷ"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Cài đặt phóng to"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Phóng to bằng phím tắt"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Phóng to bằng phím tắt và nhấn 3 lần"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Giới thiệu về <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Không trong suốt"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Văn bản có độ tương phản cao"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Thay đổi màu chữ thành đen hoặc trắng. Tăng tối đa độ tương phản so với nền."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Tăng tối đa độ tương phản văn bản"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Thay đổi màu chữ thành đen hoặc trắng để tăng độ tương phản với nền."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Tự động cập nhật phóng đại màn hình"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Cập nhật phóng đại màn hình khi chuyển ứng dụng"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Kết thúc cuộc gọi bằng nút nguồn"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Giữ phím âm lượng"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Nhấn 3 lần vào màn hình"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Chỉnh sửa lối tắt hỗ trợ tiếp cận"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Chọn phím tắt của bạn cho %1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Tiếp tục"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Thiết bị trợ thính"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Thiết lập và quản lý các thiết bị trợ thính ASHA và Âm thanh năng lượng thấp, ốc tai điện tử và các thiết bị khuếch đại âm thanh khác"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Chưa kết nối với thiết bị trợ thính nào"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Thêm thiết bị trợ thính"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Ghép nối máy trợ thính"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Khả năng tương thích với thiết bị trợ thính"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Cải thiện khả năng tương thích với các cuộn dây cảm ứng và giảm tiếng ồn không mong muốn"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Giới thiệu về thiết bị nghe"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Để tìm những thiết bị trợ thính khác mà các giao thức ASHA hoặc Âm thanh năng lượng thấp không hỗ trợ, hãy nhấn vào "<b>"Ghép nối thiết bị mới"</b>" &gt; "<b>"Xem thêm thiết bị"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Ghép nối thiết bị trợ thính"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Bạn có thể ghép nối với thiết bị trợ thính ASHA và Âm thanh năng lượng thấp trên trang này. Hãy đảm bảo rằng thiết bị trợ thính của bạn đang bật và sẵn sàng ghép nối."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Thiết bị trợ thính hiện có"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Tin nhắn văn bản"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Tự động chuyển đổi dữ liệu"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Dùng dữ liệu từ 1 trong 2 SIM tuỳ theo phạm vi phủ sóng và tình trạng mạng"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Chỉ dữ liệu"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Thiết lập"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Tiếp theo"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Giúp xác định vị trí tương đối của các thiết bị ở gần có băng tần siêu rộng (UWB)"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Tắt chế độ trên máy bay để dùng UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB (băng tần siêu rộng) không sử dụng được ở vị trí hiện tại"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Giao thức Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Kết nối với các thiết bị tương thích bằng giao thức Thread để có được một trải nghiệm nhà thông minh liền mạch"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Tắt chế độ trên máy bay để dùng giao thức Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Quyền truy cập camera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Quyền truy cập vào micrô"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Áp dụng cho các ứng dụng và dịch vụ"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Huỷ"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Độ tương phản"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Chuẩn"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Mặc định"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Vừa"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Cao"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Ứng dụng này chỉ có thể mở trong 1 cửa sổ"</string>
diff --git a/res/values-zh-rCN/arrays.xml b/res/values-zh-rCN/arrays.xml
index dd3be23..12b574a 100644
--- a/res/values-zh-rCN/arrays.xml
+++ b/res/values-zh-rCN/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"视为按流量计费"</item>
     <item msgid="2047166446768045816">"视为不按流量计费"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"使用随机 MAC（默认）"</item>
-    <item msgid="741680937828608749">"使用设备 MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"否"</item>
     <item msgid="2163015208097377388">"是"</item>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 81384a6..195b417 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"为右耳进行配对"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"为左耳进行配对"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"适合所有可用的助听设备"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"更多助听装置设置"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"更改跨设备设置，例如快捷方式和电感线圈控件"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"适合此设备"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"音频输出"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"音频输出简介"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"正在设置私密空间…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"私密空间处于锁定状态时，系统会隐藏私密空间内应用的通知"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"探索私密空间设置，以便隐藏私密空间和设置自动锁定功能"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"必需的应用已经安装在私密空间中"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"无法设置私密空间"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"重试"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"要使用屏锁来解锁私密空间？"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"应用和通知"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"锁屏状态下的敏感通知"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"可在私密空间解锁后显示敏感内容"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"创建 Google 账号协助确保数据的私密性"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"在下一个界面中，您可以登录用于私密空间的账号"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"创建专用账号，防止数据出现在私密空间外，例如："</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"已同步的照片、文件、电子邮件、联系人、日历活动和其他数据"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"应用下载记录和推荐"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"浏览记录、书签和已保存的密码"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"与私密空间应用中的活动相关的建议内容"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"知道了"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"您最多可以添加 <xliff:g id="COUNT">%d</xliff:g> 个指纹"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"您添加的指纹数量已达到上限"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"无法添加更多的指纹"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"您的运营商不允许连接此网络，因为它采用较旧的安全协议，安全性较低"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"允许连接 WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"关闭"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"要断开与<xliff:g id="NAME">%1$s</xliff:g>的连接吗？"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"您已连接到 WEP 网络。如果您阻止使用这些网络，则会断开连接。"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"高级选项"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"下拉列表高级选项"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"展开"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"要使用<xliff:g id="NEW_APP">%s</xliff:g>管理您的网络连接吗？"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"近期位置信息请求"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"工作资料位置信息"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"应用位置信息权限"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"位置信息服务已关闭"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# 个应用（共 {total} 个应用）有权获取位置信息}other{# 个应用（共 {total} 个应用）有权获取位置信息}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"使用屏幕键盘"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"开启后，连接到实体键盘时，它会一直显示在屏幕上"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"返回键"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"键盘会忽略 <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> 毫秒内快速重复按同一键的操作"</string>
     <string name="slow_keys" msgid="2891452895499690837">"慢速键"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"将按键启用时长调整为 <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> 毫秒"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"粘滞键"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"一次按下快捷键中的一个键，而非同时按住多个键"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"键盘快捷键"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"显示快捷键列表"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"工作资料键盘和工具"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"重置"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"选择辅助键"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"为<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>选择新的辅助键："</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"“<xliff:g id="IME_LABEL">%s</xliff:g>”布局"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"默认"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"自动选择的布局：<xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"用户选择的布局：<xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"语音"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"指针速度"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"游戏控制器"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"您可以根据自己的需求对此设备进行自定义，也可以稍后在“设置”中更改这些无障碍功能的设置。"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"更改字体大小"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"屏幕阅读器"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"实体键盘选项"</string>
     <string name="captions_category_title" msgid="574490148949400274">"字幕"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"音频"</string>
     <string name="general_category_title" msgid="6298579528716834157">"常规"</string>
     <string name="display_category_title" msgid="6638191682294461408">"显示"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"色彩和动画"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"颜色对比度"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"对比度越高，文字、按钮和图标越引人注目。请选择最符合您需求的对比度。"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"某些应用可能仅支持部分颜色和文字对比度设置"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"调整颜色和文字与屏幕背景颜色的对比度"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"预览"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen、Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 天前"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"要后续跟进吗？"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"出差报告"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"如要获取进一步协助，请与我\n或 Helen 联系。此报告将"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"客户端支出"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"调暗屏幕"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"互动控制"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"定时控制"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"仍然继续"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"取消"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"放大设置"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"使用快捷手势进行放大"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"通过“快捷手势”和“点按屏幕三次”进行放大"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"<xliff:g id="SERVICE">%1$s</xliff:g>简介"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"不透明"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"高对比度文字"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"将文字颜色更改为黑色或白色，使其与背景形成尽可能鲜明的对比。"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"尽可能提高文字对比度"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"将文字颜色更改为黑色或白色，提高与背景的对比度。"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"自动更新屏幕放大状态"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"在应用转换时更新屏幕放大状态"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"按电源按钮结束通话"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"按住两个音量键"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"点按屏幕三次"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"修改无障碍快捷方式"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"为%1$s选择快捷键"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"继续"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"助听装置"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"设置和管理 ASHA 和 LE 音频助听器、人工耳蜗及其他放大设备"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"未连接任何助听装置"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"添加助听器"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"为助听器进行配对"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"助听器兼容性"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"通过拾音线圈提高兼容性并减少杂音"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"助听设备简介"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"如需查找 ASHA 或 LE 音频不支持的其他助听装置，请依次点按"<b>"与新设备配对"</b>" &gt; "<b>"查看更多设备"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"与助听设备配对"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"您可以在此页面上配对 ASHA 和 LE Audio 助听装置。请确保您的助听装置已开启且可随时配对。"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"可用的助听装置"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"短信"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"自动切换数据网络"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"根据信号覆盖率和可用性，选择要使用哪张 SIM 卡的移动网络"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"上网专用"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"设置"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"继续"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"有助于确定附近支持超宽带 (UWB) 的设备的相对位置"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"会关闭飞行模式，以使用超宽带 (UWB)"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB 在当前位置不可用"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"使用 Thread 连接到兼容的设备，享受顺畅的智能家居体验"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"关闭飞行模式，以使用 Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"摄像头使用权限"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"麦克风使用权限"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"会影响应用和服务"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"取消"</string>
     <string name="contrast_title" msgid="6885768151336508075">"对比度"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"标准"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"默认"</string>
     <string name="contrast_medium" msgid="384414510709285811">"中"</string>
     <string name="contrast_high" msgid="3988567609694797696">"高"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"此应用只能在 1 个窗口中打开"</string>
diff --git a/res/values-zh-rHK/arrays.xml b/res/values-zh-rHK/arrays.xml
index 19426bf..0de2253 100644
--- a/res/values-zh-rHK/arrays.xml
+++ b/res/values-zh-rHK/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"視為按用量收費"</item>
     <item msgid="2047166446768045816">"視為非按用量收費"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"使用隨機 MAC (預設)"</item>
-    <item msgid="741680937828608749">"使用裝置 MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"否"</item>
     <item msgid="2163015208097377388">"是"</item>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index d08f556..ccf774c 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"配對右耳的裝置"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"配對左耳"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"所有適用的助聽器"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"更多助聽器設定"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"變更捷徑等跨裝置設定，以及電話線圈控制項"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"僅限此裝置"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"音訊輸出裝置"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"關於音訊輸出"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"正在設定私人空間…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"私人空間處於鎖定狀態時，系統會隱藏私人空間應用程式的通知"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"探索私人空間設定，可隱藏私人空間及設定自動鎖定"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"所需的應用程式已安裝在私人空間內"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"無法設定私人空間"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"再試一次"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"要使用螢幕鎖定功能解鎖私人空間嗎？"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"應用程式和通知"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"上鎖畫面上的敏感通知"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"在私人空間解鎖時顯示敏感內容"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"建立 Google 帳戶有助將你的資料保密"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"在下一個畫面中，你可以登入用於私人空間的帳戶"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"建立專屬帳戶，防止資料出現在私人空間外，例如："</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"已同步的相片、檔案、電郵、聯絡人、日曆活動和其他資料"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"應用程式下載記錄和建議"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"瀏覽記錄、書籤和已儲存的密碼"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"與私人空間應用程式活動相關的建議內容"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"知道了"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"你最多可以加入 <xliff:g id="COUNT">%d</xliff:g> 個指紋"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"你加入指紋的數目已達上限"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"無法加入更多指紋"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"此網絡使用較舊的安全通訊協定，安全性較低，因此你的流動網絡供應商不允許使用"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"允許使用 WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"關閉"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"要中斷與<xliff:g id="NAME">%1$s</xliff:g>的連線嗎？"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"你已連線至 WEP 網絡。封鎖這些網絡便會中斷連線。"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"進階選項"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"下拉式清單進階選項"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"展開"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"使用「<xliff:g id="NEW_APP">%s</xliff:g>」管理你的網絡連線？"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"最近的位置資訊要求"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"工作設定檔的位置"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"應用程式位置權限"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"位置設定已關閉"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{在 {total} 個應用程式中，有 # 個已取得位置資訊存取權}other{在 {total} 個應用程式中，有 # 個已取得位置資訊存取權}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"使用屏幕鍵盤"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"當實體鍵盤處於連接狀態時，保持在畫面上顯示"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"篩選鍵"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"鍵盤會忽略在 <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> 毫秒內快速重覆按下同一按鍵的動作"</string>
     <string name="slow_keys" msgid="2891452895499690837">"緩慢鍵"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"將按鍵啟動時間調整為 <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> 毫秒"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"相黏鍵"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"一次按下快速鍵中的一個鍵，而非同時按住多個鍵"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"鍵盤快速鍵"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"顯示快速鍵清單"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"工作設定檔鍵盤與工具"</string>
@@ -1947,7 +1933,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"重設"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"選擇輔助鍵"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"為「<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>」選擇新的輔助鍵："</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"<xliff:g id="IME_LABEL">%s</xliff:g> 版面配置"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"預設"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"自動：<xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"已選取使用者：<xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"語音"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"游標速度"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"遊戲控制器"</string>
@@ -2003,35 +1992,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"你可視乎個人需要自訂此裝置，日後也可前往「設定」變更這些無障礙功能。"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"變更字型大小"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"螢幕閱讀器"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"實體鍵盤選項"</string>
     <string name="captions_category_title" msgid="574490148949400274">"字幕"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"音訊"</string>
     <string name="general_category_title" msgid="6298579528716834157">"一般"</string>
     <string name="display_category_title" msgid="6638191682294461408">"螢幕"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"顏色及動作"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"色彩對比度"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"對比度越高，文字、按鈕和圖示便越突出。選擇最適合你的對比度。"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"部分應用程式可能尚未支援所有色彩和文字對比度設定"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"調整色彩和文字與螢幕背景色彩之間的對比度。"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"預覽"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen、Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 天前"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"要跟進嗎？"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"公幹報告"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"如需進一步協助，\n請與我或 Helen 聯絡。此報告將會"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"客戶支出"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"校暗螢幕"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"互動控制項"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"時間控制"</string>
@@ -2081,6 +2058,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"仍要繼續"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"取消"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"放大設定"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"使用快速鍵來放大"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"使用快速鍵和輕按三下來放大"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"關於「<xliff:g id="SERVICE">%1$s</xliff:g>」"</string>
@@ -2168,10 +2151,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"不透明"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"高對比文字"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"將文字顏色改成黑色或白色，盡量令文字和背景顏色有最大對比。"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"將文字對比度最大化"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"將文字色彩改成黑色或白色，提升文字和背景之間的對比度。"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"自動更新螢幕放大設定"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"在應用程式轉場時更新螢幕放大設定"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"按開關按鈕結束通話"</string>
@@ -2267,12 +2248,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"按住音量鍵"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"輕按三下螢幕"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"編輯無障礙功能捷徑"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"選擇 %1$s 的捷徑"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"繼續"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"助聽器"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"設定並管理 ASHA 和 LE Audio 助聽器、人工耳蝸和其他擴音裝置"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"沒有連接任何助聽器"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"新增助聽器"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"配對助聽器"</string>
@@ -2290,8 +2269,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"助聽器兼容性"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"改善 T 掣兼容性及降低噪音"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"關於助聽器"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"如要找到 ASHA 或 LE Audio 不支援的其他助聽器，請輕按 [配對新裝置] &gt; [查看更多裝置]"<b></b><b></b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"配對助聽器"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"你可在此頁面配對 ASHA 和 LE Audio 助聽器。請確保助聽器已開啟並已準備好配對。"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"可供使用的助聽器"</string>
@@ -4663,6 +4641,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"短訊"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"自動切換數據"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"按流動網絡的覆蓋範圍和適用範圍，選擇要使用哪張 SIM 卡的數據"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"數據專用"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"設定"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"下一頁"</string>
@@ -4694,7 +4678,7 @@
     <string name="erasing_sim" msgid="4237180547590463930">"正在清除 eSIM 卡…"</string>
     <string name="erase_sim_fail_title" msgid="1445700500168357303">"無法清除 eSIM 卡"</string>
     <string name="erase_sim_fail_text" msgid="6898841004987411547">"發生問題，未清除此 eSIM 卡。\n\n請重新啟動裝置並再試一次。"</string>
-    <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"清除前連線至 Wi-Fi"</string>
+    <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"清除資料前請連線至 Wi-Fi"</string>
     <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"這讓你日後再次使用 eSIM 卡時更方便，不用聯絡流動網絡供應商"</string>
     <string name="wifi_warning_continue_button" msgid="8171574741789688214">"仍要清除"</string>
     <string name="wifi_warning_return_button" msgid="6226063181583906340">"確定"</string>
@@ -4941,12 +4925,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"協助判斷附近採用超寬頻的裝置的相對位置"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"請關閉飛行模式，以便使用 UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"目前位置無法使用 UWB"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"使用 Thread 與兼容裝置連線，享受流暢的智能家居體驗"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"請關閉飛行模式，以便使用 Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"相機存取權"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"麥克風存取權"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"應用程式和服務"</string>
@@ -5123,8 +5104,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"取消"</string>
     <string name="contrast_title" msgid="6885768151336508075">"對比"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"標準"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"預設"</string>
     <string name="contrast_medium" msgid="384414510709285811">"中"</string>
     <string name="contrast_high" msgid="3988567609694797696">"高"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"此應用程式只可在 1 個視窗中開啟"</string>
diff --git a/res/values-zh-rTW/arrays.xml b/res/values-zh-rTW/arrays.xml
index ef0cceb..4b390d7 100644
--- a/res/values-zh-rTW/arrays.xml
+++ b/res/values-zh-rTW/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"視為計量付費"</item>
     <item msgid="2047166446768045816">"視為非計量付費"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"使用隨機化 MAC (預設)"</item>
-    <item msgid="741680937828608749">"使用裝置 MAC"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"否"</item>
     <item msgid="2163015208097377388">"是"</item>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index 7462a00..8b7c4de 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"配對右耳的裝置"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"配對左耳的裝置"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"適用於所有可用的助聽裝置"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"更多助聽器設定"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"變更捷徑等跨裝置設定，以及電話線圈控制選項"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"適用於本裝置"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"音訊輸出裝置"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"關於音訊輸出"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"正在設定私人空間…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"私人空間鎖定時，系統會隱藏私人空間應用程式的通知"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"探索私人空間設定，可隱藏私人空間及設定自動鎖定"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"所需應用程式已安裝在私人空間"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"無法設定私人空間"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"再試一次"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"要使用螢幕鎖定功能鎖定私人空間嗎？"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"應用程式和通知"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"在螢幕鎖定畫面上顯示私密通知"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"可在私人空間解鎖後顯示私密內容"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"建立 Google 帳戶協助保障資料隱私"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"你可以在下個畫面登入帳戶，用來使用私人空間"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"建立專用帳戶，防止資料出現在私人空間外，例如："</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"已同步相片、檔案、電子郵件、聯絡人、日曆活動和其他資料"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"應用程式下載記錄和建議"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"瀏覽記錄、書籤和儲存的密碼"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"與你的私人空間應用程式活動相關的建議內容"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"我知道了"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"你最多可以新增 <xliff:g id="COUNT">%d</xliff:g> 個指紋"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"你新增的指紋數量已達上限"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"無法新增其他指紋"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"這個網路使用較舊的安全通訊協定，安全性較低，因此你的電信業者不允許連線到這個網路"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"允許使用 WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"關閉"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"要中斷與「<xliff:g id="NAME">%1$s</xliff:g>」的連線嗎？"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"你已連上 WEP 網路。如果封鎖這類網路，就會中斷連線。"</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"進階選項"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"下拉式清單進階選項"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"展開"</string>
@@ -1553,6 +1540,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"使用「<xliff:g id="NEW_APP">%s</xliff:g>」管理你的網路連線？"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"最近的定位要求"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"工作資料夾位置資訊"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"應用程式位置存取權"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"定位功能已關閉"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{有 # 個應用程式 (共 {total} 個) 已取得位置存取權}other{有 # 個應用程式 (共 {total} 個) 已取得位置存取權}}"</string>
@@ -1886,14 +1875,11 @@
     <string name="show_ime" msgid="4334255501724746849">"使用螢幕小鍵盤"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"使用實體鍵盤時仍繼續顯示螢幕小鍵盤"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"篩選鍵"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"鍵盤會忽略在 <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> 毫秒內快速重覆按下同一按鍵的動作"</string>
     <string name="slow_keys" msgid="2891452895499690837">"延遲感應鍵"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"將按鍵啟動時間調整為 <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> 毫秒"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"相黏鍵"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"一次按下快速鍵中的一個按鍵，而非同時按住多個按鍵"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"鍵盤快速鍵"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"顯示快速鍵清單"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"工作資料夾鍵盤和工具"</string>
@@ -1947,7 +1933,13 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"重設"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"選擇輔助鍵"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"為「<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>」選擇新的輔助鍵："</string>
+    <!-- no translation found for ime_label_title (8994569521516807168) -->
+    <skip />
     <string name="default_keyboard_layout" msgid="8690689331289452201">"預設"</string>
+    <!-- no translation found for automatic_keyboard_layout_label (9138088156046198913) -->
+    <skip />
+    <!-- no translation found for user_selected_keyboard_layout_label (154742505924555156) -->
+    <skip />
     <string name="speech_category_title" msgid="5995161659186229742">"語音"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"游標速度"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"遊戲控制器"</string>
@@ -2003,35 +1995,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"你可以根據個人需求自訂這個裝置，日後也可前往「設定」變更這些無障礙功能。"</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"變更字型大小"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"螢幕閱讀器"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"實體鍵盤選項"</string>
     <string name="captions_category_title" msgid="574490148949400274">"字幕"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"音訊"</string>
     <string name="general_category_title" msgid="6298579528716834157">"一般"</string>
     <string name="display_category_title" msgid="6638191682294461408">"螢幕"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"色彩和動態"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"色彩對比"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"對比度較高時，文字、按鈕和圖示會更醒目。請選擇效果最佳的對比度。"</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"部分應用程式可能不支援所有色彩和文字對比度設定"</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"調整色彩和文字在畫面背景色上的呈現效果"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"預覽"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen、Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"2 天前"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"要追蹤後續嗎？"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"出差報告"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"如需進一步協助，請與我或 Helen 聯絡。\n報告將會"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"用戶端支出"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"調暗螢幕"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"互動控制項"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"時間控制項"</string>
@@ -2081,6 +2061,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"仍要繼續"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"取消"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"放大功能設定"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"使用快速手勢放大畫面"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"使用快速手勢並輕觸三下即可放大畫面"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"關於「<xliff:g id="SERVICE">%1$s</xliff:g>」"</string>
@@ -2168,10 +2154,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"不透明"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"高對比文字"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"將文字色彩變更為黑色或白色，讓文字與背景色彩呈現最大對比。"</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"盡可能提高文字對比度"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"將文字色彩變更為黑色或白色，增加與背景的對比度。"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"自動更新螢幕放大設定"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"更新應用程式轉場後的螢幕放大設定"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"按電源鍵結束通話"</string>
@@ -2267,12 +2251,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"按住音量鍵"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"輕觸螢幕三下"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"編輯無障礙捷徑"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"選擇「%1$s」的快速鍵"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"繼續"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"助聽器"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"設定及管理 ASHA 和 LE Audio 助聽器、人工電子耳和其他擴音裝置"</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"未連接助聽器"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"新增助聽器"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"配對助聽器"</string>
@@ -2290,8 +2272,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"助聽器相容性"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"提升與電話線圈的相容程度，減少惱人噪音"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"關於助聽器"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"如要找到 ASHA 或 LE Audio 不支援的其他助聽器，請依序輕觸「配對新裝置」"<b></b>"&gt;「查看更多裝置」"<b></b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"配對助聽器"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"你可以在本頁將 ASHA 和 LE Audio 助聽器配對。請確認助聽器已開啟並可進行配對。"</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"可用的助聽器"</string>
@@ -3823,7 +3804,7 @@
     <string name="filter_instant_apps" msgid="2292108467020380068">"免安裝應用程式"</string>
     <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"已關閉"</string>
     <string name="advanced_apps" msgid="7643010673326578815">"進階"</string>
-    <string name="app_permissions" msgid="8666537659217653626">"權限管理員"</string>
+    <string name="app_permissions" msgid="8666537659217653626">"權限管理工具"</string>
     <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"位置資料分享更新"</string>
     <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"查看哪些應用程式變更了分享位置資料的方式"</string>
     <string name="tap_to_wake" msgid="3313433536261440068">"輕觸即可喚醒"</string>
@@ -4663,6 +4644,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"訊息"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"自動切換行動數據"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"依據行動網路的涵蓋率和可用性，選擇要使用哪張 SIM 卡的數據"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"數據傳輸專用"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"設定"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"繼續"</string>
@@ -4941,12 +4928,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"協助判斷附近支援 UWB 的裝置的相對位置"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"請關閉飛航模式，以便使用 UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"無法在目前的位置使用 UWB"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"使用 Thread 與相容裝置連線，享受流暢的智慧型住宅體驗"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"關閉飛航模式即可使用 Thread"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"相機存取權"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"麥克風存取權"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"應用程式和服務"</string>
@@ -5123,8 +5107,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"取消"</string>
     <string name="contrast_title" msgid="6885768151336508075">"對比"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"標準"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"預設"</string>
     <string name="contrast_medium" msgid="384414510709285811">"中"</string>
     <string name="contrast_high" msgid="3988567609694797696">"高"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"這個應用程式只能在 1 個視窗中開啟"</string>
diff --git a/res/values-zu/arrays.xml b/res/values-zu/arrays.xml
index dd1c090..ebd7184 100644
--- a/res/values-zu/arrays.xml
+++ b/res/values-zu/arrays.xml
@@ -408,10 +408,7 @@
     <item msgid="3779092145391320375">"Phatha njengokulinganisiwe"</item>
     <item msgid="2047166446768045816">"Phatha njengokungalinganisiwe"</item>
   </string-array>
-  <string-array name="wifi_privacy_entries">
-    <item msgid="3485945604919292489">"Sebenzisa i-MAC engahleliwe (okuzenzakalelayo)"</item>
-    <item msgid="741680937828608749">"Sebenzisa i-MAC yedivayisi"</item>
-  </string-array>
+    <!-- no translation found for wifi_privacy_entries:0 (91222619458919148) -->
   <string-array name="wifi_hidden_entries">
     <item msgid="342232116597649254">"Cha"</item>
     <item msgid="2163015208097377388">"Yebo"</item>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index 829946d..e1fe95e 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -74,10 +74,8 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Bhangqa indlebe engakwesokudla"</string>
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Bhangqa indlebe engakwesokunxele"</string>
     <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Mayelana nawo wonke amadivayisi wokuzwa atholakalayo"</string>
-    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
-    <skip />
-    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
-    <skip />
+    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Amasethingi engeziwe ensizakuzwa"</string>
+    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Shintsha amasethingi amadivayisi amaningi njengesinqamuleli, kanye nezilawuli ze-telecoil"</string>
     <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Kule divayisi"</string>
     <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Okukhishwayo komsindo"</string>
     <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Mayelana nokuphumayo komsindo"</string>
@@ -598,8 +596,7 @@
     <string name="private_space_setting_up_text" msgid="8458035555212009528">"Isetha isikhala esigodliwe…"</string>
     <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Izaziso ezivela kuma-app wendawo engasese ziyafihlwa uma ikhiyiwe"</string>
     <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Hlola amasethingi endawo engasese ukuze ufihle indawo engasese futhi usethe ukukhiya ngokuzenzakalelayo"</string>
-    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
-    <skip />
+    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Ama-app ayimfuneko afakiwe kakade endaweni yakho eyimfihlo"</string>
     <string name="private_space_error_screen_title" msgid="739381738044418346">"Ayikwazanga ukusetha indawo engasese"</string>
     <string name="private_space_tryagain_label" msgid="8305362615231738367">"Zama Futhi"</string>
     <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Sebenzisa ukukhiya isikrini ukuvula isikhala esigodliwe?"</string>
@@ -622,22 +619,14 @@
     <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Ama-app nezaziso"</string>
     <string name="private_space_notifications_title" msgid="3456249671149740404">"Izaziso ezizwelayo kusikrini sokukhiya"</string>
     <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Bonisa okuqukethwe okubucayi uma indawo engasese ivuliwe"</string>
-    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
-    <skip />
-    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
-    <skip />
+    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Sungula i-Google Account ukuze usize ekugcineni idatha yakho igodliwe"</string>
+    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Esikrinini esilandelayo ungangena ngemvume ku-akhawunti ukuze uyisebenzise nendawo engasese yakho"</string>
+    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Sungula i-akhawunti ezinikele ukuze usize ekumiseni idatha evela ngaphandle kwendawo engasese, njengale:"</b></string>
+    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Izithombe, amafayela, ama-imeyile, oxhumana nabo, umcimbi wekhalenda kanye nenye idatha evunyelanisiwe"</string>
+    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Umlando wokudawuniloda we-app kanye nokunconywayo"</string>
+    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Umlando wokubhrawuza, amabhukhimakhi, kanye namaphasiwedi alondoloziwe"</string>
+    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Okuqukethwe okusikiselwe okuhlobene nomsebenzi wakho kuma-app endawo engasese"</string>
+    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Ngiyezwa"</string>
     <string name="fingerprint_add_max" msgid="8639321019299347447">"Ungangeza izigxivizo zeminwe ezingafika kwezingu-<xliff:g id="COUNT">%d</xliff:g>"</string>
     <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Ungeze inombolo ephezulu yezigxivizo zeminwe"</string>
     <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Ayikwazi ukwengeza izingxovizo zeminwe eziningi"</string>
@@ -926,10 +915,8 @@
     <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Inkampani yakho yenethiwekhi ayikuvumeli ukuthi uxhume kule nethiwekhi ngoba isebenzisa iphrothokholi yokuvikela endala engavikelekile"</string>
     <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Vumela i-WEP"</string>
     <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Vala"</string>
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
-    <skip />
-    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
-    <skip />
+    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Nqamula ukuxhuma ku-<xliff:g id="NAME">%1$s</xliff:g>?"</string>
+    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Uxhume kunethiwekhi ye-WEP. Uma uvimba la manethiwekhi, uzonqanyulwa."</string>
     <string name="wifi_show_advanced" msgid="2969378109942071741">"Izinketho ezithuthukile"</string>
     <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Izinketho ezithuthukisiwe zohlu olushona ezansi"</string>
     <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"nweba"</string>
@@ -1554,6 +1541,8 @@
     <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Sebenzisa i-<xliff:g id="NEW_APP">%s</xliff:g> ukuze uphathe uxhumo lwakho lenethiwekhi?"</string>
     <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Izicelo zendawo zakamuva"</string>
     <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Indawo yephrofayela yokusebenza"</string>
+    <!-- no translation found for private_profile_location_switch_title (4127119143109855789) -->
+    <skip />
     <string name="location_app_level_permissions" msgid="907206607664629759">"Izimvume zendawo ye-app"</string>
     <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Indawo ivaliwe"</string>
     <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{U-# ku-app e-{total} enokufinyelela kundawo}one{U-# kuma-app angu-{total} anokufinyelela kundawo}other{U-# kuma-app angu-{total} anokufinyelela kundawo}}"</string>
@@ -1887,14 +1876,11 @@
     <string name="show_ime" msgid="4334255501724746849">"Sebenzisa ikhibhodi ekuskrini"</string>
     <string name="show_ime_summary" msgid="7293345791727205975">"Yigcine kusikrini ngenkathi kusebenza ikhibhodi ephathekayo"</string>
     <string name="bounce_keys" msgid="7419450970351743904">"Okhiye bokubuyisela emuva"</string>
-    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
-    <skip />
+    <string name="bounce_keys_summary" msgid="7347050868868080302">"Ikhibhodi iziba ukuchofozwa okusheshayo ngokuphindaphindiwe kwenkinobho efanayo phakathi nenkathi engu-<xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="slow_keys" msgid="2891452895499690837">"Okhiye abahamba kancane"</string>
-    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
-    <skip />
+    <string name="slow_keys_summary" msgid="1784371292745423292">"Lungisa isikhathi esithathwa yinkinobho ngayinye ukuba isebenze lapho icindezelwa, sibe ngu-<xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
     <string name="sticky_keys" msgid="7317317044898161747">"Okhiye abanamathelayo"</string>
-    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
-    <skip />
+    <string name="sticky_keys_summary" msgid="1844953803625480623">"Cindezela inkinobho eyodwa ngesikhathi ukuze uthole izinqamuleli esikhundleni sokubamba izinkinobho ndawonye"</string>
     <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Izinqamuleli zekhibhodi"</string>
     <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Bonisa uhlu lwezinqamuleli"</string>
     <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Amakhibhodi ephrofayela yomsebenzi namathuluzi"</string>
@@ -1948,7 +1934,10 @@
     <string name="modifier_keys_reset" msgid="551170906710422041">"Setha kabusha"</string>
     <string name="modifier_keys_picker_title" msgid="244545904150587851">"Khetha ukhiye wokushintsha"</string>
     <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Khetha ukhiye omusha we-<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
+    <string name="ime_label_title" msgid="8994569521516807168">"Isakhiwo se-<xliff:g id="IME_LABEL">%s</xliff:g>"</string>
     <string name="default_keyboard_layout" msgid="8690689331289452201">"Okuzenzakalelayo"</string>
+    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Okuzenzekelayo: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
+    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Umsebenzisi ukhethiwe: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
     <string name="speech_category_title" msgid="5995161659186229742">"Inkulumo"</string>
     <string name="pointer_speed" msgid="7398649279282675718">"Ijubane lesikhombi"</string>
     <string name="game_controller_settings_category" msgid="8557472715034961918">"Isilawuli somdlalo"</string>
@@ -2004,35 +1993,23 @@
     <string name="vision_settings_description" msgid="7614894785054441991">"Ungenza ngendlela oyifisayo le divayisi ukuze ihlangabezane nezidingo zakho. Lezi zici ezingafinyeleleka zingashintshwa ngemuva kwesikhathi kuzilungiselelo."</string>
     <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Shintsha usayizi wefonti"</string>
     <string name="screen_reader_category_title" msgid="5825700839731107803">"Isifundi sesikrini"</string>
-    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
-    <skip />
+    <string name="keyboard_category_title" msgid="6841712758039893220">"Okungakhethwa kukho kwekhibhodi ebonakalayo"</string>
     <string name="captions_category_title" msgid="574490148949400274">"Amagama-ncazo"</string>
     <string name="audio_category_title" msgid="5283853679967605826">"Umsindo"</string>
     <string name="general_category_title" msgid="6298579528716834157">"Okuvamile"</string>
     <string name="display_category_title" msgid="6638191682294461408">"Bonisa"</string>
     <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Umbala nokunyakaza"</string>
-    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
-    <skip />
-    <!-- no translation found for color_contrast_note (7592686603372566198) -->
-    <skip />
-    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
-    <skip />
-    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
-    <skip />
+    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Ukungafani kombala"</string>
+    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Ukungafani okuphezulu kwenza umbhalo, izinkinobho kanye nezithonjana zivele kakhulu. Khetha ukungafani okubukeka kangcono kuwe."</string>
+    <string name="color_contrast_note" msgid="7592686603372566198">"Amanye ama-app angase angayisekeli yonke imibala nemibhalo yamasethingi okungafani."</string>
+    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Lungisa ukuthi imibala kanye nombhalo kubukeka kanjani uma kuqhathaniswa nombhala wengemuva lesikrini sakho"</string>
+    <string name="color_contrast_preview" msgid="6791430227535363883">"Hlola kuqala"</string>
+    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"U-Helen, Adam"</string>
+    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"Izinsuku ezi-2 ezidlule"</string>
+    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Landelela?"</string>
+    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Umbiko wohambo lwebhizinisi"</string>
+    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Ngosizo olwengeziwe, sicea uxhumane \nnami noma u-Helen. Lo mbiko uzo"</string>
+    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Izindleko Zeklayenti"</string>
     <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Yenza isikrini sibe mnyama"</string>
     <string name="interaction_control_category_title" msgid="2696474616743882372">"Izilawuli zokubandakanya"</string>
     <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Izilawuli zesikhathi"</string>
@@ -2082,6 +2059,12 @@
     <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Qhubeka noma kunjalo"</string>
     <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Khansela"</string>
     <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Izilungiselelo zokukhuliswa"</string>
+    <!-- no translation found for accessibility_magnification_one_finger_panning_title (4503949739883092989) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_on (9133125894310777539) -->
+    <skip />
+    <!-- no translation found for accessibility_magnification_one_finger_panning_summary_off (8979146350396559805) -->
+    <skip />
     <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Khulisa ngesinqamuleli"</string>
     <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Khulisa ngenkinobho futhi uthephe kathathu"</string>
     <string name="accessibility_introduction_title" msgid="8834950581512452348">"Mayelana ne-<xliff:g id="SERVICE">%1$s</xliff:g>"</string>
@@ -2169,10 +2152,8 @@
     <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ayibonisi ngale"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Umbala okhanya kakhulu"</string>
     <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Shintsha umbala wombhalo ube mnyama noma mhlophe. Khulisa ukugqama nengemuva."</string>
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
-    <skip />
-    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
-    <skip />
+    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Beka ekugcineni ukungafani kombhalo"</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Shintsha umbala wombhalo ube mnyama noma mhlophe ukuze wenyuse ukungafani nengemuva."</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Buyekeza ngokuzenzakalela isisondezi-skrini"</string>
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Buyekeza isisondezi-skrini ekushintshweni kohlelo lokusebenza"</string>
     <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Inkinobho yamandla ivala ikholi"</string>
@@ -2268,12 +2249,10 @@
     <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Bamba okhiye bevolomu"</string>
     <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Isikrini sokuthepha kathathu"</string>
     <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Hlela izinqamuleli zokufinyeleleka"</string>
-    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
-    <skip />
+    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Khetha isinqamuleli sakho se-%1$s"</string>
     <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Qhubeka"</string>
     <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Amadivayizi okuzwa"</string>
-    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
-    <skip />
+    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Setha futhi ulawule izinsizakuzwa ze-ASHA kanye Nomsindo we-LE, izifakelo ze-cochlear, namanye amadivayisi okukhulisa izwi."</string>
     <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Azikho izinsizakuzwa ezixhunyiwe"</string>
     <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Engeza izinsinza zokuzwa"</string>
     <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Bhangqa imishini yendlebe"</string>
@@ -2291,8 +2270,7 @@
     <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Ukusebenzisana nensiza yokuzwa"</string>
     <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Ithuthukisa ukuhambisana nama-telecoil futhi inciphisa umsindo ongafuneki"</string>
     <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Mayelana nemishini yokuzwa"</string>
-    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
-    <skip />
+    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Ukuze uthole ezinye izinsizakuzwa ezingasekelwe yi-ASHA noma Umsindo we-LE, thepha okuthi "<b>"Bhangqa idivayisi entsha"</b>" &gt; "<b>"Bheka amadivayisi engeziwe"</b></string>
     <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Bhanqa idivayisi yokuzwa"</string>
     <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Ungabhangqa amadivayisi okuzwa e-ASHA ne-LE Audio kuleli khasi. Qinisekisa ukuthi idivayisi yakho yokuzwa ivuliwe futhi ilungele ukubhanqa."</string>
     <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Amadivayisi okuzwa atholakalayo"</string>
@@ -4664,6 +4642,12 @@
     <string name="primary_sim_texts_title" msgid="1287584042733097749">"Ukuthumela imiyalezo"</string>
     <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Ukushintsha idatha okuzenzekelayo"</string>
     <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Sebenzisa idatha evela kunoma iyiphi i-SIM kuye ngokukhava nokutholakala"</string>
+    <!-- no translation found for sim_action_restart_dialog_title (3507413479633430120) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_msg (4737611046767629774) -->
+    <skip />
+    <!-- no translation found for sim_action_restart_dialog_cancel (665560106686565624) -->
+    <skip />
     <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Idatha kuphela"</string>
     <string name="sim_onboarding_setup" msgid="5750393553605388463">"Setha"</string>
     <string name="sim_onboarding_next" msgid="6415025179929475355">"Okulandelayo"</string>
@@ -4942,12 +4926,9 @@
     <string name="uwb_settings_summary" msgid="3074271396764672268">"Isiza ukukhomba ukuma okuhlobene kwamadivayisi aseduze ane-UWB"</string>
     <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Vala imodi yendiza ukuze usebenzise i-UWB"</string>
     <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"I-UWB ayitholakali endaweni yamanje"</string>
-    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
-    <skip />
-    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
-    <skip />
+    <string name="thread_network_settings_title" msgid="4212301030523859220">"Uchungechunge"</string>
+    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Xhuma kumadivayisi ahambelanayo usebenzisa Uchungechunge ukuze uthole ukuhlola okulula kwekhaya elismathi"</string>
+    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Vala imodi yendiza ukuze usebenzise Uchungechunge"</string>
     <string name="camera_toggle_title" msgid="8952668677727244992">"Ukufinyelela kwekhamera"</string>
     <string name="mic_toggle_title" msgid="265145278323852547">"Ukufinyelela kwemakrofoni"</string>
     <string name="perm_toggle_description" msgid="5754629581767319022">"Okwama-app namasevisi"</string>
@@ -5124,8 +5105,7 @@
     <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Khansela"</string>
     <string name="contrast_title" msgid="6885768151336508075">"Ukugqama"</string>
     <string name="contrast_standard" msgid="1097297089917185235">"Okujwayelekile"</string>
-    <!-- no translation found for contrast_default (8918545965525226966) -->
-    <skip />
+    <string name="contrast_default" msgid="8918545965525226966">"Okuzenzakalelayo"</string>
     <string name="contrast_medium" msgid="384414510709285811">"Okuphakathi"</string>
     <string name="contrast_high" msgid="3988567609694797696">"Phezulu"</string>
     <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Le-app ingavulwa kuphela ewindini eli-1."</string>
diff --git a/res/values/accessibility_shortcut_keys.xml b/res/values/accessibility_shortcut_keys.xml
index 4992a54..fcf62bc 100644
--- a/res/values/accessibility_shortcut_keys.xml
+++ b/res/values/accessibility_shortcut_keys.xml
@@ -22,6 +22,7 @@
     <string name="accessibility_shortcut_nav_button_pref" translatable="false">shortcut_nav_button_pref</string>
     <string name="accessibility_shortcut_fab_pref" translatable="false">shortcut_fab_pref</string>
     <string name="accessibility_shortcut_triple_tap_pref" translatable="false">shortcut_triple_tap_pref</string>
-    <string name="accessibility_shortcut_two_fingers_double_tap_pref" translatable="false">shortcut_two_fingers_double_tap_pref</string>
+    <string name="accessibility_shortcut_two_finger_double_tap_pref" translatable="false">shortcut_two_finger_double_tap_pref</string>
+    <string name="accessibility_shortcut_quick_settings_pref" translatable="false">shortcut_quick_settings_pref</string>
     <string name="accessibility_shortcuts_advanced_collapsed" translatable="false">advanced_shortcuts_collapsed</string>
 </resources>
\ No newline at end of file
diff --git a/res/values/arrays.xml b/res/values/arrays.xml
index 0e35fed..6122e0d 100644
--- a/res/values/arrays.xml
+++ b/res/values/arrays.xml
@@ -232,6 +232,23 @@
 
 
     <!-- Bluetooth Settings -->
+    <!-- Titles for Bluetooth Stack Logging -->
+    <string-array name="bt_stack_log_level_entries">
+        <item>Verbose</item>
+        <item>Debug</item>
+        <item>Info</item>
+        <item>Warn</item>
+        <item>Error</item>
+    </string-array>
+
+    <!-- Values for Bluetooth Stack Logging -->
+    <string-array name="bt_stack_log_level_values" translatable="false">
+        <item>verbose</item>
+        <item>debug</item>
+        <item>info</item>
+        <item>warn</item>
+        <item>error</item>
+    </string-array>
 
     <!-- Bluetooth developer settings: Bluetooth LE Audio modes -->
     <string-array name="bluetooth_leaudio_mode">
@@ -1074,10 +1091,15 @@
     </string-array>
 
     <string-array name="wifi_privacy_entries">
-        <item>Use randomized MAC (default)</item>
+        <item>Use randomized MAC</item>
         <item>Use device MAC</item>
     </string-array>
 
+    <string-array name="wifi_dhcp_entries">
+        <item>Send device name to network</item>
+        <item>Don\u0027t send device name to network</item>
+    </string-array>
+
     <string-array name="wifi_hidden_entries">
         <item>No</item>
         <item>Yes</item>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 42d425f..409805a 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -150,14 +150,14 @@
     <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button">Pair right ear</string>
     <!-- Connected devices settings. Positive button of the dialog to help user to pair left ear of the hearing aid device. Dialog shows when only one of the hearing aid device set is connected. [CHAR LIMIT=20] -->
     <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button">Pair left ear</string>
-    <!-- Title for all hearing devices related controls section. [CHAR LIMIT=60] -->
-    <string name="bluetooth_device_controls_general">For all available hearing devices</string>
-    <!-- Connected devices settings. Title of the preference to show the entrance of the hearing device settings related page. [CHAR LIMIT=65] -->
-    <string name="bluetooth_device_controls_title">More hearing device settings</string>
-    <!-- Connected devices settings. Summary of the preference to show the item in the hearing device settings related page. [CHAR LIMIT=120] -->
-    <string name="bluetooth_device_controls_summary">Change cross-device settings like shortcut, and telecoil controls</string>
-    <!-- Title for this device specific controls section. [CHAR LIMIT=30] -->
-    <string name="bluetooth_device_controls_specific">For this device</string>
+    <!-- Connected devices settings. Title of the preference to show the entrance of the hearing device settings page. [CHAR LIMIT=65 BACKUP_MESSAGE_ID=1895676556354697234] -->
+    <string name="bluetooth_hearing_device_settings_title">Hearing device settings</string>
+    <!-- Connected devices settings. Summary of the preference to show the entrance of the hearing device settings page. [CHAR LIMIT=65 BACKUP_MESSAGE_ID=8115767735418425663] -->
+    <string name="bluetooth_hearing_device_settings_summary">Shortcut, hearing aid compatibility</string>
+    <!-- Connected devices settings. Title for hearing aids presets. A preset is a set of hearing aid settings. User can apply different settings in different environments (e.g. Outdoor, Restaurant, Home) [CHAR LIMIT=60] -->
+    <string name="bluetooth_hearing_aids_presets">Presets</string>
+    <!-- Message when selecting hearing aids presets failed. [CHAR LIMIT=NONE] -->
+    <string name="bluetooth_hearing_aids_presets_error">Couldn\u2019t update preset</string>
     <!-- Connected devices settings. Title of the preference to show the entrance of the audio output page. It can change different types of audio are played on phone or other bluetooth devices. [CHAR LIMIT=35] -->
     <string name="bluetooth_audio_routing_title">Audio output</string>
     <!-- Title for bluetooth audio routing page footer. [CHAR LIMIT=30] -->
@@ -1263,6 +1263,12 @@
     <string name="privatespace_hide_off_summary">Off</string>
     <!-- Used to describe the off state of Private space hidden [CHAR LIMIT=30] -->
     <string name="privatespace_hide_on_summary">On</string>
+    <!-- Title for the dialog shown when Private space hidden setting is turned on. [CHAR LIMIT=60] -->
+    <string name="private_space_hide_dialog_title">Private space will hide when you lock it next</string>
+    <!-- Text message in the dialog shown when Private space hidden setting is turned on. [CHAR LIMIT=90] -->
+    <string name="private_space_hide_dialog_message">To access your space when it’s hidden, enter \“private space\” in the search bar on your apps list</string>
+    <!-- Label for the dialog shown when Private space hidden setting is turned on. [CHAR LIMIT=90] -->
+    <string name="private_space_hide_dialog_button">Got it</string>
     <!-- System category for the Private Space page. [CHAR LIMIT=30] -->
     <string name="private_space_category_system">System</string>
     <!-- Title for the preference to delete Private Space. [CHAR LIMIT=40] -->
@@ -1850,11 +1856,6 @@
     <!-- Bluetooth developer settings: Maximum number of connected audio devices -->
     <string name="bluetooth_max_connected_audio_devices_dialog_title">Select maximum number of connected Bluetooth audio devices</string>
 
-    <!-- Nfc developer settings: The title of the setting. [CHAR LIMIT=60] -->
-    <string name="nfc_stack_debuglog_title">NFC stack debug log</string>
-    <!-- Nfc developer settings: The description of the setting. -->
-    <string name="nfc_stack_debuglog_summary">Increase NFC stack logging level</string>
-
     <!-- Nfc developer settings: The title of the setting to enable nfc verbose vendor log. [CHAR LIMIT=60] -->
     <string name="nfc_verbose_vendor_log_title">NFC verbose vendor debug log</string>
     <!-- Nfc developer settings: The description of the setting to enable nfc verbose vendor log. [CHAR_LIMIT=NONE] -->
@@ -4679,6 +4680,10 @@
     <string name="experimental_category_title">Experimental</string>
     <!-- Title for feature flags dashboard where developers can turn on experimental features [CHAR LIMIT=50] -->
     <string name="feature_flags_dashboard_title">Feature flags</string>
+    <!-- Setting Checkbox title whether to enable Bluetooth stack log -->
+    <string name="bt_stack_log_level">Enable Bluetooth stack log</string>
+    <!-- setting Checkbox summary to set log level [CHAR_LIMIT=100] -->
+    <string name="bt_stack_log_level_summary">Change log level of Bluetooth Stack Logging (Toggle Bluetooth after changing this setting)</string>
     <!-- Title for snoop logger filters dashboard where developers can turn on filters [CHAR LIMIT=100] -->
     <string name="bt_hci_snoop_log_filters_dashboard_title">Bluetooth HCI snoop log filtering</string>
     <!-- Summary for the snoop logger filters [CHAR LIMIT=100] -->
@@ -4838,6 +4843,8 @@
     <string name="accessibility_tutorial_dialog_title_triple">Triple tap screen to open</string>
     <!-- Title for the accessibility tutorial dialog in accessibility service with two finger double tap. [CHAR LIMIT=100] -->
     <string name="accessibility_tutorial_dialog_title_two_finger_double">Two finger double tap screen to open</string>
+    <!-- Title for the accessibility tutorial dialog in accessibility service with quick setting shortcut. [CHAR LIMIT=100] -->
+    <string name="accessibility_tutorial_dialog_title_quick_setting">Quick Settings shortcut</string>
     <!-- Title for the accessibility tutorial dialog in accessibility service with gesture. [CHAR LIMIT=50] -->
     <string name="accessibility_tutorial_dialog_title_gesture">Use gesture to open</string>
     <!-- Title for the accessibility tutorial dialog in gesture navigation settings. [CHAR LIMIT=50] -->
@@ -4852,6 +4859,8 @@
     <string name="accessibility_tutorial_dialog_message_triple">To start and stop magnification, triple-tap anywhere on your screen.</string>
     <!-- Instruction for the accessibility tutorial dialog in accessibility service with two finger double tap. [CHAR LIMIT=100] -->
     <string name="accessibility_tutorial_dialog_message_two_finger_triple">To start and stop magnification, double-tap anywhere on your screen with two fingers.</string>
+    <!-- Instruction for the accessibility tutorial dialog in accessibility service with triple tap. [CHAR LIMIT=NONE]-->
+    <string name="accessibility_tutorial_dialog_message_quick_setting">To use this feature, swipe down from the top of your screen.</string>
     <!-- Message for the accessibility tutorial dialog when user enables an accessibility service while using gesture navigation and touch exploration is not enabled. [CHAR LIMIT=NONE] -->
     <string name="accessibility_tutorial_dialog_message_gesture">To use this feature, swipe up from the bottom of the screen with 2 fingers.\n\nTo switch between features, swipe up with 2 fingers and hold.</string>
     <!-- Message for the accessibility tutorial dialog when user enables an accessibility service while using gesture navigation and touch exploration is enabled. [CHAR LIMIT=NONE] -->
@@ -4866,10 +4875,10 @@
     <string name="accessibility_tutorial_dialog_link_button">Button settings</string>
     <!-- Title for accessibility shortcut preference for accessibility apps. [CHAR LIMIT=40] -->
     <string name="accessibility_shortcut_title"><xliff:g id="service" example="Select to Speak">%1$s</xliff:g> shortcut</string>
-    <!-- Title for software shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
-    <string name="accessibility_shortcut_edit_summary_software">Accessibility button</string>
-    <!-- Title for software shortcut gesture in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
-    <string name="accessibility_shortcut_edit_summary_software_gesture">Accessibility gesture</string>
+    <!-- Shown as one of the item in the chosen accessibility shortcut types list presented as a label next to the shortcut toggle. [CHAR LIMIT=NONE] -->
+    <string name="accessibility_shortcut_edit_summary_software">accessibility button</string>
+    <!-- Shown as one of the item in the chosen accessibility shortcut types list presented as a label next to the shortcut toggle. [CHAR LIMIT=NONE] -->
+    <string name="accessibility_shortcut_edit_summary_software_gesture">accessibility gesture</string>
     <!-- Title for software shortcut in gesture mode in accessibility edit shortcut dialog while using gesture navigation is enabled. [CHAR LIMIT=NONE] -->
     <string name="accessibility_shortcut_edit_dialog_title_software_gesture">Swipe up with 2 fingers</string>
     <!-- Title for software shortcut in gesture mode in accessibility edit shortcut dialog while using gesture navigation and touch exploration are enabled. [CHAR LIMIT=NONE] -->
@@ -4888,6 +4897,12 @@
     <string name="accessibility_shortcut_edit_dialog_summary_software_floating"><annotation id="link">More options</annotation></string>
     <!-- Footer to show help link content description. [CHAR LIMIT=NONE] -->
     <string name="footer_learn_more_content_description">Learn more about <xliff:g id="service" example="Select to Speak">%1$s</xliff:g></string>
+    <!-- Title for quick settings shortcut option in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
+    <string name="accessibility_shortcut_edit_dialog_title_quick_settings">Quick Settings</string>
+    <!-- Summary for quick settings shortcut option in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
+    <string name="accessibility_shortcut_edit_dialog_summary_quick_settings">Swipe down from the top of your screen</string>
+    <!-- Shown as one of the item in the chosen accessibility shortcut types list presented as a label next to the shortcut toggle. [CHAR LIMIT=NONE] -->
+    <string name="accessibility_feature_shortcut_setting_summary_quick_settings">Quick Settings</string>
     <!-- Title for hardware shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
     <string name="accessibility_shortcut_edit_dialog_title_hardware">Hold volume keys</string>
     <!-- Part of list to compose user's accessibility shortcut list. [CHAR LIMIT=NONE] -->
@@ -4977,7 +4992,7 @@
     <!-- Title for the accessibility preference to high contrast text. [CHAR LIMIT=35] -->
     <string name="accessibility_toggle_maximize_text_contrast_preference_title">Maximize text contrast</string>
     <!-- Summary for the accessibility preference to high contrast text. [CHAR LIMIT=NONE] -->
-    <string name="accessibility_toggle_maximize_text_contrast_preference_summary">Change text color to black or white to increase contrast with the background.</string>
+    <string name="accessibility_toggle_maximize_text_contrast_preference_summary">Add a black or white background around text to increase contrast</string>
     <!-- Title for the accessibility preference to auto update screen magnification. [CHAR LIMIT=35] -->
     <string name="accessibility_toggle_screen_magnification_auto_update_preference_title">Auto
         update screen magnification</string>
@@ -10467,6 +10482,9 @@
     <!-- Summary text for 3-button navigation  [CHAR LIMIT=NONE] -->
     <string name="legacy_navigation_summary">Go back, Home, and switch apps with buttons at the bottom of your screen.</string>
 
+    <!-- Accessibility string for gesture nav tutorial button [CHAR_LIMIT=NONE] -->
+    <string name="nav_tutorial_button_description">Start gesture navigation tutorial</string>
+
     <!-- Search keywords for System Navigation settings. [CHAR_LIMIT=NONE]-->
     <string name="keywords_system_navigation">system navigation, 2 button navigation, 3 button navigation, gesture navigation, swipe</string>
 
@@ -11980,6 +11998,15 @@
     <!-- Toast message when 16k OTA update fails -->
     <string name="toast_16k_update_failed_text">Failed to update kernel to 16KB pages compatible kernel.</string>
     <string name="progress_16k_ota_title">Applying change</string>
+    <!-- Confirmation dialog title and text to reformat data to ext4 -->
+    <string name="confirm_format_ext4_title">Reformat device to ext4?</string>
+    <string name="confirm_format_ext4_text">16K developer option is supported with ext4 filesystem. Device will be wiped and filesystem will be changed to ext4 after confirmation.</string>
+    <!-- Toast on failure to reformat data to ext4 -->
+    <string name="format_ext4_failure_toast">Failed to reformat and wipe the data partiton to ext4.</string>
+    <!-- Dialog to OEM unlock the device before using 16K developer option -->
+    <string name="confirm_oem_unlock_for_16k_title">OEM unlock required</string>
+    <string name="confirm_oem_unlock_for_16k_text">Device needs to be OEM unlocked before using 16K developer option. OEM unlock will also require formatting userdata. Please OEM unlock the device and try again.</string>
+
     <!-- DSU Loader. Do not translate. -->
 
     <string name="dsu_loader_title" translatable="false">DSU Loader</string>
@@ -13012,11 +13039,6 @@
     <!-- Developer settings: select Grammatical gender dialog title [CHAR LIMIT=50]-->
     <string name="grammatical_gender_dialog_title">Select Grammatical gender</string>
 
-    <!-- Do not translate. Developer settings: Title for the screen allowing user to control Quarantined apps [CHAR LIMIT=50] -->
-    <string name="quarantined_apps_title" translatable="false">Quarantined Apps</string>
-    <!-- Do not translate. Developer settings: Button to unquarantine an app [CHAR LIMIT=20] -->
-    <string name="unquarantine_app_button" translatable="false">Unquarantine app</string>
-
     <!-- Title of preference to manage content protection settings -->
     <string name="content_protection_preference_title">Scanning for deceptive apps</string>
     <!-- Summary of the preference to manage content protection settings -->
diff --git a/res/values/styles.xml b/res/values/styles.xml
index 0a28b01..fe2084f 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -249,7 +249,7 @@
         <item name="android:layout_gravity">center</item>
         <item name="android:fontFamily">@*android:string/config_headlineFontFamily</item>
         <item name="android:textSize">@dimen/search_bar_text_size</item>
-        <item name="android:textColor">?android:attr/textColorSecondary</item>
+        <item name="android:textColor">?androidprv:attr/materialColorOnSurfaceVariant</item>
         <item name="android:singleLine">true</item>
     </style>
 
diff --git a/res/values/themes_suw.xml b/res/values/themes_suw.xml
index 71d9fcb..9efac28 100644
--- a/res/values/themes_suw.xml
+++ b/res/values/themes_suw.xml
@@ -231,7 +231,7 @@
     <style name="SuwAlertDialogThemeCompat" parent="@style/Theme.AppCompat.Dialog.Alert">
         <!-- Referenced SudThemeGlifV3 style -->
         <item name="android:textAllCaps">false</item>
-
+        <item name="android:colorBackground">@android:color/system_neutral1_900</item>
         <item name="android:windowSoftInputMode">adjustResize</item>
         <!-- copied from Theme.DeviceDefault.Dialog.Alert -->
         <item name="colorAccent">@*android:color/accent_device_default_dark</item>
@@ -243,7 +243,7 @@
     <style name="SuwAlertDialogThemeCompat.Light" parent="@style/Theme.AppCompat.Light.Dialog.Alert">
         <!-- Referenced SudThemeGlifV3.Light style -->
         <item name="android:textAllCaps">false</item>
-
+        <item name="android:colorBackground">@android:color/system_neutral1_50</item>
         <item name="android:windowSoftInputMode">adjustResize</item>
         <!-- copied from Theme.DeviceDefault.Light.Dialog.Alert -->
         <item name="colorAccent">@*android:color/accent_device_default_light</item>
diff --git a/res/xml/accessibility_edit_shortcuts.xml b/res/xml/accessibility_edit_shortcuts.xml
index fdb5b99..37e25af 100644
--- a/res/xml/accessibility_edit_shortcuts.xml
+++ b/res/xml/accessibility_edit_shortcuts.xml
@@ -26,6 +26,14 @@
         settings:allowDividerBelow="false"/>
 
     <com.android.settings.accessibility.shortcuts.ShortcutOptionPreference
+        android:key="@string/accessibility_shortcut_quick_settings_pref"
+        android:persistent="false"
+        android:selectable="true"
+        settings:allowDividerAbove="false"
+        settings:allowDividerBelow="false"
+        settings:controller="com.android.settings.accessibility.shortcuts.QuickSettingsShortcutOptionController" />
+
+    <com.android.settings.accessibility.shortcuts.ShortcutOptionPreference
         android:key="@string/accessibility_shortcut_fab_pref"
         android:persistent="false"
         android:selectable="true"
@@ -58,12 +66,12 @@
         settings:controller="com.android.settings.accessibility.shortcuts.VolumeKeysShortcutOptionController" />
 
     <com.android.settings.accessibility.shortcuts.ShortcutOptionPreference
-        android:key="@string/accessibility_shortcut_two_fingers_double_tap_pref"
+        android:key="@string/accessibility_shortcut_two_finger_double_tap_pref"
         android:persistent="false"
         android:selectable="true"
         settings:allowDividerAbove="false"
         settings:allowDividerBelow="false"
-        settings:controller="com.android.settings.accessibility.shortcuts.TwoFingersDoubleTapShortcutOptionController" />
+        settings:controller="com.android.settings.accessibility.shortcuts.TwoFingerDoubleTapShortcutOptionController" />
 
     <Preference
         android:icon="@drawable/ic_keyboard_arrow_down"
diff --git a/res/xml/bluetooth_device_details_fragment.xml b/res/xml/bluetooth_device_details_fragment.xml
index d260554..91f73a7 100644
--- a/res/xml/bluetooth_device_details_fragment.xml
+++ b/res/xml/bluetooth_device_details_fragment.xml
@@ -69,7 +69,7 @@
         android:key="device_companion_apps"/>
 
     <PreferenceCategory
-        android:key="device_controls_general" />
+        android:key="hearing_device_group" />
 
     <PreferenceCategory
         android:key="bluetooth_audio_device_type_group"/>
diff --git a/res/xml/development_settings.xml b/res/xml/development_settings.xml
index c0b6560..23eb1f2 100644
--- a/res/xml/development_settings.xml
+++ b/res/xml/development_settings.xml
@@ -75,6 +75,13 @@
             android:entryValues="@array/hdcp_checking_values" />
 
         <ListPreference
+            android:key="bt_stack_log_level"
+            android:title="@string/bt_stack_log_level"
+            android:dialogTitle="@string/bt_stack_log_level_summary"
+            android:entries="@array/bt_stack_log_level_entries"
+            android:entryValues="@array/bt_stack_log_level_values" />
+
+        <ListPreference
             android:key="bt_hci_snoop_log"
             android:title="@string/bt_hci_snoop_log"
             android:dialogTitle="@string/bt_hci_snoop_log_summary"
@@ -463,11 +470,6 @@
             android:entryValues="@array/bluetooth_max_connected_audio_devices_values" />
 
         <SwitchPreferenceCompat
-            android:key="nfc_stack_debuglog_enabled"
-            android:title="@string/nfc_stack_debuglog_title"
-            android:summary="@string/nfc_stack_debuglog_summary" />
-
-        <SwitchPreferenceCompat
             android:key="nfc_verbose_vendor_log"
             android:title="@string/nfc_verbose_vendor_log_title"
             android:summary="@string/nfc_verbose_vendor_log_summary" />
@@ -769,12 +771,6 @@
             android:title="@string/enable_notes_role_title"
             android:summary="@string/enable_notes_role_summary" />
 
-        <Preference
-            android:key="quarantined_apps"
-            android:title="@string/quarantined_apps_title"
-            settings:controller="com.android.settings.development.quarantine.QuarantinedAppsPreferenceController"
-            android:fragment="com.android.settings.development.quarantine.QuarantinedAppsFragment" />
-
     </PreferenceCategory>
 
     <PreferenceCategory
diff --git a/res/xml/mobile_network_settings.xml b/res/xml/mobile_network_settings.xml
index 1e43ef0..adb84b6 100644
--- a/res/xml/mobile_network_settings.xml
+++ b/res/xml/mobile_network_settings.xml
@@ -18,9 +18,8 @@
     xmlns:settings="http://schemas.android.com/apk/res-auto"
     android:key="mobile_network_pref_screen">
 
-    <com.android.settings.widget.SettingsMainSwitchPreference
+    <com.android.settings.spa.preference.ComposePreference
         android:key="use_sim_switch"
-        android:title="@string/mobile_network_use_sim_on"
         settings:controller="com.android.settings.network.telephony.MobileNetworkSwitchController"/>
 
     <PreferenceCategory
diff --git a/res/xml/quarantined_apps.xml b/res/xml/quarantined_apps.xml
deleted file mode 100644
index 69a90d6..0000000
--- a/res/xml/quarantined_apps.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<?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.
--->
-
-<PreferenceScreen
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:settings="http://schemas.android.com/apk/res-auto"
-    android:key="quarantined_apps_screen"
-    android:title="@string/quarantined_apps_title"
-    settings:controller="com.android.settings.development.quarantine.QuarantinedAppsScreenController"
-    settings:searchable="true">
-</PreferenceScreen>
\ No newline at end of file
diff --git a/res/xml/security_lockscreen_settings.xml b/res/xml/security_lockscreen_settings.xml
index cb1ce44..15d5303 100644
--- a/res/xml/security_lockscreen_settings.xml
+++ b/res/xml/security_lockscreen_settings.xml
@@ -69,9 +69,11 @@
             android:summary="@string/lockscreen_trivial_controls_summary"
             settings:controller="com.android.settings.display.ControlsTrivialPrivacyPreferenceController"/>
 
+        <!-- Shortcuts -->
         <Preference
             android:key="customizable_lock_screen_quick_affordances"
             android:title="@string/lockscreen_quick_affordances_title"
+            android:summary="@string/summary_placeholder"
             settings:controller="com.android.settings.display.CustomizableLockScreenQuickAffordancesPreferenceController" />
 
         <SwitchPreferenceCompat
diff --git a/res/xml/wifi_network_details_fragment2.xml b/res/xml/wifi_network_details_fragment2.xml
index 598f9d8..eacff88 100644
--- a/res/xml/wifi_network_details_fragment2.xml
+++ b/res/xml/wifi_network_details_fragment2.xml
@@ -112,6 +112,10 @@
         android:title="@string/wifi_auto_connect_title"
         android:summary="@string/wifi_auto_connect_summary"/>
 
+    <com.android.settings.spa.preference.ComposePreference
+        android:key="certificate_details"
+        settings:controller="com.android.settings.wifi.details2.CertificateDetailsPreferenceController"/>
+
     <!-- Add device Preference -->
     <Preference
         android:key="add_device_to_network"
diff --git a/src/com/android/settings/MainClear.java b/src/com/android/settings/MainClear.java
index 7b96d42..87b11f7 100644
--- a/src/com/android/settings/MainClear.java
+++ b/src/com/android/settings/MainClear.java
@@ -426,7 +426,7 @@
     @VisibleForTesting
     protected boolean isEuiccEnabled(Context context) {
         EuiccManager euiccManager = (EuiccManager) context.getSystemService(Context.EUICC_SERVICE);
-        return euiccManager.isEnabled();
+        return euiccManager != null && euiccManager.isEnabled();
     }
 
     @VisibleForTesting
diff --git a/src/com/android/settings/ResetNetwork.java b/src/com/android/settings/ResetNetwork.java
index c33a4f8..642485a 100644
--- a/src/com/android/settings/ResetNetwork.java
+++ b/src/com/android/settings/ResetNetwork.java
@@ -293,7 +293,7 @@
         }
         EuiccManager euiccManager =
                 (EuiccManager) context.getSystemService(Context.EUICC_SERVICE);
-        if (!euiccManager.isEnabled()) {
+        if (euiccManager == null || !euiccManager.isEnabled()) {
             return false;
         }
         ContentResolver resolver = context.getContentResolver();
diff --git a/src/com/android/settings/SettingsApplication.java b/src/com/android/settings/SettingsApplication.java
index 1a53b83..c0d2445 100644
--- a/src/com/android/settings/SettingsApplication.java
+++ b/src/com/android/settings/SettingsApplication.java
@@ -30,6 +30,7 @@
 import com.android.settings.core.instrumentation.ElapsedTimeUtils;
 import com.android.settings.fuelgauge.BatterySettingsStorage;
 import com.android.settings.homepage.SettingsHomepageActivity;
+import com.android.settings.localepicker.LocaleNotificationDataManager;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settings.overlay.FeatureFactoryImpl;
 import com.android.settings.spa.SettingsSpaEnvironment;
@@ -56,7 +57,10 @@
     public void onCreate() {
         super.onCreate();
 
-        BackupRestoreStorageManager.getInstance(this).add(new BatterySettingsStorage(this));
+        BackupRestoreStorageManager.getInstance(this)
+                .add(
+                        new BatterySettingsStorage(this),
+                        LocaleNotificationDataManager.getSharedPreferencesStorage(this));
 
         // Add null checking to avoid test case failed.
         if (getApplicationContext() != null) {
diff --git a/src/com/android/settings/Utils.java b/src/com/android/settings/Utils.java
index 6e36ee3..c38ebfe 100644
--- a/src/com/android/settings/Utils.java
+++ b/src/com/android/settings/Utils.java
@@ -1289,7 +1289,8 @@
      */
     @ColorInt
     public static int getHomepageIconColor(Context context) {
-        return getColorAttrDefaultColor(context, android.R.attr.textColorPrimary);
+        return getColorAttrDefaultColor(
+                context, com.android.internal.R.attr.materialColorOnSurface);
     }
 
     /**
diff --git a/src/com/android/settings/accessibility/AccessibilityGestureNavigationTutorial.java b/src/com/android/settings/accessibility/AccessibilityGestureNavigationTutorial.java
index 1f71ab0..4b394a0 100644
--- a/src/com/android/settings/accessibility/AccessibilityGestureNavigationTutorial.java
+++ b/src/com/android/settings/accessibility/AccessibilityGestureNavigationTutorial.java
@@ -414,7 +414,7 @@
 
     private static TutorialPage createTwoFingerTripleTapTutorialPage(@NonNull Context context) {
         // TODO(b/308088945): Update tutorial string and image when UX provides them
-        final int type = UserShortcutType.TWOFINGERTRIPLETAP;
+        final int type = UserShortcutType.TWOFINGER_DOUBLETAP;
         final CharSequence title =
                 context.getText(R.string.accessibility_tutorial_dialog_title_two_finger_double);
         final View image =
@@ -429,10 +429,32 @@
         return new TutorialPage(type, title, image, indicatorIcon, instruction);
     }
 
+    private static TutorialPage createQuickSettingTutorialPage(@NonNull Context context) {
+        final int type = UserShortcutType.QUICK_SETTINGS;
+        final CharSequence title =
+                context.getText(R.string.accessibility_tutorial_dialog_title_quick_setting);
+        final View image =
+                createIllustrationView(context,
+                        R.drawable.a11y_shortcut_type_quick_settings);
+        final CharSequence instruction =
+                context.getText(R.string.accessibility_tutorial_dialog_message_quick_setting);
+        final ImageView indicatorIcon =
+                createImageView(context, R.drawable.ic_accessibility_page_indicator);
+        indicatorIcon.setEnabled(false);
+
+        return new TutorialPage(type, title, image, indicatorIcon, instruction);
+    }
+
     @VisibleForTesting
     static List<TutorialPage> createShortcutTutorialPages(@NonNull Context context,
             int shortcutTypes) {
         final List<TutorialPage> tutorialPages = new ArrayList<>();
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            if ((shortcutTypes & UserShortcutType.QUICK_SETTINGS)
+                    == UserShortcutType.QUICK_SETTINGS) {
+                tutorialPages.add(createQuickSettingTutorialPage(context));
+            }
+        }
         if ((shortcutTypes & UserShortcutType.SOFTWARE) == UserShortcutType.SOFTWARE) {
             tutorialPages.add(createSoftwareTutorialPage(context));
         }
@@ -446,8 +468,8 @@
         }
 
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if ((shortcutTypes & UserShortcutType.TWOFINGERTRIPLETAP)
-                    == UserShortcutType.TWOFINGERTRIPLETAP) {
+            if ((shortcutTypes & UserShortcutType.TWOFINGER_DOUBLETAP)
+                    == UserShortcutType.TWOFINGER_DOUBLETAP) {
                 tutorialPages.add(createTwoFingerTripleTapTutorialPage(context));
             }
         }
diff --git a/src/com/android/settings/accessibility/AccessibilitySettings.java b/src/com/android/settings/accessibility/AccessibilitySettings.java
index fe89bf2..35fe6e4 100644
--- a/src/com/android/settings/accessibility/AccessibilitySettings.java
+++ b/src/com/android/settings/accessibility/AccessibilitySettings.java
@@ -175,6 +175,9 @@
         // Observe changes from accessibility selection menu
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS);
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE);
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_QS_TARGETS);
+        }
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_STICKY_KEYS);
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_SLOW_KEYS);
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_BOUNCE_KEYS);
diff --git a/src/com/android/settings/accessibility/AccessibilityShortcutPreferenceFragment.java b/src/com/android/settings/accessibility/AccessibilityShortcutPreferenceFragment.java
index 09a691e..41c5d75 100644
--- a/src/com/android/settings/accessibility/AccessibilityShortcutPreferenceFragment.java
+++ b/src/com/android/settings/accessibility/AccessibilityShortcutPreferenceFragment.java
@@ -125,6 +125,9 @@
         final List<String> shortcutFeatureKeys = new ArrayList<>();
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS);
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE);
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_QS_TARGETS);
+        }
         mSettingsContentObserver = new AccessibilitySettingsContentObserver(new Handler());
         mSettingsContentObserver.registerKeysToObserverCallback(shortcutFeatureKeys, key -> {
             updateShortcutPreferenceData();
@@ -452,7 +455,13 @@
                 getComponentName().flattenToString());
 
         final List<CharSequence> list = new ArrayList<>();
-
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            if (hasShortcutType(shortcutTypes, AccessibilityUtil.UserShortcutType.QUICK_SETTINGS)) {
+                final CharSequence qsTitle = context.getText(
+                        R.string.accessibility_feature_shortcut_setting_summary_quick_settings);
+                list.add(qsTitle);
+            }
+        }
         if (hasShortcutType(shortcutTypes, AccessibilityUtil.UserShortcutType.SOFTWARE)) {
             list.add(getSoftwareShortcutTypeSummary(context));
         }
@@ -538,6 +547,10 @@
     }
 
     private void showQuickSettingsTooltipIfNeeded() {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            // Don't show Quick Settings tooltip
+            return;
+        }
         final ComponentName tileComponentName = getTileComponentName();
         if (tileComponentName == null) {
             // Returns if no tile service assigned.
diff --git a/src/com/android/settings/accessibility/AccessibilityUtil.java b/src/com/android/settings/accessibility/AccessibilityUtil.java
index 3b81bdb..afc7b84 100644
--- a/src/com/android/settings/accessibility/AccessibilityUtil.java
+++ b/src/com/android/settings/accessibility/AccessibilityUtil.java
@@ -28,6 +28,7 @@
 import android.graphics.Insets;
 import android.graphics.Rect;
 import android.os.Build;
+import android.os.UserHandle;
 import android.provider.Settings;
 import android.text.TextUtils;
 import android.util.TypedValue;
@@ -40,8 +41,11 @@
 import androidx.annotation.StringRes;
 import androidx.annotation.VisibleForTesting;
 
+import com.android.internal.accessibility.util.ShortcutUtils;
+
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
+import java.util.Set;
 import java.util.StringJoiner;
 
 /** Provides utility methods to accessibility settings only. */
@@ -87,6 +91,10 @@
      * choose accessibility shortcut as preferred shortcut.
      * {@code TRIPLETAP} for displaying specifying magnification to be toggled via quickly
      * tapping screen 3 times as preferred shortcut.
+     * {@code TWOFINGER_DOUBLETAP} for displaying specifying magnification to be toggled via
+     * quickly tapping screen 2 times with two fingers as preferred shortcut.
+     * {@code QUICK_SETTINGS} for displaying specifying the accessibility services or features which
+     * choose Quick Settings as preferred shortcut.
      */
     @Retention(RetentionPolicy.SOURCE)
     @IntDef({
@@ -94,16 +102,18 @@
             UserShortcutType.SOFTWARE,
             UserShortcutType.HARDWARE,
             UserShortcutType.TRIPLETAP,
-            UserShortcutType.TWOFINGERTRIPLETAP,
+            UserShortcutType.TWOFINGER_DOUBLETAP,
+            UserShortcutType.QUICK_SETTINGS,
     })
 
     /** Denotes the user shortcut type. */
     public @interface UserShortcutType {
         int EMPTY = 0;
-        int SOFTWARE = 1; // 1 << 0
-        int HARDWARE = 2; // 1 << 1
-        int TRIPLETAP = 4; // 1 << 2
-        int TWOFINGERTRIPLETAP = 8; // 1 << 3
+        int SOFTWARE = 1;
+        int HARDWARE = 1 << 1;
+        int TRIPLETAP = 1 << 2;
+        int TWOFINGER_DOUBLETAP = 1 << 3;
+        int QUICK_SETTINGS = 1 << 4;
     }
 
     /**
@@ -200,12 +210,26 @@
      * Opts in component name into multiple {@code shortcutTypes} colon-separated string in
      * Settings.
      *
-     * @param context The current context.
-     * @param shortcutTypes  A combination of {@link UserShortcutType}.
+     * @param context       The current context.
+     * @param shortcutTypes A combination of {@link UserShortcutType}.
      * @param componentName The component name that need to be opted in Settings.
      */
     static void optInAllValuesToSettings(Context context, int shortcutTypes,
             @NonNull ComponentName componentName) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            AccessibilityManager a11yManager = context.getSystemService(AccessibilityManager.class);
+            if (a11yManager != null) {
+                a11yManager.enableShortcutsForTargets(
+                        /* enable= */ true,
+                        shortcutTypes,
+                        Set.of(componentName.flattenToString()),
+                        UserHandle.myUserId()
+                );
+            }
+
+            return;
+        }
+
         if ((shortcutTypes & UserShortcutType.SOFTWARE) == UserShortcutType.SOFTWARE) {
             optInValueToSettings(context, UserShortcutType.SOFTWARE, componentName);
         }
@@ -217,13 +241,26 @@
     /**
      * Opts in component name into {@code shortcutType} colon-separated string in Settings.
      *
-     * @param context The current context.
-     * @param shortcutType The preferred shortcut type user selected.
+     * @param context       The current context.
+     * @param shortcutType  The preferred shortcut type user selected.
      * @param componentName The component name that need to be opted in Settings.
      */
     @VisibleForTesting
     static void optInValueToSettings(Context context, @UserShortcutType int shortcutType,
             @NonNull ComponentName componentName) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            AccessibilityManager a11yManager = context.getSystemService(AccessibilityManager.class);
+            if (a11yManager != null) {
+                a11yManager.enableShortcutsForTargets(
+                        /* enable= */ true,
+                        shortcutType,
+                        Set.of(componentName.flattenToString()),
+                        UserHandle.myUserId()
+                );
+            }
+            return;
+        }
+
         final String targetKey = convertKeyFromSettings(shortcutType);
         final String targetString = Settings.Secure.getString(context.getContentResolver(),
                 targetKey);
@@ -245,12 +282,25 @@
      * Opts out component name into multiple {@code shortcutTypes} colon-separated string in
      * Settings.
      *
-     * @param context The current context.
+     * @param context       The current context.
      * @param shortcutTypes A combination of {@link UserShortcutType}.
      * @param componentName The component name that need to be opted out from Settings.
      */
     static void optOutAllValuesFromSettings(Context context, int shortcutTypes,
             @NonNull ComponentName componentName) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            AccessibilityManager a11yManager = context.getSystemService(AccessibilityManager.class);
+            if (a11yManager != null) {
+                a11yManager.enableShortcutsForTargets(
+                        /* enable= */ false,
+                        shortcutTypes,
+                        Set.of(componentName.flattenToString()),
+                        UserHandle.myUserId()
+                );
+            }
+            return;
+        }
+
         if ((shortcutTypes & UserShortcutType.SOFTWARE) == UserShortcutType.SOFTWARE) {
             optOutValueFromSettings(context, UserShortcutType.SOFTWARE, componentName);
         }
@@ -262,13 +312,26 @@
     /**
      * Opts out component name into {@code shortcutType} colon-separated string in Settings.
      *
-     * @param context The current context.
-     * @param shortcutType The preferred shortcut type user selected.
+     * @param context       The current context.
+     * @param shortcutType  The preferred shortcut type user selected.
      * @param componentName The component name that need to be opted out from Settings.
      */
     @VisibleForTesting
     static void optOutValueFromSettings(Context context, @UserShortcutType int shortcutType,
             @NonNull ComponentName componentName) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            AccessibilityManager a11yManager = context.getSystemService(AccessibilityManager.class);
+            if (a11yManager != null) {
+                a11yManager.enableShortcutsForTargets(
+                        /* enable= */ false,
+                        shortcutType,
+                        Set.of(componentName.flattenToString()),
+                        UserHandle.myUserId()
+                );
+            }
+            return;
+        }
+
         final StringJoiner joiner = new StringJoiner(String.valueOf(COMPONENT_NAME_SEPARATOR));
         final String targetKey = convertKeyFromSettings(shortcutType);
         final String targetString = Settings.Secure.getString(context.getContentResolver(),
@@ -307,6 +370,14 @@
         if (((shortcutTypes & UserShortcutType.HARDWARE) == UserShortcutType.HARDWARE)) {
             exist |= hasValueInSettings(context, UserShortcutType.HARDWARE, componentName);
         }
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            if ((shortcutTypes & UserShortcutType.QUICK_SETTINGS)
+                    == UserShortcutType.QUICK_SETTINGS) {
+                exist |= hasValueInSettings(context, UserShortcutType.QUICK_SETTINGS,
+                        componentName);
+            }
+        }
+
         return exist;
     }
 
@@ -321,6 +392,12 @@
     @VisibleForTesting
     static boolean hasValueInSettings(Context context, @UserShortcutType int shortcutType,
             @NonNull ComponentName componentName) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            return ShortcutUtils.getShortcutTargetsFromSettings(
+                    context, shortcutType, UserHandle.myUserId()
+            ).contains(componentName.flattenToString());
+        }
+
         final String targetKey = convertKeyFromSettings(shortcutType);
         final String targetString = Settings.Secure.getString(context.getContentResolver(),
                 targetKey);
@@ -357,6 +434,12 @@
         if (hasValuesInSettings(context, UserShortcutType.HARDWARE, componentName)) {
             shortcutTypes |= UserShortcutType.HARDWARE;
         }
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            if (hasValuesInSettings(context, UserShortcutType.QUICK_SETTINGS, componentName)) {
+                shortcutTypes |= UserShortcutType.QUICK_SETTINGS;
+            }
+        }
+
         return shortcutTypes;
     }
 
@@ -367,6 +450,10 @@
      * @return Mapping key in Settings.
      */
     static String convertKeyFromSettings(@UserShortcutType int shortcutType) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            return ShortcutUtils.convertToKey(shortcutType);
+        }
+
         switch (shortcutType) {
             case UserShortcutType.SOFTWARE:
                 return Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS;
diff --git a/src/com/android/settings/accessibility/ColorAndMotionFragment.java b/src/com/android/settings/accessibility/ColorAndMotionFragment.java
index 28c5335..4ea2226 100644
--- a/src/com/android/settings/accessibility/ColorAndMotionFragment.java
+++ b/src/com/android/settings/accessibility/ColorAndMotionFragment.java
@@ -74,6 +74,9 @@
         mShortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED);
         mShortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE);
         mShortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS);
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            mShortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_QS_TARGETS);
+        }
         if (Flags.forceInvertColor()) {
             mShortcutFeatureKeys.add(ToggleForceInvertPreferenceController.SETTINGS_KEY);
         }
diff --git a/src/com/android/settings/accessibility/HearingDevicePairingFragment.java b/src/com/android/settings/accessibility/HearingDevicePairingFragment.java
index 0b762f3..c797559 100644
--- a/src/com/android/settings/accessibility/HearingDevicePairingFragment.java
+++ b/src/com/android/settings/accessibility/HearingDevicePairingFragment.java
@@ -192,7 +192,7 @@
     public void onDeviceBondStateChanged(@NonNull CachedBluetoothDevice cachedDevice,
             int bondState) {
         if (DEBUG) {
-            Log.d(TAG, "onDeviceBondStateChanged: " + cachedDevice.getDevice() + ", state = "
+            Log.d(TAG, "onDeviceBondStateChanged: " + cachedDevice + ", state = "
                     + bondState);
         }
         if (bondState == BluetoothDevice.BOND_BONDED) {
@@ -276,13 +276,13 @@
         }
         mDevicePreferenceMap.put(cachedDevice, preference);
         if (DEBUG) {
-            Log.d(TAG, "Add device. device: " + cachedDevice.getDevice());
+            Log.d(TAG, "Add device. device: " + cachedDevice);
         }
     }
 
     void removeDevice(CachedBluetoothDevice cachedDevice) {
         if (DEBUG) {
-            Log.d(TAG, "removeDevice: " + cachedDevice.getDevice());
+            Log.d(TAG, "removeDevice: " + cachedDevice);
         }
         BluetoothDevicePreference preference = mDevicePreferenceMap.remove(cachedDevice);
         if (mAvailableHearingDeviceGroup != null && preference != null) {
@@ -331,13 +331,13 @@
             cachedDevice = mCachedDeviceManager.addDevice(device);
         } else if (cachedDevice.getBondState() == BluetoothDevice.BOND_BONDED) {
             if (DEBUG) {
-                Log.d(TAG, "Skip this device, already bonded: " + cachedDevice.getDevice());
+                Log.d(TAG, "Skip this device, already bonded: " + cachedDevice);
             }
             return;
         }
         if (cachedDevice.getHearingAidInfo() == null) {
             if (DEBUG) {
-                Log.d(TAG, "Set hearing aid info on device: " + cachedDevice.getDevice());
+                Log.d(TAG, "Set hearing aid info on device: " + cachedDevice);
             }
             cachedDevice.setHearingAidInfo(new HearingAidInfo.Builder().build());
         }
@@ -455,7 +455,7 @@
 
     void discoverServices(CachedBluetoothDevice cachedDevice) {
         if (DEBUG) {
-            Log.d(TAG, "connectGattToCheckCompatibility, device: " + cachedDevice.getDevice());
+            Log.d(TAG, "connectGattToCheckCompatibility, device: " + cachedDevice);
         }
         BluetoothGatt gatt = cachedDevice.getDevice().connectGatt(getContext(), false,
                 new BluetoothGattCallback() {
@@ -465,7 +465,7 @@
                         super.onConnectionStateChange(gatt, status, newState);
                         if (DEBUG) {
                             Log.d(TAG, "onConnectionStateChange, status: " + status + ", newState: "
-                                    + newState + ", device: " + cachedDevice.getDevice());
+                                    + newState + ", device: " + cachedDevice);
                         }
                         if (status == GATT_SUCCESS
                                 && newState == BluetoothProfile.STATE_CONNECTED) {
@@ -481,14 +481,14 @@
                         super.onServicesDiscovered(gatt, status);
                         if (DEBUG) {
                             Log.d(TAG, "onServicesDiscovered, status: " + status + ", device: "
-                                    + cachedDevice.getDevice());
+                                    + cachedDevice);
                         }
                         if (status == GATT_SUCCESS) {
                             if (gatt.getService(BluetoothUuid.HEARING_AID.getUuid()) != null
                                     || gatt.getService(BluetoothUuid.HAS.getUuid()) != null) {
                                 if (DEBUG) {
                                     Log.d(TAG, "compatible with Android, device: "
-                                            + cachedDevice.getDevice());
+                                            + cachedDevice);
                                 }
                                 addDevice(cachedDevice);
                             }
diff --git a/src/com/android/settings/accessibility/KeyboardVibrationTogglePreferenceController.java b/src/com/android/settings/accessibility/KeyboardVibrationTogglePreferenceController.java
index 58aa0cc..21800b9 100644
--- a/src/com/android/settings/accessibility/KeyboardVibrationTogglePreferenceController.java
+++ b/src/com/android/settings/accessibility/KeyboardVibrationTogglePreferenceController.java
@@ -22,6 +22,7 @@
 import static com.android.settings.accessibility.AccessibilityUtil.State.ON;
 
 import android.app.settings.SettingsEnums;
+import android.content.ContentResolver;
 import android.content.Context;
 import android.database.ContentObserver;
 import android.net.Uri;
@@ -159,8 +160,11 @@
     }
 
     private boolean updateKeyboardVibrationSetting(boolean enable) {
-        final boolean success = Settings.System.putInt(mContext.getContentResolver(),
-                    KEYBOARD_VIBRATION_ENABLED, enable ? ON : OFF);
+        final ContentResolver contentResolver = mContext.getContentResolver();
+        final boolean success = Settings.System.putInt(contentResolver,
+                KEYBOARD_VIBRATION_ENABLED, enable ? ON : OFF);
+        contentResolver.notifyChange(Settings.System.getUriFor(KEYBOARD_VIBRATION_ENABLED),
+                null /* observer */, ContentResolver.NOTIFY_NO_DELAY);
         if (!success) {
             Log.w(TAG, "Update settings database error!");
         }
diff --git a/src/com/android/settings/accessibility/PreferredShortcuts.java b/src/com/android/settings/accessibility/PreferredShortcuts.java
index e76bc9b..e166f38 100644
--- a/src/com/android/settings/accessibility/PreferredShortcuts.java
+++ b/src/com/android/settings/accessibility/PreferredShortcuts.java
@@ -21,8 +21,10 @@
 import android.content.SharedPreferences;
 import android.os.UserHandle;
 import android.util.ArrayMap;
+import android.view.accessibility.Flags;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
 
 import com.android.internal.accessibility.common.ShortcutConstants;
 import com.android.internal.accessibility.util.ShortcutUtils;
@@ -98,6 +100,11 @@
             @NonNull Context context, @NonNull Set<String> components) {
         final Map<Integer, Set<String>> shortcutTypeToTargets = new ArrayMap<>();
         for (int shortcutType : ShortcutConstants.USER_SHORTCUT_TYPES) {
+            if (!Flags.a11yQsShortcut()
+                    && shortcutType == ShortcutConstants.UserShortcutType.QUICK_SETTINGS) {
+                // Skip saving quick setting as preferred shortcut option when flag is not enabled
+                continue;
+            }
             shortcutTypeToTargets.put(
                     shortcutType,
                     ShortcutUtils.getShortcutTargetsFromSettings(
@@ -138,6 +145,11 @@
         return context.getSharedPreferences(ACCESSIBILITY_PERF, Context.MODE_PRIVATE);
     }
 
+    @VisibleForTesting(otherwise = VisibleForTesting.NONE)
+    static void clearPreferredShortcuts(Context context) {
+        getSharedPreferences(context).edit().clear().apply();
+    }
+
     /**
      * Returns the default shortcut types for the given accessibility feature.
      */
diff --git a/src/com/android/settings/accessibility/ToggleFeaturePreferenceFragment.java b/src/com/android/settings/accessibility/ToggleFeaturePreferenceFragment.java
index e7835f8..ed47007 100644
--- a/src/com/android/settings/accessibility/ToggleFeaturePreferenceFragment.java
+++ b/src/com/android/settings/accessibility/ToggleFeaturePreferenceFragment.java
@@ -179,6 +179,9 @@
         final List<String> shortcutFeatureKeys = new ArrayList<>();
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS);
         shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE);
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            shortcutFeatureKeys.add(Settings.Secure.ACCESSIBILITY_QS_TARGETS);
+        }
         return shortcutFeatureKeys;
     }
 
@@ -711,6 +714,13 @@
                 mComponentName.flattenToString());
 
         final List<CharSequence> list = new ArrayList<>();
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            if (hasShortcutType(shortcutTypes, UserShortcutType.QUICK_SETTINGS)) {
+                final CharSequence qsTitle = context.getText(
+                        R.string.accessibility_feature_shortcut_setting_summary_quick_settings);
+                list.add(qsTitle);
+            }
+        }
         if (hasShortcutType(shortcutTypes, UserShortcutType.SOFTWARE)) {
             list.add(getSoftwareShortcutTypeSummary(context));
         }
@@ -906,6 +916,10 @@
     }
 
     private void showQuickSettingsTooltipIfNeeded() {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            // Don't show Quick Settings tooltip
+            return;
+        }
         final ComponentName tileComponentName = getTileComponentName();
         if (tileComponentName == null) {
             // Returns if no tile service assigned.
diff --git a/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragment.java b/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragment.java
index 985d45d..6ef764e 100644
--- a/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragment.java
+++ b/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragment.java
@@ -33,6 +33,7 @@
 import android.icu.text.MessageFormat;
 import android.net.Uri;
 import android.os.Bundle;
+import android.os.UserHandle;
 import android.provider.DeviceConfig;
 import android.provider.Settings;
 import android.text.TextUtils;
@@ -65,6 +66,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
+import java.util.Set;
 import java.util.StringJoiner;
 
 /**
@@ -357,7 +359,7 @@
         }
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
             if (mTwoFingerTripleTapTypeCheckBox.isChecked()) {
-                value |= UserShortcutType.TWOFINGERTRIPLETAP;
+                value |= UserShortcutType.TWOFINGER_DOUBLETAP;
             }
         }
         return value;
@@ -419,7 +421,7 @@
                 hasShortcutType(value, UserShortcutType.TRIPLETAP));
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
             mTwoFingerTripleTapTypeCheckBox.setChecked(
-                    hasShortcutType(value, UserShortcutType.TWOFINGERTRIPLETAP));
+                    hasShortcutType(value, UserShortcutType.TWOFINGER_DOUBLETAP));
         }
     }
 
@@ -483,6 +485,13 @@
                 MAGNIFICATION_CONTROLLER_NAME);
 
         final List<CharSequence> list = new ArrayList<>();
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            if (hasShortcutType(shortcutTypes, UserShortcutType.QUICK_SETTINGS)) {
+                final CharSequence qsTitle = context.getText(
+                        R.string.accessibility_feature_shortcut_setting_summary_quick_settings);
+                list.add(qsTitle);
+            }
+        }
         if (hasShortcutType(shortcutTypes, UserShortcutType.SOFTWARE)) {
             list.add(getSoftwareShortcutTypeSummary(context));
         }
@@ -497,7 +506,7 @@
             list.add(tripleTapTitle);
         }
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if (hasShortcutType(shortcutTypes, UserShortcutType.TWOFINGERTRIPLETAP)) {
+            if (hasShortcutType(shortcutTypes, UserShortcutType.TWOFINGER_DOUBLETAP)) {
                 final CharSequence twoFingerTripleTapTitle = context.getText(
                         R.string.accessibility_shortcut_two_finger_double_tap_keyword);
                 list.add(twoFingerTripleTapTitle);
@@ -678,15 +687,34 @@
             optInMagnificationValueToSettings(context, UserShortcutType.TRIPLETAP);
         }
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if (((shortcutTypes & UserShortcutType.TWOFINGERTRIPLETAP)
-                    == UserShortcutType.TWOFINGERTRIPLETAP)) {
-                optInMagnificationValueToSettings(context, UserShortcutType.TWOFINGERTRIPLETAP);
+            if (((shortcutTypes & UserShortcutType.TWOFINGER_DOUBLETAP)
+                    == UserShortcutType.TWOFINGER_DOUBLETAP)) {
+                optInMagnificationValueToSettings(context, UserShortcutType.TWOFINGER_DOUBLETAP);
+            }
+        }
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            if (((shortcutTypes & UserShortcutType.QUICK_SETTINGS)
+                    == UserShortcutType.QUICK_SETTINGS)) {
+                optInMagnificationValueToSettings(context, UserShortcutType.QUICK_SETTINGS);
             }
         }
     }
 
-    private static void optInMagnificationValueToSettings(Context context,
-            @UserShortcutType int shortcutType) {
+    private static void optInMagnificationValueToSettings(
+            Context context, @UserShortcutType int shortcutType) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            AccessibilityManager a11yManager = context.getSystemService(AccessibilityManager.class);
+            if (a11yManager != null) {
+                a11yManager.enableShortcutsForTargets(
+                        /* enable= */ true,
+                        shortcutType,
+                        Set.of(MAGNIFICATION_CONTROLLER_NAME),
+                        UserHandle.myUserId()
+                );
+            }
+            return;
+        }
+
         if (shortcutType == UserShortcutType.TRIPLETAP) {
             Settings.Secure.putInt(context.getContentResolver(),
                     Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, ON);
@@ -694,8 +722,9 @@
         }
 
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if (shortcutType == UserShortcutType.TWOFINGERTRIPLETAP) {
-                Settings.Secure.putInt(context.getContentResolver(),
+            if (shortcutType == UserShortcutType.TWOFINGER_DOUBLETAP) {
+                Settings.Secure.putInt(
+                        context.getContentResolver(),
                         Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED,
                         ON);
                 return;
@@ -743,15 +772,34 @@
             optOutMagnificationValueFromSettings(context, UserShortcutType.TRIPLETAP);
         }
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if (((shortcutTypes & UserShortcutType.TWOFINGERTRIPLETAP)
-                    == UserShortcutType.TWOFINGERTRIPLETAP)) {
-                optOutMagnificationValueFromSettings(context, UserShortcutType.TWOFINGERTRIPLETAP);
+            if (((shortcutTypes & UserShortcutType.TWOFINGER_DOUBLETAP)
+                    == UserShortcutType.TWOFINGER_DOUBLETAP)) {
+                optOutMagnificationValueFromSettings(context, UserShortcutType.TWOFINGER_DOUBLETAP);
+            }
+        }
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            if (((shortcutTypes & UserShortcutType.QUICK_SETTINGS)
+                    == UserShortcutType.QUICK_SETTINGS)) {
+                optOutMagnificationValueFromSettings(context, UserShortcutType.QUICK_SETTINGS);
             }
         }
     }
 
     private static void optOutMagnificationValueFromSettings(Context context,
             @UserShortcutType int shortcutType) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            AccessibilityManager a11yManager = context.getSystemService(AccessibilityManager.class);
+            if (a11yManager != null) {
+                a11yManager.enableShortcutsForTargets(
+                        /* enable= */ false,
+                        shortcutType,
+                        Set.of(MAGNIFICATION_CONTROLLER_NAME),
+                        UserHandle.myUserId()
+                );
+            }
+            return;
+        }
+
         if (shortcutType == UserShortcutType.TRIPLETAP) {
             Settings.Secure.putInt(context.getContentResolver(),
                     Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, OFF);
@@ -759,8 +807,9 @@
         }
 
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if (shortcutType == UserShortcutType.TWOFINGERTRIPLETAP) {
-                Settings.Secure.putInt(context.getContentResolver(),
+            if (shortcutType == UserShortcutType.TWOFINGER_DOUBLETAP) {
+                Settings.Secure.putInt(
+                        context.getContentResolver(),
                         Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED,
                         OFF);
                 return;
@@ -803,10 +852,10 @@
             exist |= hasMagnificationValueInSettings(context, UserShortcutType.TRIPLETAP);
         }
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if (((shortcutTypes & UserShortcutType.TWOFINGERTRIPLETAP)
-                    == UserShortcutType.TWOFINGERTRIPLETAP)) {
+            if (((shortcutTypes & UserShortcutType.TWOFINGER_DOUBLETAP)
+                    == UserShortcutType.TWOFINGER_DOUBLETAP)) {
                 exist |= hasMagnificationValueInSettings(context,
-                        UserShortcutType.TWOFINGERTRIPLETAP);
+                        UserShortcutType.TWOFINGER_DOUBLETAP);
             }
         }
         return exist;
@@ -820,7 +869,7 @@
         }
 
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if (shortcutType == UserShortcutType.TWOFINGERTRIPLETAP) {
+            if (shortcutType == UserShortcutType.TWOFINGER_DOUBLETAP) {
                 return Settings.Secure.getInt(context.getContentResolver(),
                         Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED,
                         OFF) == ON;
@@ -857,8 +906,8 @@
             shortcutTypes |= UserShortcutType.TRIPLETAP;
         }
         if (Flags.enableMagnificationMultipleFingerMultipleTapGesture()) {
-            if (hasMagnificationValuesInSettings(context, UserShortcutType.TWOFINGERTRIPLETAP)) {
-                shortcutTypes |= UserShortcutType.TWOFINGERTRIPLETAP;
+            if (hasMagnificationValuesInSettings(context, UserShortcutType.TWOFINGER_DOUBLETAP)) {
+                shortcutTypes |= UserShortcutType.TWOFINGER_DOUBLETAP;
             }
         }
         return shortcutTypes;
diff --git a/src/com/android/settings/accessibility/shortcuts/EditShortcutsPreferenceFragment.java b/src/com/android/settings/accessibility/shortcuts/EditShortcutsPreferenceFragment.java
index aba342a..976fffb 100644
--- a/src/com/android/settings/accessibility/shortcuts/EditShortcutsPreferenceFragment.java
+++ b/src/com/android/settings/accessibility/shortcuts/EditShortcutsPreferenceFragment.java
@@ -21,6 +21,7 @@
 import static android.provider.Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS;
 import static android.provider.Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED;
 import static android.provider.Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED;
+import static android.provider.Settings.Secure.ACCESSIBILITY_QS_TARGETS;
 import static android.provider.Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE;
 
 import static com.android.internal.accessibility.AccessibilityShortcutController.MAGNIFICATION_COMPONENT_NAME;
@@ -98,6 +99,9 @@
     private static final Uri TWO_FINGERS_DOUBLE_TAP_SHORTCUT_SETTING =
             Settings.Secure.getUriFor(ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED);
 
+    private static final Uri QUICK_SETTINGS_SHORTCUT_SETTING =
+            Settings.Secure.getUriFor(ACCESSIBILITY_QS_TARGETS);
+
     @VisibleForTesting
     static final Uri[] SHORTCUT_SETTINGS = {
             VOLUME_KEYS_SHORTCUT_SETTING,
@@ -105,6 +109,7 @@
             BUTTON_SHORTCUT_SETTING,
             TRIPLE_TAP_SHORTCUT_SETTING,
             TWO_FINGERS_DOUBLE_TAP_SHORTCUT_SETTING,
+            QUICK_SETTINGS_SHORTCUT_SETTING,
     };
 
     private Set<String> mShortcutTargets;
@@ -171,7 +176,9 @@
                 } else if (TRIPLE_TAP_SHORTCUT_SETTING.equals(uri)) {
                     refreshPreferenceController(TripleTapShortcutOptionController.class);
                 } else if (TWO_FINGERS_DOUBLE_TAP_SHORTCUT_SETTING.equals(uri)) {
-                    refreshPreferenceController(TwoFingersDoubleTapShortcutOptionController.class);
+                    refreshPreferenceController(TwoFingerDoubleTapShortcutOptionController.class);
+                } else if (QUICK_SETTINGS_SHORTCUT_SETTING.equals(uri)) {
+                    refreshPreferenceController(QuickSettingsShortcutOptionController.class);
                 }
 
                 PreferredShortcuts.updatePreferredShortcutsFromSettings(
diff --git a/src/com/android/settings/accessibility/shortcuts/QuickSettingsShortcutOptionController.java b/src/com/android/settings/accessibility/shortcuts/QuickSettingsShortcutOptionController.java
new file mode 100644
index 0000000..27f6bc9
--- /dev/null
+++ b/src/com/android/settings/accessibility/shortcuts/QuickSettingsShortcutOptionController.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.accessibility.shortcuts;
+
+import static com.android.internal.accessibility.common.ShortcutConstants.AccessibilityFragmentType.INVISIBLE_TOGGLE;
+
+import android.accessibilityservice.AccessibilityServiceInfo;
+import android.content.ComponentName;
+import android.content.Context;
+import android.os.UserHandle;
+import android.service.quicksettings.TileService;
+import android.util.ArraySet;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.Flags;
+
+import androidx.annotation.NonNull;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.internal.accessibility.common.ShortcutConstants;
+import com.android.internal.accessibility.util.AccessibilityUtils;
+import com.android.settings.R;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A controller handles displaying the quick settings shortcut option preference and
+ * configuring the shortcut.
+ */
+public class QuickSettingsShortcutOptionController extends ShortcutOptionPreferenceController {
+    public QuickSettingsShortcutOptionController(
+            @NonNull Context context, @NonNull String preferenceKey) {
+        super(context, preferenceKey);
+    }
+
+    @ShortcutConstants.UserShortcutType
+    @Override
+    protected int getShortcutType() {
+        return ShortcutConstants.UserShortcutType.QUICK_SETTINGS;
+    }
+
+    @Override
+    public void displayPreference(@NonNull PreferenceScreen screen) {
+        super.displayPreference(screen);
+        final Preference preference = screen.findPreference(getPreferenceKey());
+        if (preference instanceof ShortcutOptionPreference shortcutOptionPreference) {
+            shortcutOptionPreference.setTitle(
+                    R.string.accessibility_shortcut_edit_dialog_title_quick_settings);
+            shortcutOptionPreference.setSummary(
+                    R.string.accessibility_shortcut_edit_dialog_summary_quick_settings);
+            shortcutOptionPreference.setIntroImageResId(
+                    R.drawable.a11y_shortcut_type_quick_settings);
+        }
+    }
+
+    @Override
+    protected boolean isShortcutAvailable() {
+        return Flags.a11yQsShortcut()
+                && TileService.isQuickSettingsSupported()
+                && allTargetsHasQsTile()
+                && allTargetsHasValidQsTileUseCase();
+    }
+
+    private boolean allTargetsHasQsTile() {
+        AccessibilityManager accessibilityManager = mContext.getSystemService(
+                AccessibilityManager.class);
+        if (accessibilityManager == null) {
+            return false;
+        }
+
+        Map<ComponentName, ComponentName> a11yFeatureToTileMap =
+                accessibilityManager.getA11yFeatureToTileMap(UserHandle.myUserId());
+        if (a11yFeatureToTileMap.isEmpty()) {
+            return false;
+        }
+        for (String target : getShortcutTargets()) {
+            ComponentName targetComponentName = ComponentName.unflattenFromString(target);
+            if (!a11yFeatureToTileMap.containsKey(targetComponentName)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Returns true if all targets have valid QS Tile shortcut use case.
+     *
+     * <p>
+     * Note: We don't want to promote the qs option in the edit shortcuts screen for
+     * a standard AccessibilityService, because the Tile is provided by the owner of the
+     * AccessibilityService, and they don't have control to enable the A11yService themselves
+     * which makes the TileService not acting as the other a11y shortcut like FAB where the user
+     * can turn on/off the feature by toggling the shortcut.
+     *
+     * A standard AccessibilityService normally won't create a TileService because the
+     * above mentioned reason. In any case where the standard AccessibilityService provides a tile,
+     * we'll hide it from the Setting's UI.
+     * </p>
+     */
+    private boolean allTargetsHasValidQsTileUseCase() {
+        AccessibilityManager accessibilityManager = mContext.getSystemService(
+                AccessibilityManager.class);
+        if (accessibilityManager == null) {
+            return false;
+        }
+
+        List<AccessibilityServiceInfo> installedServices =
+                accessibilityManager.getInstalledAccessibilityServiceList();
+        final Set<String> standardA11yServices = new ArraySet<>();
+        for (AccessibilityServiceInfo serviceInfo : installedServices) {
+            if (AccessibilityUtils.getAccessibilityServiceFragmentType(serviceInfo)
+                    != INVISIBLE_TOGGLE) {
+                standardA11yServices.add(serviceInfo.getComponentName().flattenToString());
+            }
+        }
+
+        for (String target : getShortcutTargets()) {
+            if (standardA11yServices.contains(target)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/com/android/settings/accessibility/shortcuts/ShortcutOptionPreferenceController.java b/src/com/android/settings/accessibility/shortcuts/ShortcutOptionPreferenceController.java
index 4d35554..defb256 100644
--- a/src/com/android/settings/accessibility/shortcuts/ShortcutOptionPreferenceController.java
+++ b/src/com/android/settings/accessibility/shortcuts/ShortcutOptionPreferenceController.java
@@ -18,6 +18,8 @@
 
 import android.content.Context;
 import android.os.UserHandle;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.Flags;
 
 import androidx.annotation.NonNull;
 import androidx.preference.Preference;
@@ -116,6 +118,16 @@
         Set<String> shortcutTargets = getShortcutTargets();
         @ShortcutConstants.UserShortcutType int shortcutType = getShortcutType();
 
+        if (Flags.a11yQsShortcut()) {
+            AccessibilityManager a11yManager = mContext.getSystemService(
+                    AccessibilityManager.class);
+            if (a11yManager != null) {
+                a11yManager.enableShortcutsForTargets(enable, shortcutType, shortcutTargets,
+                        UserHandle.myUserId());
+            }
+            return;
+        }
+
         if (enable) {
             for (String target : shortcutTargets) {
                 ShortcutUtils.optInValueToSettings(mContext, shortcutType, target);
diff --git a/src/com/android/settings/accessibility/shortcuts/SoftwareShortcutOptionPreferenceController.java b/src/com/android/settings/accessibility/shortcuts/SoftwareShortcutOptionPreferenceController.java
index 24098c8..861bebd 100644
--- a/src/com/android/settings/accessibility/shortcuts/SoftwareShortcutOptionPreferenceController.java
+++ b/src/com/android/settings/accessibility/shortcuts/SoftwareShortcutOptionPreferenceController.java
@@ -21,6 +21,7 @@
 import android.content.Context;
 import android.provider.Settings;
 import android.view.View;
+import android.view.accessibility.Flags;
 
 import com.android.internal.accessibility.common.ShortcutConstants;
 import com.android.settings.R;
@@ -65,6 +66,9 @@
     @Override
     protected void enableShortcutForTargets(boolean enable) {
         super.enableShortcutForTargets(enable);
+        if (Flags.a11yQsShortcut()) {
+            return;
+        }
 
         if (enable) {
             // Update the A11y FAB size to large when the Magnification shortcut is enabled
diff --git a/src/com/android/settings/accessibility/shortcuts/TripleTapShortcutOptionController.java b/src/com/android/settings/accessibility/shortcuts/TripleTapShortcutOptionController.java
index 0eb1ee5..e43aeb2 100644
--- a/src/com/android/settings/accessibility/shortcuts/TripleTapShortcutOptionController.java
+++ b/src/com/android/settings/accessibility/shortcuts/TripleTapShortcutOptionController.java
@@ -21,6 +21,7 @@
 import android.content.Context;
 import android.icu.text.MessageFormat;
 import android.provider.Settings;
+import android.view.accessibility.Flags;
 
 import androidx.preference.Preference;
 import androidx.preference.PreferenceScreen;
@@ -105,6 +106,11 @@
 
     @Override
     protected void enableShortcutForTargets(boolean enable) {
+        if (Flags.a11yQsShortcut()) {
+            super.enableShortcutForTargets(enable);
+            return;
+        }
+
         Settings.Secure.putInt(
                 mContext.getContentResolver(),
                 Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
diff --git a/src/com/android/settings/accessibility/shortcuts/TwoFingersDoubleTapShortcutOptionController.java b/src/com/android/settings/accessibility/shortcuts/TwoFingerDoubleTapShortcutOptionController.java
similarity index 90%
rename from src/com/android/settings/accessibility/shortcuts/TwoFingersDoubleTapShortcutOptionController.java
rename to src/com/android/settings/accessibility/shortcuts/TwoFingerDoubleTapShortcutOptionController.java
index 64ed7bd..83ba6e4 100644
--- a/src/com/android/settings/accessibility/shortcuts/TwoFingersDoubleTapShortcutOptionController.java
+++ b/src/com/android/settings/accessibility/shortcuts/TwoFingerDoubleTapShortcutOptionController.java
@@ -36,17 +36,17 @@
  * A controller handles displaying the two fingers double tap shortcut option preference and
  * configuring the shortcut.
  */
-public class TwoFingersDoubleTapShortcutOptionController
+public class TwoFingerDoubleTapShortcutOptionController
         extends ShortcutOptionPreferenceController {
 
-    public TwoFingersDoubleTapShortcutOptionController(Context context, String preferenceKey) {
+    public TwoFingerDoubleTapShortcutOptionController(Context context, String preferenceKey) {
         super(context, preferenceKey);
     }
 
     @ShortcutConstants.UserShortcutType
     @Override
     protected int getShortcutType() {
-        return ShortcutConstants.UserShortcutType.TRIPLETAP;
+        return ShortcutConstants.UserShortcutType.TWOFINGER_DOUBLETAP;
     }
 
     @Override
@@ -90,6 +90,10 @@
 
     @Override
     protected void enableShortcutForTargets(boolean enable) {
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            super.enableShortcutForTargets(enable);
+            return;
+        }
         Settings.Secure.putInt(
                 mContext.getContentResolver(),
                 Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED,
diff --git a/src/com/android/settings/accessibility/shortcuts/VolumeKeysShortcutOptionController.java b/src/com/android/settings/accessibility/shortcuts/VolumeKeysShortcutOptionController.java
index 9083e7c..e8e261c 100644
--- a/src/com/android/settings/accessibility/shortcuts/VolumeKeysShortcutOptionController.java
+++ b/src/com/android/settings/accessibility/shortcuts/VolumeKeysShortcutOptionController.java
@@ -17,6 +17,7 @@
 package com.android.settings.accessibility.shortcuts;
 
 import android.content.Context;
+import android.view.accessibility.Flags;
 
 import androidx.preference.Preference;
 import androidx.preference.PreferenceScreen;
@@ -64,6 +65,10 @@
     @Override
     protected void enableShortcutForTargets(boolean enable) {
         super.enableShortcutForTargets(enable);
+        if (Flags.a11yQsShortcut()) {
+            return;
+        }
+
         if (enable) {
             AccessibilityUtil.skipVolumeShortcutDialogTimeoutRestriction(mContext);
         }
diff --git a/src/com/android/settings/applications/AppStoreUtil.java b/src/com/android/settings/applications/AppStoreUtil.java
index b73b14a..636669c 100644
--- a/src/com/android/settings/applications/AppStoreUtil.java
+++ b/src/com/android/settings/applications/AppStoreUtil.java
@@ -83,6 +83,7 @@
     }
 
     /** Convenience method that looks up the installerPackageName for you. */
+    @Nullable
     public static Intent getAppStoreLink(Context context, String packageName) {
       String installerPackageName = getInstallerPackageName(context, packageName);
       return getAppStoreLink(context, installerPackageName, packageName);
diff --git a/src/com/android/settings/applications/credentials/DefaultCombinedPickerPrivate.java b/src/com/android/settings/applications/credentials/DefaultCombinedPickerPrivate.java
index 52adc4d..f1aaa53 100644
--- a/src/com/android/settings/applications/credentials/DefaultCombinedPickerPrivate.java
+++ b/src/com/android/settings/applications/credentials/DefaultCombinedPickerPrivate.java
@@ -32,6 +32,8 @@
 
     /** Returns whether the user is handled by this fragment. */
     public static boolean isUserHandledByFragment(UserManager userManager) {
-        return android.os.Flags.allowPrivateProfile() && userManager.isPrivateProfile();
+        return android.os.Flags.allowPrivateProfile()
+                && android.multiuser.Flags.enablePrivateSpaceFeatures()
+                && userManager.isPrivateProfile();
     }
 }
diff --git a/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesDetails.java b/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesDetails.java
index faa1b51..81e8439 100644
--- a/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesDetails.java
+++ b/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesDetails.java
@@ -384,20 +384,21 @@
     }
 
     private void handleInstallBannerClick() {
-        if (mInstallAppIntent == null) {
-            logEvent(
-                    DevicePolicyEnums.CROSS_PROFILE_SETTINGS_PAGE_INSTALL_BANNER_NO_INTENT_CLICKED);
-            return;
-        }
-        if (!mInstalledInWork) {
+        if (mInstallAppIntent != null
+                && !mInstalledInWork
+                && isInstallableInProfile(mInstallAppIntent, mWorkProfile)) {
             logEvent(DevicePolicyEnums.CROSS_PROFILE_SETTINGS_PAGE_INSTALL_BANNER_CLICKED);
             mContext.startActivityAsUser(mInstallAppIntent, mWorkProfile);
             return;
         }
-        if (!mInstalledInPersonal) {
+        if (mInstallAppIntent != null
+                && !mInstalledInPersonal
+                && isInstallableInProfile(mInstallAppIntent, mPersonalProfile)) {
             logEvent(DevicePolicyEnums.CROSS_PROFILE_SETTINGS_PAGE_INSTALL_BANNER_CLICKED);
             mContext.startActivityAsUser(mInstallAppIntent, mPersonalProfile);
+            return;
         }
+        logEvent(DevicePolicyEnums.CROSS_PROFILE_SETTINGS_PAGE_INSTALL_BANNER_NO_INTENT_CLICKED);
     }
 
     /**
@@ -447,7 +448,8 @@
                                     R.string.interact_across_profiles_install_personal_app_title,
                                     mAppLabel),
                             mAppLabel));
-            if (mInstallAppIntent != null) {
+            if (mInstallAppIntent != null
+                    && isInstallableInProfile(mInstallAppIntent, mPersonalProfile)) {
                 mInstallBanner.setSummary(
                         R.string.interact_across_profiles_install_app_summary);
             }
@@ -461,7 +463,8 @@
                                     R.string.interact_across_profiles_install_work_app_title,
                                     mAppLabel),
                             mAppLabel));
-            if (mInstallAppIntent != null) {
+            if (mInstallAppIntent != null
+                    && isInstallableInProfile(mInstallAppIntent, mWorkProfile)) {
                 mInstallBanner.setSummary(
                         R.string.interact_across_profiles_install_app_summary);
             }
@@ -488,6 +491,12 @@
         return info != null;
     }
 
+    private boolean isInstallableInProfile(Intent intent, UserHandle profile) {
+        return !mContext.getPackageManager()
+                .queryIntentActivitiesAsUser(intent, /* flags= */ 0, profile)
+                .isEmpty();
+    }
+
     private void refreshUiForConfigurableApps() {
         mInstallBanner.setVisible(false);
         mSwitchPref.setEnabled(true);
diff --git a/src/com/android/settings/backup/SettingsBackupHelper.java b/src/com/android/settings/backup/SettingsBackupHelper.java
index 0861af2..556ab72 100644
--- a/src/com/android/settings/backup/SettingsBackupHelper.java
+++ b/src/com/android/settings/backup/SettingsBackupHelper.java
@@ -16,10 +16,8 @@
 
 package com.android.settings.backup;
 
-import static com.android.settings.localepicker.LocaleNotificationDataManager.LOCALE_NOTIFICATION;
 
 import android.app.backup.BackupAgentHelper;
-import android.app.backup.SharedPreferencesBackupHelper;
 
 import com.android.settings.flags.Flags;
 import com.android.settings.onboarding.OnboardingFeatureProvider;
@@ -29,15 +27,12 @@
 
 /** Backup agent for Settings APK */
 public class SettingsBackupHelper extends BackupAgentHelper {
-    private static final String PREF_LOCALE_NOTIFICATION = "localeNotificationSharedPref";
     public static final String SOUND_BACKUP_HELPER = "SoundSettingsBackup";
 
     @Override
     public void onCreate() {
         super.onCreate();
         BackupRestoreStorageManager.getInstance(this).addBackupAgentHelpers(this);
-        addHelper(PREF_LOCALE_NOTIFICATION,
-                new SharedPreferencesBackupHelper(this, LOCALE_NOTIFICATION));
         if (Flags.enableSoundBackup()) {
             OnboardingFeatureProvider onboardingFeatureProvider =
                     FeatureFactory.getFeatureFactory().getOnboardingFeatureProvider();
diff --git a/src/com/android/settings/bluetooth/BluetoothDetailsHearingAidsPresetsController.java b/src/com/android/settings/bluetooth/BluetoothDetailsHearingAidsPresetsController.java
new file mode 100644
index 0000000..43721f4
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothDetailsHearingAidsPresetsController.java
@@ -0,0 +1,308 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.bluetooth;
+
+import static com.android.settings.bluetooth.BluetoothDetailsHearingDeviceController.KEY_HEARING_DEVICE_GROUP;
+import static com.android.settings.bluetooth.BluetoothDetailsHearingDeviceController.ORDER_HEARING_AIDS_PRESETS;
+
+import android.bluetooth.BluetoothCsipSetCoordinator;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothHapClient;
+import android.bluetooth.BluetoothHapPresetInfo;
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Log;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.preference.ListPreference;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceCategory;
+import androidx.preference.PreferenceFragmentCompat;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HapClientProfile;
+import com.android.settingslib.bluetooth.LocalBluetoothManager;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+import com.android.settingslib.core.lifecycle.events.OnPause;
+import com.android.settingslib.core.lifecycle.events.OnResume;
+import com.android.settingslib.utils.ThreadUtils;
+
+import java.util.List;
+
+/**
+ * The controller of the hearing aid presets.
+ */
+public class BluetoothDetailsHearingAidsPresetsController extends
+        BluetoothDetailsController implements Preference.OnPreferenceChangeListener,
+        BluetoothHapClient.Callback, OnResume, OnPause {
+
+    private static final boolean DEBUG = true;
+    private static final String TAG = "BluetoothDetailsHearingAidsPresetsController";
+    static final String KEY_HEARING_AIDS_PRESETS = "hearing_aids_presets";
+
+    private final HapClientProfile mHapClientProfile;
+    @Nullable
+    private ListPreference mPreference;
+
+    public BluetoothDetailsHearingAidsPresetsController(@NonNull Context context,
+            @NonNull PreferenceFragmentCompat fragment,
+            @NonNull LocalBluetoothManager manager,
+            @NonNull CachedBluetoothDevice device,
+            @NonNull Lifecycle lifecycle) {
+        super(context, fragment, device, lifecycle);
+        mHapClientProfile = manager.getProfileManager().getHapClientProfile();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (mHapClientProfile != null) {
+            mHapClientProfile.registerCallback(ThreadUtils.getBackgroundExecutor(), this);
+        }
+    }
+
+    @Override
+    public void onPause() {
+        if (mHapClientProfile != null) {
+            mHapClientProfile.unregisterCallback(this);
+        }
+        super.onPause();
+    }
+
+    @Override
+    public boolean onPreferenceChange(@NonNull Preference preference, @Nullable Object newValue) {
+        if (TextUtils.equals(preference.getKey(), getPreferenceKey())) {
+            if (newValue instanceof final String value
+                    && preference instanceof final ListPreference listPreference) {
+                final int index = listPreference.findIndexOfValue(value);
+                final String presetName = listPreference.getEntries()[index].toString();
+                final int presetIndex = Integer.parseInt(
+                        listPreference.getEntryValues()[index].toString());
+                listPreference.setSummary(presetName);
+                boolean supportSynchronizedPresets = mHapClientProfile.supportsSynchronizedPresets(
+                        mCachedDevice.getDevice());
+                int hapGroupId = mHapClientProfile.getHapGroup(mCachedDevice.getDevice());
+                if (supportSynchronizedPresets
+                        && hapGroupId != BluetoothCsipSetCoordinator.GROUP_ID_INVALID) {
+                    if (DEBUG) {
+                        Log.d(TAG, "onPreferenceChange, selectPresetForGroup "
+                                + ", presetName: " + presetName
+                                + ", presetIndex: " + presetIndex
+                                + ", hapGroupId: "  + hapGroupId
+                                + ", device: " + mCachedDevice.getAddress());
+                    }
+                    mHapClientProfile.selectPresetForGroup(hapGroupId, presetIndex);
+                } else {
+                    if (DEBUG) {
+                        Log.d(TAG, "onPreferenceChange, selectPreset "
+                                + ", presetName: " + presetName
+                                + ", presetIndex: " + presetIndex
+                                + ", device: " + mCachedDevice.getAddress());
+                    }
+                    mHapClientProfile.selectPreset(mCachedDevice.getDevice(), presetIndex);
+                    final CachedBluetoothDevice subDevice = mCachedDevice.getSubDevice();
+                    if (subDevice != null) {
+                        if (DEBUG) {
+                            Log.d(TAG, "onPreferenceChange, selectPreset for subDevice"
+                                    + ", device: " + subDevice.getAddress());
+                        }
+                        mHapClientProfile.selectPreset(subDevice.getDevice(), presetIndex);
+                    }
+                    for (final CachedBluetoothDevice memberDevice :
+                            mCachedDevice.getMemberDevice()) {
+                        if (DEBUG) {
+                            Log.d(TAG, "onPreferenceChange, selectPreset for memberDevice"
+                                    + ", device: " + memberDevice.getAddress());
+                        }
+                        mHapClientProfile.selectPreset(memberDevice.getDevice(), presetIndex);
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Nullable
+    @Override
+    public String getPreferenceKey() {
+        return KEY_HEARING_AIDS_PRESETS;
+    }
+
+    @Override
+    protected void init(PreferenceScreen screen) {
+        PreferenceCategory deviceControls = screen.findPreference(KEY_HEARING_DEVICE_GROUP);
+        if (deviceControls != null) {
+            mPreference = createPresetPreference(deviceControls.getContext());
+            deviceControls.addPreference(mPreference);
+        }
+    }
+
+    @Override
+    protected void refresh() {
+        if (!isAvailable() || mPreference == null) {
+            return;
+        }
+        mPreference.setEnabled(mCachedDevice.isConnectedHapClientDevice());
+
+        loadAllPresetInfo();
+        if (mPreference.getEntries().length == 0) {
+            mPreference.setEnabled(false);
+        } else {
+            int activePresetIndex = mHapClientProfile.getActivePresetIndex(
+                    mCachedDevice.getDevice());
+            if (activePresetIndex != BluetoothHapClient.PRESET_INDEX_UNAVAILABLE) {
+                mPreference.setValue(Integer.toString(activePresetIndex));
+                mPreference.setSummary(mPreference.getEntry());
+            } else {
+                mPreference.setSummary(null);
+            }
+        }
+    }
+
+    @Override
+    public boolean isAvailable() {
+        if (mHapClientProfile == null) {
+            return false;
+        }
+        return mCachedDevice.getProfiles().stream().anyMatch(
+                profile -> profile instanceof HapClientProfile);
+    }
+
+    @Override
+    public void onPresetSelected(@NonNull BluetoothDevice device, int presetIndex, int reason) {
+        if (device.equals(mCachedDevice.getDevice())) {
+            if (DEBUG) {
+                Log.d(TAG, "onPresetSelected, device: " + device.getAddress()
+                        + ", presetIndex: " + presetIndex + ", reason: " + reason);
+            }
+            mContext.getMainExecutor().execute(this::refresh);
+        }
+    }
+
+    @Override
+    public void onPresetSelectionFailed(@NonNull BluetoothDevice device, int reason) {
+        if (device.equals(mCachedDevice.getDevice())) {
+            if (DEBUG) {
+                Log.d(TAG,
+                        "onPresetSelectionFailed, device: " + device.getAddress()
+                                + ", reason: " + reason);
+            }
+            mContext.getMainExecutor().execute(() -> {
+                refresh();
+                showErrorToast();
+            });
+        }
+    }
+
+    @Override
+    public void onPresetSelectionForGroupFailed(int hapGroupId, int reason) {
+        if (hapGroupId == mHapClientProfile.getHapGroup(mCachedDevice.getDevice())) {
+            if (DEBUG) {
+                Log.d(TAG, "onPresetSelectionForGroupFailed, group: " + hapGroupId
+                        + ", reason: " + reason);
+            }
+            mContext.getMainExecutor().execute(() -> {
+                refresh();
+                showErrorToast();
+            });
+        }
+    }
+
+    @Override
+    public void onPresetInfoChanged(@NonNull BluetoothDevice device,
+            @NonNull List<BluetoothHapPresetInfo> presetInfoList, int reason) {
+        if (device.equals(mCachedDevice.getDevice())) {
+            if (DEBUG) {
+                Log.d(TAG, "onPresetInfoChanged, device: " + device.getAddress()
+                        + ", reason: " + reason
+                        + ", infoList: " + presetInfoList);
+            }
+            mContext.getMainExecutor().execute(this::refresh);
+        }
+    }
+
+    @Override
+    public void onSetPresetNameFailed(@NonNull BluetoothDevice device, int reason) {
+        if (device.equals(mCachedDevice.getDevice())) {
+            if (DEBUG) {
+                Log.d(TAG,
+                        "onSetPresetNameFailed, device: " + device.getAddress()
+                                + ", reason: " + reason);
+            }
+            mContext.getMainExecutor().execute(() -> {
+                refresh();
+                showErrorToast();
+            });
+        }
+    }
+
+    @Override
+    public void onSetPresetNameForGroupFailed(int hapGroupId, int reason) {
+        if (hapGroupId == mHapClientProfile.getHapGroup(mCachedDevice.getDevice())) {
+            if (DEBUG) {
+                Log.d(TAG, "onSetPresetNameForGroupFailed, group: " + hapGroupId
+                        + ", reason: " + reason);
+            }
+            mContext.getMainExecutor().execute(() -> {
+                refresh();
+                showErrorToast();
+            });
+        }
+    }
+
+    private ListPreference createPresetPreference(Context context) {
+        ListPreference preference = new ListPreference(context);
+        preference.setKey(KEY_HEARING_AIDS_PRESETS);
+        preference.setOrder(ORDER_HEARING_AIDS_PRESETS);
+        preference.setTitle(context.getString(R.string.bluetooth_hearing_aids_presets));
+        preference.setOnPreferenceChangeListener(this);
+        return preference;
+    }
+
+    private void loadAllPresetInfo() {
+        if (mPreference == null) {
+            return;
+        }
+        List<BluetoothHapPresetInfo> infoList = mHapClientProfile.getAllPresetInfo(
+                mCachedDevice.getDevice());
+        CharSequence[] presetNames = new CharSequence[infoList.size()];
+        CharSequence[] presetIndexes = new CharSequence[infoList.size()];
+        for (int i = 0; i < infoList.size(); i++) {
+            presetNames[i] = infoList.get(i).getName();
+            presetIndexes[i] = Integer.toString(infoList.get(i).getIndex());
+        }
+        mPreference.setEntries(presetNames);
+        mPreference.setEntryValues(presetIndexes);
+    }
+
+    @VisibleForTesting
+    @Nullable
+    ListPreference getPreference() {
+        return mPreference;
+    }
+
+    void showErrorToast() {
+        Toast.makeText(mContext, R.string.bluetooth_hearing_aids_presets_error,
+                Toast.LENGTH_SHORT).show();
+    }
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceController.java b/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceController.java
new file mode 100644
index 0000000..3703b71
--- /dev/null
+++ b/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceController.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.bluetooth;
+
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+import androidx.preference.PreferenceFragmentCompat;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.accessibility.Flags;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.LocalBluetoothManager;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The controller of the hearing device controls.
+ *
+ * <p><b>Note:</b> It is responsible for creating the sub-controllers inside this preference
+ * category controller.
+ */
+public class BluetoothDetailsHearingDeviceController extends BluetoothDetailsController {
+
+    public static final int ORDER_HEARING_DEVICE_SETTINGS = 1;
+    public static final int ORDER_HEARING_AIDS_PRESETS = 2;
+    static final String KEY_HEARING_DEVICE_GROUP = "hearing_device_group";
+
+    private final List<BluetoothDetailsController> mControllers = new ArrayList<>();
+    private Lifecycle mLifecycle;
+    private LocalBluetoothManager mManager;
+
+    public BluetoothDetailsHearingDeviceController(@NonNull Context context,
+            @NonNull PreferenceFragmentCompat fragment,
+            @NonNull LocalBluetoothManager manager,
+            @NonNull CachedBluetoothDevice device,
+            @NonNull Lifecycle lifecycle) {
+        super(context, fragment, device, lifecycle);
+        mManager = manager;
+        mLifecycle = lifecycle;
+    }
+
+    @VisibleForTesting
+    void setSubControllers(
+            BluetoothDetailsHearingDeviceSettingsController hearingDeviceSettingsController,
+            BluetoothDetailsHearingAidsPresetsController presetsController) {
+        mControllers.clear();
+        mControllers.add(hearingDeviceSettingsController);
+        mControllers.add(presetsController);
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return mControllers.stream().anyMatch(BluetoothDetailsController::isAvailable);
+    }
+
+    @Override
+    @NonNull
+    public String getPreferenceKey() {
+        return KEY_HEARING_DEVICE_GROUP;
+    }
+
+    @Override
+    protected void init(PreferenceScreen screen) {
+
+    }
+
+    @Override
+    protected void refresh() {
+
+    }
+
+    /**
+     * Initiates the sub controllers controlled by this group controller.
+     *
+     * <p><b>Note:</b> The caller must call this method when creating this class.
+     *
+     * @param isLaunchFromHearingDevicePage a boolean that determines if the caller is launch from
+     *                                      hearing device page
+     */
+    void initSubControllers(boolean isLaunchFromHearingDevicePage) {
+        mControllers.clear();
+        // Don't need to show the entrance to hearing device page when launched from the same page
+        if (!isLaunchFromHearingDevicePage) {
+            mControllers.add(new BluetoothDetailsHearingDeviceSettingsController(mContext,
+                    mFragment, mCachedDevice, mLifecycle));
+        }
+        if (Flags.enableHearingAidPresetControl()) {
+            mControllers.add(new BluetoothDetailsHearingAidsPresetsController(mContext, mFragment,
+                    mManager, mCachedDevice, mLifecycle));
+        }
+    }
+
+    @NonNull
+    public List<BluetoothDetailsController> getSubControllers() {
+        return mControllers;
+    }
+}
diff --git a/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControlsController.java b/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceSettingsController.java
similarity index 71%
rename from src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControlsController.java
rename to src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceSettingsController.java
index 162abc7..7e5f3b1 100644
--- a/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControlsController.java
+++ b/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceSettingsController.java
@@ -16,6 +16,9 @@
 
 package com.android.settings.bluetooth;
 
+import static com.android.settings.bluetooth.BluetoothDetailsHearingDeviceController.KEY_HEARING_DEVICE_GROUP;
+import static com.android.settings.bluetooth.BluetoothDetailsHearingDeviceController.ORDER_HEARING_DEVICE_SETTINGS;
+
 import android.content.Context;
 import android.text.TextUtils;
 
@@ -36,15 +39,13 @@
 /**
  * The controller of the hearing device settings to launch Hearing device page.
  */
-public class BluetoothDetailsHearingDeviceControlsController extends BluetoothDetailsController
+public class BluetoothDetailsHearingDeviceSettingsController extends BluetoothDetailsController
         implements Preference.OnPreferenceClickListener {
 
     @VisibleForTesting
-    static final String KEY_DEVICE_CONTROLS_GENERAL_GROUP = "device_controls_general";
-    @VisibleForTesting
-    static final String KEY_HEARING_DEVICE_CONTROLS = "hearing_device_controls";
+    static final String KEY_HEARING_DEVICE_SETTINGS = "hearing_device_settings";
 
-    public BluetoothDetailsHearingDeviceControlsController(Context context,
+    public BluetoothDetailsHearingDeviceSettingsController(Context context,
             PreferenceFragmentCompat fragment, CachedBluetoothDevice device, Lifecycle lifecycle) {
         super(context, fragment, device, lifecycle);
         lifecycle.addObserver(this);
@@ -57,37 +58,40 @@
 
     @Override
     protected void init(PreferenceScreen screen) {
-        if (!mCachedDevice.isHearingAidDevice()) {
+        if (!isAvailable()) {
             return;
         }
-
-        final PreferenceCategory prefCategory = screen.findPreference(getPreferenceKey());
-        final Preference pref = createHearingDeviceControlsPreference(prefCategory.getContext());
-        prefCategory.addPreference(pref);
+        final PreferenceCategory group = screen.findPreference(KEY_HEARING_DEVICE_GROUP);
+        final Preference pref = createHearingDeviceSettingsPreference(group.getContext());
+        group.addPreference(pref);
     }
 
     @Override
-    protected void refresh() {}
+    protected void refresh() {
+
+    }
 
     @Override
     public String getPreferenceKey() {
-        return KEY_DEVICE_CONTROLS_GENERAL_GROUP;
+        return KEY_HEARING_DEVICE_SETTINGS;
     }
 
     @Override
     public boolean onPreferenceClick(Preference preference) {
-        if (TextUtils.equals(preference.getKey(), KEY_HEARING_DEVICE_CONTROLS)) {
+        if (TextUtils.equals(preference.getKey(), KEY_HEARING_DEVICE_SETTINGS)) {
             launchAccessibilityHearingDeviceSettings();
             return true;
         }
         return false;
     }
 
-    private Preference createHearingDeviceControlsPreference(Context context) {
+    private Preference createHearingDeviceSettingsPreference(Context context) {
         final ArrowPreference preference = new ArrowPreference(context);
-        preference.setKey(KEY_HEARING_DEVICE_CONTROLS);
-        preference.setTitle(context.getString(R.string.bluetooth_device_controls_title));
-        preference.setSummary(context.getString(R.string.bluetooth_device_controls_summary));
+        preference.setKey(KEY_HEARING_DEVICE_SETTINGS);
+        preference.setOrder(ORDER_HEARING_DEVICE_SETTINGS);
+        preference.setTitle(context.getString(R.string.bluetooth_hearing_device_settings_title));
+        preference.setSummary(
+                context.getString(R.string.bluetooth_hearing_device_settings_summary));
         preference.setOnPreferenceClickListener(this);
 
         return preference;
diff --git a/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragment.java b/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragment.java
index 9c68c9c..87b2c6b 100644
--- a/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragment.java
+++ b/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragment.java
@@ -326,16 +326,16 @@
                     lifecycle));
             controllers.add(new BluetoothDetailsPairOtherController(context, this, mCachedDevice,
                     lifecycle));
-            // Don't need to show hearing device again when launched from the same page.
-            if (!isLaunchFromHearingDevicePage()) {
-                controllers.add(new BluetoothDetailsHearingDeviceControlsController(context, this,
-                        mCachedDevice, lifecycle));
-            }
-            controllers.add(new BluetoothDetailsDataSyncController(context, this,
-                    mCachedDevice, lifecycle));
-            controllers.add(
-                    new BluetoothDetailsExtraOptionsController(
-                            context, this, mCachedDevice, lifecycle));
+            controllers.add(new BluetoothDetailsDataSyncController(context, this, mCachedDevice,
+                    lifecycle));
+            controllers.add(new BluetoothDetailsExtraOptionsController(context, this, mCachedDevice,
+                    lifecycle));
+            BluetoothDetailsHearingDeviceController hearingDeviceController =
+                    new BluetoothDetailsHearingDeviceController(context, this, mManager,
+                            mCachedDevice, lifecycle);
+            controllers.add(hearingDeviceController);
+            hearingDeviceController.initSubControllers(isLaunchFromHearingDevicePage());
+            controllers.addAll(hearingDeviceController.getSubControllers());
         }
         return controllers;
     }
diff --git a/src/com/android/settings/connecteddevice/threadnetwork/ThreadNetworkPreferenceController.kt b/src/com/android/settings/connecteddevice/threadnetwork/ThreadNetworkPreferenceController.kt
index f5c0a87..1c01750 100644
--- a/src/com/android/settings/connecteddevice/threadnetwork/ThreadNetworkPreferenceController.kt
+++ b/src/com/android/settings/connecteddevice/threadnetwork/ThreadNetworkPreferenceController.kt
@@ -34,9 +34,9 @@
 import androidx.lifecycle.LifecycleOwner
 import androidx.preference.Preference
 import androidx.preference.PreferenceScreen
-import com.android.net.thread.platform.flags.Flags
 import com.android.settings.R
 import com.android.settings.core.TogglePreferenceController
+import com.android.settings.flags.Flags
 import java.util.concurrent.Executor
 
 /** Controller for the "Thread" toggle in "Connected devices > Connection preferences".  */
@@ -110,7 +110,7 @@
     }
 
     override fun getAvailabilityStatus(): Int {
-        return if (!Flags.threadEnabledPlatform()) {
+        return if (!Flags.threadSettingsEnabled()) {
             CONDITIONALLY_UNAVAILABLE
         } else if (!isThreadSupportedOnDevice) {
             UNSUPPORTED_ON_DEVICE
diff --git a/src/com/android/settings/dashboard/profileselector/ProfileSelectFragment.java b/src/com/android/settings/dashboard/profileselector/ProfileSelectFragment.java
index e8f407b..494ef95 100644
--- a/src/com/android/settings/dashboard/profileselector/ProfileSelectFragment.java
+++ b/src/com/android/settings/dashboard/profileselector/ProfileSelectFragment.java
@@ -233,7 +233,12 @@
                 return ((ViewPagerAdapter) mViewPager.getAdapter())
                         .getPositionForProfileTab(extraTab);
             }
-            final int userId = bundle.getInt(EXTRA_USER_ID, UserHandle.SYSTEM.getIdentifier());
+            final UserManager userManager = getSystemService(UserManager.class);
+            UserHandle mainUser = userManager.getMainUser();
+            if (mainUser == null) {
+                mainUser = UserHandle.SYSTEM;
+            }
+            final int userId = bundle.getInt(EXTRA_USER_ID, mainUser.getIdentifier());
             final boolean isWorkProfile = UserManager.get(activity).isManagedProfile(userId);
             if (isWorkProfile) {
                 return WORK_TAB;
@@ -325,7 +330,7 @@
             List<UserInfo> userInfos = userManager.getProfiles(UserHandle.myUserId());
 
             for (UserInfo userInfo : userInfos) {
-                if (userInfo.getUserHandle().isSystem()) {
+                if (userInfo.isMain()) {
                     fragments.add(createAndGetFragment(
                             ProfileType.PERSONAL,
                             bundle != null ? bundle : new Bundle(),
@@ -345,7 +350,7 @@
                                 privateFragmentConstructor));
                     }
                 } else {
-                    Log.d(TAG, "Not showing tab for unsupported user");
+                    Log.d(TAG, "Not showing tab for unsupported user " + userInfo);
                 }
             }
 
diff --git a/src/com/android/settings/datausage/lib/AppDataUsageRepository.kt b/src/com/android/settings/datausage/lib/AppDataUsageRepository.kt
index 5abde31..0055463 100644
--- a/src/com/android/settings/datausage/lib/AppDataUsageRepository.kt
+++ b/src/com/android/settings/datausage/lib/AppDataUsageRepository.kt
@@ -164,6 +164,7 @@
 
     private fun shouldSkipProfile(userManager : UserManager, userHandle: UserHandle): Boolean {
         if (android.os.Flags.allowPrivateProfile()
+                && android.multiuser.Flags.enablePrivateSpaceFeatures()
                 && android.multiuser.Flags.handleInterleavedSettingsForPrivateSpace()) {
             return (userManager.isQuietModeEnabled(userHandle)
                     && userManager.getUserProperties(userHandle).showInQuietMode
diff --git a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java
index cfa4a58..3e211de 100644
--- a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java
+++ b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java
@@ -69,6 +69,7 @@
 import com.android.settings.development.bluetooth.BluetoothHDAudioPreferenceController;
 import com.android.settings.development.bluetooth.BluetoothQualityDialogPreferenceController;
 import com.android.settings.development.bluetooth.BluetoothSampleRateDialogPreferenceController;
+import com.android.settings.development.bluetooth.BluetoothStackLogPreferenceController;
 import com.android.settings.development.graphicsdriver.GraphicsDriverEnableAngleAsSystemDriverController;
 import com.android.settings.development.qstile.DevelopmentTiles;
 import com.android.settings.development.storage.SharedDataPreferenceController;
@@ -637,6 +638,7 @@
         controllers.add(new StayAwakePreferenceController(context, lifecycle));
         controllers.add(new HdcpCheckingPreferenceController(context));
         controllers.add(new BluetoothSnoopLogPreferenceController(context, fragment));
+        controllers.add(new BluetoothStackLogPreferenceController(context));
         controllers.add(new DefaultLaunchPreferenceController(context,
                 "snoop_logger_filters_dashboard"));
         controllers.add(new BluetoothSnoopLogFilterProfilePbapPreferenceController(context));
diff --git a/src/com/android/settings/development/Enable16KOemUnlockDialog.java b/src/com/android/settings/development/Enable16KOemUnlockDialog.java
new file mode 100644
index 0000000..65690df
--- /dev/null
+++ b/src/com/android/settings/development/Enable16KOemUnlockDialog.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.development;
+
+import android.app.Dialog;
+import android.app.settings.SettingsEnums;
+import android.content.DialogInterface;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AlertDialog;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentManager;
+
+import com.android.settings.R;
+import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
+
+/** Dialog when user interacts 16K pages developer option and device is not OEM unlocked */
+public class Enable16KOemUnlockDialog extends InstrumentedDialogFragment
+        implements DialogInterface.OnClickListener, DialogInterface.OnDismissListener {
+
+    public static final String TAG = "Enable16KOemUnlockDialog";
+
+    /** This method is used to prompt user to do OEM unlock before using 16k */
+    public static void show(@NonNull Fragment hostFragment) {
+        final FragmentManager manager = hostFragment.getActivity().getSupportFragmentManager();
+        Fragment existingFragment = manager.findFragmentByTag(TAG);
+        if (existingFragment == null) {
+            existingFragment = new Enable16KOemUnlockDialog();
+        }
+
+        if (existingFragment instanceof Enable16KOemUnlockDialog) {
+            existingFragment.setTargetFragment(hostFragment, 0 /* requestCode */);
+            ((Enable16KOemUnlockDialog) existingFragment).show(manager, TAG);
+        }
+    }
+
+    @Override
+    public int getMetricsCategory() {
+        return SettingsEnums.DIALOG_ENABLE_16K_PAGES;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
+        return new AlertDialog.Builder(getActivity())
+                .setTitle(R.string.confirm_oem_unlock_for_16k_title)
+                .setMessage(R.string.confirm_oem_unlock_for_16k_text)
+                .setPositiveButton(android.R.string.ok, this /* onClickListener */)
+                .create();
+    }
+
+    @Override
+    public void onClick(@NonNull DialogInterface dialog, int buttonId) {
+        // Do nothing. OEM unlock has to be done by user
+    }
+
+    @Override
+    public void onDismiss(@NonNull DialogInterface dialog) {
+        super.onDismiss(dialog);
+    }
+}
diff --git a/src/com/android/settings/development/Enable16kPagesPreferenceController.java b/src/com/android/settings/development/Enable16kPagesPreferenceController.java
index 3f9da57..bed5c04 100644
--- a/src/com/android/settings/development/Enable16kPagesPreferenceController.java
+++ b/src/com/android/settings/development/Enable16kPagesPreferenceController.java
@@ -22,19 +22,22 @@
 import android.os.ParcelFileDescriptor;
 import android.os.PersistableBundle;
 import android.os.PowerManager;
+import android.os.RecoverySystem;
 import android.os.SystemProperties;
 import android.os.SystemUpdateManager;
 import android.os.UpdateEngine;
 import android.os.UpdateEngineStable;
 import android.os.UpdateEngineStableCallback;
+import android.os.UserHandle;
+import android.os.UserManager;
 import android.provider.Settings;
+import android.service.oemlock.OemLockManager;
 import android.util.Log;
 import android.widget.LinearLayout;
 import android.widget.ProgressBar;
 import android.widget.Toast;
 
 import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import androidx.appcompat.app.AlertDialog;
 import androidx.core.content.ContextCompat;
@@ -54,6 +57,7 @@
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileNotFoundException;
+import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -68,7 +72,8 @@
 public class Enable16kPagesPreferenceController extends DeveloperOptionsPreferenceController
         implements Preference.OnPreferenceChangeListener,
                 PreferenceControllerMixin,
-                Enable16kbPagesDialogHost {
+                Enable16kbPagesDialogHost,
+                EnableExt4DialogHost {
 
     private static final String TAG = "Enable16kPages";
     private static final String REBOOT_REASON = "toggle16k";
@@ -87,7 +92,7 @@
     private static final int OFFSET_TO_FILE_NAME = 30;
     public static final String EXPERIMENTAL_UPDATE_TITLE = "Android 16K Kernel Experimental Update";
 
-    private @Nullable DevelopmentSettingsDashboardFragment mFragment = null;
+    private @NonNull DevelopmentSettingsDashboardFragment mFragment;
     private boolean mEnable16k;
 
     private final ListeningExecutorService mExecutorService =
@@ -96,9 +101,9 @@
     private AlertDialog mProgressDialog;
 
     public Enable16kPagesPreferenceController(
-            @NonNull Context context, @Nullable DevelopmentSettingsDashboardFragment fragment) {
+            @NonNull Context context, @NonNull DevelopmentSettingsDashboardFragment fragment) {
         super(context);
-        mFragment = fragment;
+        this.mFragment = fragment;
     }
 
     @Override
@@ -114,6 +119,16 @@
     @Override
     public boolean onPreferenceChange(Preference preference, Object newValue) {
         mEnable16k = (Boolean) newValue;
+        // Prompt user to do oem unlock first
+        if (!isDeviceOEMUnlocked()) {
+            Enable16KOemUnlockDialog.show(mFragment);
+            return false;
+        }
+
+        if (isDataf2fs()) {
+            EnableExt4WarningDialog.show(mFragment, this);
+            return false;
+        }
         Enable16kPagesWarningDialog.show(mFragment, this, mEnable16k);
         return true;
     }
@@ -162,7 +177,7 @@
                     }
 
                     @Override
-                    public void onFailure(Throwable t) {
+                    public void onFailure(@NonNull Throwable t) {
                         hideProgressDialog();
                         Log.e(TAG, "Failed to call applyPayload of UpdateEngineStable!");
                         displayToast(mContext.getString(R.string.toast_16k_update_failed_text));
@@ -291,6 +306,41 @@
         Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show();
     }
 
+    @Override
+    public void onExt4DialogConfirmed() {
+        // user has confirmed to wipe the device
+        ListenableFuture future = mExecutorService.submit(() -> wipeData());
+        Futures.addCallback(
+                future,
+                new FutureCallback<>() {
+                    @Override
+                    public void onSuccess(@NonNull Object result) {
+                        Log.i(TAG, "Wiping /data  with recovery system.");
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Throwable t) {
+                        Log.e(TAG, "Failed to change the /data partition with ext4");
+                        displayToast(mContext.getString(R.string.format_ext4_failure_toast));
+                    }
+                },
+                ContextCompat.getMainExecutor(mContext));
+    }
+
+    private void wipeData() {
+        RecoverySystem recoveryService = mContext.getSystemService(RecoverySystem.class);
+        try {
+            recoveryService.wipePartitionToExt4();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public void onExt4DialogDismissed() {
+        // Do nothing
+    }
+
     private class OtaUpdateCallback extends UpdateEngineStableCallback {
         UpdateEngineStable mUpdateEngineStable;
 
@@ -357,4 +407,50 @@
         infoBundle.putString(SystemUpdateManager.KEY_TITLE, EXPERIMENTAL_UPDATE_TITLE);
         return infoBundle;
     }
+
+    private boolean isDataf2fs() {
+        try (BufferedReader br = new BufferedReader(new FileReader("/proc/mounts"))) {
+            String line;
+            while ((line = br.readLine()) != null) {
+                Log.i(TAG, line);
+                final String[] fields = line.split(" ");
+                final String partition = fields[1];
+                final String fsType = fields[2];
+                if (partition.equals("/data") && fsType.equals("f2fs")) {
+                    return true;
+                }
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to read /proc/mounts");
+            displayToast(mContext.getString(R.string.format_ext4_failure_toast));
+        }
+
+        return false;
+    }
+
+    private boolean isDeviceOEMUnlocked() {
+        // OEM unlock is checked for bootloader, carrier and user. Check all three to ensure
+        // that device is unlocked and it is also allowed by user as well as carrier
+        final OemLockManager oemLockManager = mContext.getSystemService(OemLockManager.class);
+        final UserManager userManager = mContext.getSystemService(UserManager.class);
+        if (oemLockManager == null || userManager == null) {
+            Log.e(TAG, "Required services not found on device to check for OEM unlock state.");
+            return false;
+        }
+
+        // If either of device or carrier is not allowed to unlock, return false
+        if (!oemLockManager.isDeviceOemUnlocked()
+                || !oemLockManager.isOemUnlockAllowedByCarrier()) {
+            Log.e(TAG, "Device is not OEM unlocked or it is not allowed by carrier");
+            return false;
+        }
+
+        final UserHandle userHandle = UserHandle.of(UserHandle.myUserId());
+        if (userManager.hasBaseUserRestriction(UserManager.DISALLOW_FACTORY_RESET, userHandle)) {
+            Log.e(TAG, "Factory reset is not allowed for user.");
+            return false;
+        }
+
+        return true;
+    }
 }
diff --git a/src/com/android/settings/development/EnableExt4DialogHost.java b/src/com/android/settings/development/EnableExt4DialogHost.java
new file mode 100644
index 0000000..6cbd7e1
--- /dev/null
+++ b/src/com/android/settings/development/EnableExt4DialogHost.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.development;
+
+/** Interface for EnableExt4DialogHost callbacks. */
+public interface EnableExt4DialogHost {
+    /** Callback when the user presses ok the warning dialog. */
+    void onExt4DialogConfirmed();
+
+    /** Callback when the user cancels or dismisses the warning dialog. */
+    void onExt4DialogDismissed();
+}
diff --git a/src/com/android/settings/development/EnableExt4WarningDialog.java b/src/com/android/settings/development/EnableExt4WarningDialog.java
new file mode 100644
index 0000000..c8ba521
--- /dev/null
+++ b/src/com/android/settings/development/EnableExt4WarningDialog.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.development;
+
+import android.app.Dialog;
+import android.app.settings.SettingsEnums;
+import android.content.DialogInterface;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AlertDialog;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentManager;
+
+import com.android.internal.annotations.Initializer;
+import com.android.settings.R;
+import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
+
+/** Dialog when user interacts 16K pages developer option and data is f2fs */
+public class EnableExt4WarningDialog extends InstrumentedDialogFragment
+        implements DialogInterface.OnClickListener, DialogInterface.OnDismissListener {
+
+    public static final String TAG = "EnableExt4WarningDialog";
+
+    private EnableExt4DialogHost mHost;
+
+    @Initializer
+    private void setHost(@NonNull EnableExt4DialogHost host) {
+        this.mHost = host;
+    }
+
+    /** This method is used to show warning dialog to reformat data to /ext4 */
+    public static void show(
+            @NonNull Fragment hostFragment, @NonNull EnableExt4DialogHost dialogHost) {
+        final FragmentManager manager = hostFragment.getActivity().getSupportFragmentManager();
+        Fragment existingFragment = manager.findFragmentByTag(TAG);
+        if (existingFragment == null) {
+            existingFragment = new EnableExt4WarningDialog();
+        }
+
+        if (existingFragment instanceof EnableExt4WarningDialog) {
+            existingFragment.setTargetFragment(hostFragment, 0 /* requestCode */);
+            ((EnableExt4WarningDialog) existingFragment).setHost(dialogHost);
+            ((EnableExt4WarningDialog) existingFragment).show(manager, TAG);
+        }
+    }
+
+    @Override
+    public int getMetricsCategory() {
+        return SettingsEnums.DIALOG_ENABLE_16K_PAGES;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
+        return new AlertDialog.Builder(getActivity())
+                .setTitle(R.string.confirm_format_ext4_title)
+                .setMessage(R.string.confirm_format_ext4_text)
+                .setPositiveButton(android.R.string.ok, this /* onClickListener */)
+                .setNegativeButton(android.R.string.cancel, this /* onClickListener */)
+                .create();
+    }
+
+    @Override
+    public void onClick(@NonNull DialogInterface dialog, int buttonId) {
+        if (buttonId == DialogInterface.BUTTON_POSITIVE) {
+            mHost.onExt4DialogConfirmed();
+        } else {
+            mHost.onExt4DialogDismissed();
+        }
+    }
+
+    @Override
+    public void onDismiss(@NonNull DialogInterface dialog) {
+        super.onDismiss(dialog);
+        mHost.onExt4DialogDismissed();
+    }
+}
diff --git a/src/com/android/settings/development/bluetooth/BluetoothStackLogPreferenceController.java b/src/com/android/settings/development/bluetooth/BluetoothStackLogPreferenceController.java
new file mode 100644
index 0000000..23d4cc6
--- /dev/null
+++ b/src/com/android/settings/development/bluetooth/BluetoothStackLogPreferenceController.java
@@ -0,0 +1,114 @@
+/*
+ * 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.
+ */
+
+package com.android.settings.development.bluetooth;
+
+import android.content.Context;
+import android.os.SystemProperties;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.preference.ListPreference;
+import androidx.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settingslib.development.DeveloperOptionsPreferenceController;
+
+public class BluetoothStackLogPreferenceController extends DeveloperOptionsPreferenceController
+        implements Preference.OnPreferenceChangeListener, PreferenceControllerMixin {
+
+    /* Ensure that the indexes match with bt_stack_log_values and bt_stack_log_entries ordering */
+    private static final String PREFERENCE_KEY = "bt_stack_log_level";
+    @VisibleForTesting static final int BTSTACK_LOG_MODE_VERBOSE_INDEX = 0;
+    @VisibleForTesting static final int BTSTACK_LOG_MODE_DEBUG_INDEX = 1;
+    @VisibleForTesting static final int BTSTACK_LOG_MODE_INFO_INDEX = 2;
+    @VisibleForTesting static final int BTSTACK_LOG_MODE_WARN_INDEX = 3;
+    @VisibleForTesting static final int BTSTACK_LOG_MODE_ERROR_INDEX = 4;
+
+    @VisibleForTesting
+    static final String BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST = "persist.log.tag.bluetooth";
+    static final String BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY = "log.tag.bluetooth";
+    static final String BLUETOOTH_STRING_NAME = "bluetooth";
+    static final int DEFAULT_MODE = BTSTACK_LOG_MODE_INFO_INDEX;
+
+    private final String[] mListValues;
+    private final String[] mListEntries;
+
+
+    public BluetoothStackLogPreferenceController(@NonNull Context context) {
+        super(context);
+        mListValues = context.getResources().getStringArray(R.array.bt_stack_log_level_values);
+        mListEntries = context.getResources().getStringArray(R.array.bt_stack_log_level_entries);
+    }
+
+    /** returns default log level index of INFO */
+    public int getDefaultModeIndex() {
+        return DEFAULT_MODE;
+    }
+
+    @Override
+    @Nullable
+    public String getPreferenceKey() {
+        return PREFERENCE_KEY;
+    }
+
+    @Override
+    public boolean onPreferenceChange(@NonNull Preference preference, @NonNull Object newValue) {
+        SystemProperties.set(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST, newValue.toString());
+        SystemProperties.set(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY, newValue.toString());
+        updateState(mPreference);
+        return true;
+    }
+
+    @Override
+    public void updateState(@NonNull Preference preference) {
+        final ListPreference listPreference = (ListPreference) preference;
+        int index = getBluetoothLogLevelIndex();
+        listPreference.setValue(mListValues[index]);
+        listPreference.setSummary(mListEntries[index]);
+    }
+
+    /**
+     *  Returns the current log level from Log.isLoggable().
+     */
+    @VisibleForTesting
+    public int getBluetoothLogLevelIndex() {
+        if (Log.isLoggable(BLUETOOTH_STRING_NAME, Log.VERBOSE)) {
+            return BTSTACK_LOG_MODE_VERBOSE_INDEX;
+        } else if (Log.isLoggable(BLUETOOTH_STRING_NAME, Log.DEBUG)) {
+            return BTSTACK_LOG_MODE_DEBUG_INDEX;
+        } else if (Log.isLoggable(BLUETOOTH_STRING_NAME, Log.INFO)) {
+            return BTSTACK_LOG_MODE_INFO_INDEX;
+        } else if (Log.isLoggable(BLUETOOTH_STRING_NAME, Log.WARN)) {
+            return BTSTACK_LOG_MODE_WARN_INDEX;
+        } else if (Log.isLoggable(BLUETOOTH_STRING_NAME, Log.ERROR)) {
+            return BTSTACK_LOG_MODE_ERROR_INDEX;
+        }
+        return BTSTACK_LOG_MODE_INFO_INDEX;
+    }
+
+    @Override
+    protected void onDeveloperOptionsSwitchDisabled() {
+        super.onDeveloperOptionsSwitchDisabled();
+        SystemProperties.set(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST, null);
+        SystemProperties.set(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY, null);
+        ((ListPreference) mPreference).setValue(mListValues[getDefaultModeIndex()]);
+        ((ListPreference) mPreference).setSummary(mListEntries[getDefaultModeIndex()]);
+    }
+}
diff --git a/src/com/android/settings/development/quarantine/OWNERS b/src/com/android/settings/development/quarantine/OWNERS
deleted file mode 100644
index d4de31a..0000000
--- a/src/com/android/settings/development/quarantine/OWNERS
+++ /dev/null
@@ -1,4 +0,0 @@
-# Bug component: 316234
-
-sudheersai@google.com
-yamasani@google.com
\ No newline at end of file
diff --git a/src/com/android/settings/development/quarantine/QuarantinedAppPreference.java b/src/com/android/settings/development/quarantine/QuarantinedAppPreference.java
deleted file mode 100644
index 6ad1f86..0000000
--- a/src/com/android/settings/development/quarantine/QuarantinedAppPreference.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.development.quarantine;
-
-import android.content.Context;
-import android.graphics.drawable.Drawable;
-
-import androidx.preference.PreferenceViewHolder;
-
-import com.android.settings.R;
-import com.android.settingslib.applications.AppUtils;
-import com.android.settingslib.applications.ApplicationsState.AppEntry;
-import com.android.settingslib.utils.ThreadUtils;
-import com.android.settingslib.widget.AppSwitchPreference;
-
-public class QuarantinedAppPreference extends AppSwitchPreference {
-    private final AppEntry mEntry;
-    private Drawable mCacheIcon;
-
-    public QuarantinedAppPreference(Context context, AppEntry entry) {
-        super(context);
-        mEntry = entry;
-        mCacheIcon = AppUtils.getIconFromCache(mEntry);
-
-        mEntry.ensureLabel(context);
-        setKey(generateKey(mEntry));
-        if (mCacheIcon != null) {
-            setIcon(mCacheIcon);
-        } else {
-            setIcon(R.drawable.empty_icon);
-        }
-        updateState();
-    }
-
-    static String generateKey(AppEntry entry) {
-        return entry.info.packageName + "|" + entry.info.uid;
-    }
-
-    public AppEntry getEntry() {
-        return mEntry;
-    }
-
-    @Override
-    public void onBindViewHolder(PreferenceViewHolder holder) {
-        if (mCacheIcon == null) {
-            ThreadUtils.postOnBackgroundThread(() -> {
-                final Drawable icon = AppUtils.getIcon(getContext(), mEntry);
-                ThreadUtils.postOnMainThread(() -> {
-                    setIcon(icon);
-                    mCacheIcon = icon;
-                });
-            });
-        }
-        super.onBindViewHolder(holder);
-    }
-
-    void updateState() {
-        setTitle(mEntry.label);
-        setChecked((boolean) mEntry.extraInfo);
-        notifyChanged();
-    }
-}
diff --git a/src/com/android/settings/development/quarantine/QuarantinedAppStateBridge.java b/src/com/android/settings/development/quarantine/QuarantinedAppStateBridge.java
deleted file mode 100644
index 206b922..0000000
--- a/src/com/android/settings/development/quarantine/QuarantinedAppStateBridge.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.development.quarantine;
-
-import android.content.Context;
-import android.content.pm.PackageManager;
-import android.os.UserHandle;
-
-import com.android.settings.applications.AppStateBaseBridge;
-import com.android.settingslib.applications.ApplicationsState;
-import com.android.settingslib.applications.ApplicationsState.AppEntry;
-
-import java.util.ArrayList;
-
-public class QuarantinedAppStateBridge extends AppStateBaseBridge {
-    private Context mContext;
-
-    public QuarantinedAppStateBridge(Context context,
-            ApplicationsState appState, Callback callback) {
-        super(appState, callback);
-        mContext = context;
-    }
-
-    @Override
-    protected void loadAllExtraInfo() {
-        final ArrayList<AppEntry> apps = mAppSession.getAllApps();
-        for (int i = 0; i < apps.size(); i++) {
-            final AppEntry app = apps.get(i);
-            updateExtraInfo(app, app.info.packageName, app.info.uid);
-        }
-    }
-
-    @Override
-    protected void updateExtraInfo(AppEntry app, String pkg, int uid) {
-        app.extraInfo = isPackageQuarantined(pkg, uid);
-    }
-
-    private boolean isPackageQuarantined(String pkg, int uid) {
-        final PackageManager pm = mContext.createContextAsUser(
-                UserHandle.getUserHandleForUid(uid), 0).getPackageManager();
-        try {
-            return pm.isPackageQuarantined(pkg);
-        } catch (PackageManager.NameNotFoundException e) {
-            return false;
-        }
-    }
-}
diff --git a/src/com/android/settings/development/quarantine/QuarantinedAppsFragment.java b/src/com/android/settings/development/quarantine/QuarantinedAppsFragment.java
deleted file mode 100644
index 985e962..0000000
--- a/src/com/android/settings/development/quarantine/QuarantinedAppsFragment.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.development.quarantine;
-
-import static android.view.MenuItem.SHOW_AS_ACTION_ALWAYS;
-import static android.view.MenuItem.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW;
-
-import android.app.settings.SettingsEnums;
-import android.os.Bundle;
-import android.text.TextUtils;
-import android.view.Menu;
-import android.view.MenuInflater;
-import android.view.MenuItem;
-import android.widget.SearchView;
-
-import com.android.settings.R;
-import com.android.settings.dashboard.DashboardFragment;
-import com.android.settings.search.BaseSearchIndexProvider;
-import com.android.settingslib.applications.AppIconCacheManager;
-import com.android.settingslib.applications.ApplicationsState;
-import com.android.settingslib.applications.ApplicationsState.AppFilter;
-import com.android.settingslib.search.SearchIndexable;
-
-import com.google.android.material.appbar.AppBarLayout;
-
-// TODO: b/297934650 - Update this to use SPA framework
-@SearchIndexable
-public class QuarantinedAppsFragment extends DashboardFragment implements
-        SearchView.OnQueryTextListener, SearchView.OnCloseListener,
-        MenuItem.OnActionExpandListener {
-    private static final String TAG = "QuarantinedApps";
-
-    private static final int MENU_SEARCH_APPS = Menu.FIRST + 42;
-    private static final int MENU_SHOW_SYSTEM = Menu.FIRST + 43;
-    private static final String EXTRA_SHOW_SYSTEM = "show_system";
-
-    private boolean mShowSystem;
-    private SearchView mSearchView;
-    private String mCurQuery;
-
-    @Override
-    public void onCreate(Bundle icicle) {
-        super.onCreate(icicle);
-        mShowSystem = icicle != null && icicle.getBoolean(EXTRA_SHOW_SYSTEM);
-        use(QuarantinedAppsScreenController.class).setFilter(mCustomFilter);
-        use(QuarantinedAppsScreenController.class).setSession(getSettingsLifecycle());
-    }
-
-    @Override
-    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
-        mSearchView = new SearchView(getContext());
-        mSearchView.setOnQueryTextListener(this);
-        mSearchView.setOnCloseListener(this);
-        mSearchView.setIconifiedByDefault(true);
-
-        menu.add(Menu.NONE, MENU_SEARCH_APPS, Menu.NONE, R.string.search_settings)
-                .setIcon(R.drawable.ic_find_in_page_24px)
-                .setActionView(mSearchView)
-                .setOnActionExpandListener(this)
-                .setShowAsAction(SHOW_AS_ACTION_ALWAYS | SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW);
-        menu.add(Menu.NONE, MENU_SHOW_SYSTEM, Menu.NONE,
-                mShowSystem ? R.string.menu_hide_system : R.string.menu_show_system);
-        super.onCreateOptionsMenu(menu, inflater);
-    }
-
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        if (item.getItemId() == MENU_SHOW_SYSTEM) {
-            mShowSystem = !mShowSystem;
-            item.setTitle(mShowSystem ? R.string.menu_hide_system : R.string.menu_show_system);
-            use(QuarantinedAppsScreenController.class).setFilter(mCustomFilter);
-            use(QuarantinedAppsScreenController.class).rebuild();
-            return true;
-        }
-        return super.onOptionsItemSelected(item);
-    }
-
-    @Override
-    public boolean onQueryTextChange(String newText) {
-        mCurQuery = !TextUtils.isEmpty(newText) ? newText : null;
-        use(QuarantinedAppsScreenController.class).rebuild();
-        return true;
-    }
-
-    @Override
-    public boolean onQueryTextSubmit(String query) {
-        // Don't care about this.
-        return true;
-    }
-
-    @Override
-    public boolean onClose() {
-        if (!TextUtils.isEmpty(mSearchView.getQuery())) {
-            mSearchView.setQuery(null, true);
-        }
-        return true;
-    }
-
-    public final AppFilter mCustomFilter = new AppFilter() {
-        @Override
-        public void init() {
-        }
-
-        @Override
-        public boolean filterApp(ApplicationsState.AppEntry entry) {
-            final AppFilter defaultFilter = mShowSystem ? ApplicationsState.FILTER_ALL_ENABLED
-                    : ApplicationsState.FILTER_DOWNLOADED_AND_LAUNCHER;
-            return defaultFilter.filterApp(entry) && (mCurQuery == null
-                    || entry.label.toLowerCase().contains(mCurQuery.toLowerCase()));
-        }
-    };
-
-    @Override
-    public boolean onMenuItemActionExpand(MenuItem item) {
-        final AppBarLayout mAppBarLayout = getActivity().findViewById(R.id.app_bar);
-        // To prevent a large space on tool bar.
-        mAppBarLayout.setExpanded(false /*expanded*/, false /*animate*/);
-        return true;
-    }
-
-    @Override
-    public boolean onMenuItemActionCollapse(MenuItem item) {
-        final AppBarLayout mAppBarLayout = getActivity().findViewById(R.id.app_bar);
-        // To prevent a large space on tool bar.
-        mAppBarLayout.setExpanded(false /*expanded*/, false /*animate*/);
-        return true;
-    }
-
-    @Override
-    public int getPreferenceScreenResId() {
-        return R.xml.quarantined_apps;
-    }
-
-    @Override
-    public void onSaveInstanceState(Bundle outState) {
-        super.onSaveInstanceState(outState);
-        outState.putBoolean(EXTRA_SHOW_SYSTEM, mShowSystem);
-    }
-
-    @Override
-    protected String getLogTag() {
-        return TAG;
-    }
-
-    @Override
-    public int getMetricsCategory() {
-        return SettingsEnums.QUARANTINED_APPS_DEV_CONTROL;
-    }
-
-    @Override
-    public void onDestroyView() {
-        super.onDestroyView();
-        AppIconCacheManager.getInstance().release();
-    }
-
-    public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
-            new BaseSearchIndexProvider(R.xml.quarantined_apps);
-}
diff --git a/src/com/android/settings/development/quarantine/QuarantinedAppsPreferenceController.java b/src/com/android/settings/development/quarantine/QuarantinedAppsPreferenceController.java
deleted file mode 100644
index de3b18b..0000000
--- a/src/com/android/settings/development/quarantine/QuarantinedAppsPreferenceController.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.development.quarantine;
-
-import android.content.Context;
-import android.content.pm.Flags;
-
-import com.android.settings.core.BasePreferenceController;
-
-public class QuarantinedAppsPreferenceController extends BasePreferenceController {
-    public QuarantinedAppsPreferenceController(Context context, String preferenceKey) {
-        super(context, preferenceKey);
-    }
-
-    @Override
-    public int getAvailabilityStatus() {
-        return Flags.quarantinedEnabled() ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
-    }
-}
diff --git a/src/com/android/settings/development/quarantine/QuarantinedAppsScreenController.java b/src/com/android/settings/development/quarantine/QuarantinedAppsScreenController.java
deleted file mode 100644
index 4d4834b..0000000
--- a/src/com/android/settings/development/quarantine/QuarantinedAppsScreenController.java
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.development.quarantine;
-
-import android.app.Application;
-import android.content.Context;
-import android.content.pm.Flags;
-import android.content.pm.PackageManager;
-import android.content.pm.SuspendDialogInfo;
-import android.os.UserHandle;
-
-import androidx.annotation.VisibleForTesting;
-import androidx.preference.Preference;
-import androidx.preference.PreferenceScreen;
-
-import com.android.settings.R;
-import com.android.settings.applications.AppStateBaseBridge;
-import com.android.settings.core.BasePreferenceController;
-import com.android.settingslib.applications.AppUtils;
-import com.android.settingslib.applications.ApplicationsState;
-import com.android.settingslib.applications.ApplicationsState.AppEntry;
-import com.android.settingslib.applications.ApplicationsState.AppFilter;
-import com.android.settingslib.core.lifecycle.Lifecycle;
-import com.android.settingslib.core.lifecycle.LifecycleObserver;
-import com.android.settingslib.core.lifecycle.events.OnDestroy;
-import com.android.settingslib.core.lifecycle.events.OnStart;
-import com.android.settingslib.core.lifecycle.events.OnStop;
-
-import java.util.ArrayList;
-import java.util.Set;
-import java.util.TreeSet;
-
-public class QuarantinedAppsScreenController extends BasePreferenceController implements
-        LifecycleObserver, OnStart, OnStop, OnDestroy,
-        ApplicationsState.Callbacks, Preference.OnPreferenceChangeListener,
-        AppStateBaseBridge.Callback {
-    private final ApplicationsState mApplicationsState;
-    private final QuarantinedAppStateBridge mQuarantinedAppStateBridge;
-    private ApplicationsState.Session mSession;
-    private PreferenceScreen mScreen;
-    private AppFilter mFilter;
-    private boolean mExtraLoaded;
-
-    public QuarantinedAppsScreenController(Context context, String preferenceKey) {
-        super(context, preferenceKey);
-        mApplicationsState = ApplicationsState.getInstance(
-                (Application) context.getApplicationContext());
-        mQuarantinedAppStateBridge = new QuarantinedAppStateBridge(context,
-                mApplicationsState, this);
-    }
-
-    @Override
-    public void onStart() {
-        mQuarantinedAppStateBridge.resume(true /* forceLoadAllApps */);
-    }
-
-    @Override
-    public void onStop() {
-        mQuarantinedAppStateBridge.pause();
-    }
-
-    @Override
-    public void onDestroy() {
-        mQuarantinedAppStateBridge.release();
-    }
-
-    @Override
-    public void displayPreference(PreferenceScreen screen) {
-        super.displayPreference(screen);
-        mScreen = screen;
-    }
-
-    public void setFilter(AppFilter filter) {
-        mFilter = filter;
-    }
-
-    public void setSession(Lifecycle lifecycle) {
-        mSession = mApplicationsState.newSession(this, lifecycle);
-    }
-
-    @Override
-    public void onExtraInfoUpdated() {
-        mExtraLoaded = true;
-        rebuild();
-    }
-
-    public void rebuild() {
-        if (!mExtraLoaded || mSession == null) {
-            return;
-        }
-
-        final ArrayList<AppEntry> apps = mSession.rebuild(mFilter,
-                ApplicationsState.ALPHA_COMPARATOR);
-        if (apps != null) {
-            onRebuildComplete(apps);
-        }
-    }
-
-    @Override
-    public void onRebuildComplete(ArrayList<AppEntry> apps) {
-        if (apps == null) {
-            return;
-        }
-
-        // Preload top visible icons of app list.
-        AppUtils.preloadTopIcons(mContext, apps,
-                mContext.getResources().getInteger(R.integer.config_num_visible_app_icons));
-
-        // Create apps key set for removing useless preferences
-        final Set<String> appsKeySet = new TreeSet<>();
-        // Add or update preferences
-        final int count = apps.size();
-        for (int i = 0; i < count; i++) {
-            final AppEntry entry = apps.get(i);
-            if (!shouldAddPreference(entry)) {
-                continue;
-            }
-            final String prefkey = QuarantinedAppPreference.generateKey(entry);
-            appsKeySet.add(prefkey);
-            QuarantinedAppPreference preference = mScreen.findPreference(prefkey);
-            if (preference == null) {
-                preference = new QuarantinedAppPreference(mScreen.getContext(), entry);
-                preference.setOnPreferenceChangeListener(this);
-                mScreen.addPreference(preference);
-            } else {
-                preference.updateState();
-            }
-            preference.setOrder(i);
-        }
-
-        // Remove useless preferences
-        removeUselessPrefs(appsKeySet);
-    }
-
-    private void removeUselessPrefs(final Set<String> appsKeySet) {
-        final int prefCount = mScreen.getPreferenceCount();
-        String prefKey;
-        if (prefCount > 0) {
-            for (int i = prefCount - 1; i >= 0; i--) {
-                final Preference pref = mScreen.getPreference(i);
-                prefKey = pref.getKey();
-                if (!appsKeySet.isEmpty() && appsKeySet.contains(prefKey)) {
-                    continue;
-                }
-                mScreen.removePreference(pref);
-            }
-        }
-    }
-
-    @VisibleForTesting
-    static boolean shouldAddPreference(AppEntry app) {
-        return app != null && UserHandle.isApp(app.info.uid);
-    }
-
-    @Override
-    public boolean onPreferenceChange(Preference preference, Object newValue) {
-        if (preference instanceof QuarantinedAppPreference) {
-            final QuarantinedAppPreference quarantinedPreference =
-                    (QuarantinedAppPreference) preference;
-            final boolean quarantined = newValue == Boolean.TRUE;
-            setPackageQuarantined(quarantinedPreference.getEntry().info.packageName,
-                    quarantinedPreference.getEntry().info.uid, quarantined);
-            quarantinedPreference.getEntry().extraInfo = quarantined;
-            return true;
-        }
-        return false;
-    }
-
-    private void setPackageQuarantined(String pkg, int uid, boolean quarantined) {
-        final PackageManager pm = mContext.createContextAsUser(
-                UserHandle.getUserHandleForUid(uid), 0).getPackageManager();
-        final SuspendDialogInfo dialogInfo;
-        if (quarantined) {
-            dialogInfo = new SuspendDialogInfo.Builder()
-                    .setNeutralButtonText(R.string.unquarantine_app_button)
-                    .setNeutralButtonAction(SuspendDialogInfo.BUTTON_ACTION_UNSUSPEND)
-                    .build();
-        } else {
-            dialogInfo = null;
-        }
-        pm.setPackagesSuspended(new String[] {pkg}, quarantined, null /* appExtras */,
-                null /* launcherExtras */, dialogInfo,
-                PackageManager.FLAG_SUSPEND_QUARANTINED);
-    }
-
-    @Override
-    public int getAvailabilityStatus() {
-        return Flags.quarantinedEnabled() ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
-    }
-
-    @Override
-    public void onRunningStateChanged(boolean running) {
-    }
-
-    @Override
-    public void onPackageListChanged() {
-    }
-
-    @Override
-    public void onPackageIconChanged() {
-    }
-
-    @Override
-    public void onPackageSizeChanged(String packageName) {
-    }
-
-    @Override
-    public void onAllSizesComputed() {
-    }
-
-    @Override
-    public void onLauncherInfoChanged() {
-    }
-
-    @Override
-    public void onLoadEntriesCompleted() {
-    }
-}
diff --git a/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java b/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java
index 6ef5aa8..42e6d9c 100644
--- a/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java
+++ b/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java
@@ -52,7 +52,6 @@
 import com.android.settingslib.applications.ApplicationsState;
 import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.core.instrumentation.Instrumentable;
-import com.android.settingslib.datastore.ChangeReason;
 import com.android.settingslib.widget.LayoutPreference;
 
 import java.util.ArrayList;
@@ -272,7 +271,6 @@
     public void onPause() {
         super.onPause();
 
-        notifyBackupManager();
         final int currentOptimizeMode = mBatteryOptimizeUtils.getAppOptimizationMode();
         mLogStringBuilder.append(", onPause mode = ").append(currentOptimizeMode);
         logMetricCategory(currentOptimizeMode);
@@ -290,13 +288,6 @@
     }
 
     @VisibleForTesting
-    void notifyBackupManager() {
-        if (mOptimizationMode != mBatteryOptimizeUtils.getAppOptimizationMode()) {
-            BatterySettingsStorage.get(getContext()).notifyChange(ChangeReason.UPDATE);
-        }
-    }
-
-    @VisibleForTesting
     void initHeader() {
         final View appSnippet = mHeaderPreference.findViewById(R.id.entity_header);
         final Activity context = getActivity();
diff --git a/src/com/android/settings/fuelgauge/BatteryOptimizeUtils.java b/src/com/android/settings/fuelgauge/BatteryOptimizeUtils.java
index dc4aade..001876c3 100644
--- a/src/com/android/settings/fuelgauge/BatteryOptimizeUtils.java
+++ b/src/com/android/settings/fuelgauge/BatteryOptimizeUtils.java
@@ -33,6 +33,7 @@
 
 import com.android.settings.R;
 import com.android.settings.fuelgauge.BatteryOptimizeHistoricalLogEntry.Action;
+import com.android.settingslib.datastore.ChangeReason;
 import com.android.settingslib.fuelgauge.PowerAllowlistBackend;
 
 import java.lang.annotation.Retention;
@@ -222,6 +223,10 @@
             return;
         }
 
+        // App preferences are already clear when code reach here, and there may be no
+        // setAppUsageStateInternal call to notifyChange. So always trigger notifyChange here.
+        BatterySettingsStorage.get(context).notifyChange(ChangeReason.DELETE);
+
         allowlistBackend.refreshList();
         // Resets optimization mode for each application.
         for (ApplicationInfo info : applications) {
@@ -351,6 +356,9 @@
         }
         BatteryOptimizeLogUtils.writeLog(
                 context, action, packageNameKey, createLogEvent(appStandbyMode, allowListed));
+        if (action != Action.RESET) { // reset has been notified in resetAppOptimizationMode
+            BatterySettingsStorage.get(context).notifyChange(toChangeReason(action));
+        }
     }
 
     private static String createLogEvent(int appStandbyMode, boolean allowListed) {
@@ -362,4 +370,8 @@
                         allowListed,
                         getAppOptimizationMode(appStandbyMode, allowListed));
     }
+
+    private static @ChangeReason int toChangeReason(Action action) {
+        return action == Action.RESTORE ? ChangeReason.RESTORE : ChangeReason.UPDATE;
+    }
 }
diff --git a/src/com/android/settings/fuelgauge/BatterySettingsStorage.java b/src/com/android/settings/fuelgauge/BatterySettingsStorage.java
index ff3223f..99edbec 100644
--- a/src/com/android/settings/fuelgauge/BatterySettingsStorage.java
+++ b/src/com/android/settings/fuelgauge/BatterySettingsStorage.java
@@ -26,7 +26,6 @@
 import android.content.pm.ApplicationInfo;
 import android.os.Build;
 import android.os.IDeviceIdleController;
-import android.os.ParcelFileDescriptor;
 import android.os.RemoteException;
 import android.os.ServiceManager;
 import android.os.UserHandle;
@@ -39,6 +38,7 @@
 
 import com.android.settings.fuelgauge.BatteryOptimizeHistoricalLogEntry.Action;
 import com.android.settings.overlay.FeatureFactory;
+import com.android.settingslib.datastore.BackupCodec;
 import com.android.settingslib.datastore.BackupContext;
 import com.android.settingslib.datastore.BackupRestoreEntity;
 import com.android.settingslib.datastore.BackupRestoreStorageManager;
@@ -52,6 +52,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 
 /** An implementation to backup and restore battery configurations. */
@@ -159,8 +160,24 @@
         return Arrays.asList(allowlistedApps);
     }
 
+    @NonNull
     @Override
-    public void writeNewStateDescription(@NonNull ParcelFileDescriptor newState) {
+    public OutputStream wrapBackupOutputStream(
+            @NonNull BackupCodec codec, @NonNull OutputStream outputStream) {
+        // not using any codec for backward compatibility
+        return outputStream;
+    }
+
+    @NonNull
+    @Override
+    public InputStream wrapRestoreInputStream(
+            @NonNull BackupCodec codec, @NonNull InputStream inputStream) {
+        // not using any codec for backward compatibility
+        return inputStream;
+    }
+
+    @Override
+    public void onRestoreFinished() {
         BatterySettingsMigrateChecker.verifySaverConfiguration(mApplication);
         performRestoreIfNeeded();
     }
@@ -305,8 +322,8 @@
                 @NonNull BackupContext backupContext, @NonNull OutputStream outputStream)
                 throws IOException {
             final long timestamp = System.currentTimeMillis();
-            final ArraySet<ApplicationInfo> applications = getInstalledApplications();
-            if (applications == null || applications.isEmpty()) {
+            final ApplicationInfo[] applications = getInstalledApplications();
+            if (applications.length == 0) {
                 Log.w(TAG, "no data found in the getInstalledApplications()");
                 return EntityBackupResult.DELETE;
             }
@@ -344,15 +361,24 @@
                     TAG,
                     String.format(
                             "backup getInstalledApplications():%d count=%d in %d/ms",
-                            applications.size(),
+                            applications.length,
                             backupCount,
                             (System.currentTimeMillis() - timestamp)));
             return EntityBackupResult.UPDATE;
         }
 
-        private @Nullable ArraySet<ApplicationInfo> getInstalledApplications() {
-            return BatteryOptimizeUtils.getInstalledApplications(
-                    mApplication, AppGlobals.getPackageManager());
+        private ApplicationInfo[] getInstalledApplications() {
+            ArraySet<ApplicationInfo> installedApplications =
+                    BatteryOptimizeUtils.getInstalledApplications(
+                            mApplication, AppGlobals.getPackageManager());
+            ApplicationInfo[] applicationInfos = new ApplicationInfo[0];
+            if (installedApplications == null || installedApplications.isEmpty()) {
+                return applicationInfos;
+            }
+            applicationInfos = installedApplications.toArray(applicationInfos);
+            // sort the list to ensure backup data is stable
+            Arrays.sort(applicationInfos, Comparator.comparing(info -> info.packageName));
+            return applicationInfos;
         }
 
         static @NonNull SharedPreferences getSharedPreferences(Context context) {
diff --git a/src/com/android/settings/fuelgauge/PowerBackgroundUsageDetail.java b/src/com/android/settings/fuelgauge/PowerBackgroundUsageDetail.java
index 56702cf..b662d3e 100644
--- a/src/com/android/settings/fuelgauge/PowerBackgroundUsageDetail.java
+++ b/src/com/android/settings/fuelgauge/PowerBackgroundUsageDetail.java
@@ -41,7 +41,6 @@
 import com.android.settingslib.applications.AppUtils;
 import com.android.settingslib.applications.ApplicationsState;
 import com.android.settingslib.core.AbstractPreferenceController;
-import com.android.settingslib.datastore.ChangeReason;
 import com.android.settingslib.widget.FooterPreference;
 import com.android.settingslib.widget.LayoutPreference;
 import com.android.settingslib.widget.MainSwitchPreference;
@@ -116,7 +115,6 @@
     public void onPause() {
         super.onPause();
 
-        notifyBackupManager();
         final int currentOptimizeMode = mBatteryOptimizeUtils.getAppOptimizationMode();
         mLogStringBuilder.append(", onPause mode = ").append(currentOptimizeMode);
         logMetricCategory(currentOptimizeMode);
@@ -184,13 +182,6 @@
     }
 
     @VisibleForTesting
-    void notifyBackupManager() {
-        if (mOptimizationMode != mBatteryOptimizeUtils.getAppOptimizationMode()) {
-            BatterySettingsStorage.get(getContext()).notifyChange(ChangeReason.UPDATE);
-        }
-    }
-
-    @VisibleForTesting
     int getSelectedPreference() {
         if (!mMainSwitchPreference.isChecked()) {
             return BatteryOptimizeUtils.MODE_RESTRICTED;
diff --git a/src/com/android/settings/gestures/OneHandedSettingsUtils.java b/src/com/android/settings/gestures/OneHandedSettingsUtils.java
index 04898dc..fe7db4f 100644
--- a/src/com/android/settings/gestures/OneHandedSettingsUtils.java
+++ b/src/com/android/settings/gestures/OneHandedSettingsUtils.java
@@ -50,6 +50,8 @@
             Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS);
     static final Uri HARDWARE_SHORTCUT_ENABLED_URI =
             Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE);
+    static final Uri QS_SHORTCUT_ENABLED_URI =
+            Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_QS_TARGETS);
 
     public enum OneHandedTimeout {
         NEVER(0), SHORT(4), MEDIUM(8), LONG(12);
@@ -254,6 +256,16 @@
         if (!TextUtils.isEmpty(targetsHW) && targetsHW.contains(ONE_HANDED_MODE_TARGET_NAME)) {
             return true;
         }
+
+        if (android.view.accessibility.Flags.a11yQsShortcut()) {
+            // Checks QS_SHORTCUT_KEY
+            final String targetsQs = Settings.Secure.getStringForUser(context.getContentResolver(),
+                    Settings.Secure.ACCESSIBILITY_QS_TARGETS, sCurrentUserId);
+            if (!TextUtils.isEmpty(targetsQs) && targetsQs.contains(ONE_HANDED_MODE_TARGET_NAME)) {
+                return true;
+            }
+        }
+
         return false;
     }
 
@@ -301,6 +313,9 @@
             resolver.registerContentObserver(SHOW_NOTIFICATION_ENABLED_URI, true, this);
             resolver.registerContentObserver(SOFTWARE_SHORTCUT_ENABLED_URI, true, this);
             resolver.registerContentObserver(HARDWARE_SHORTCUT_ENABLED_URI, true, this);
+            if (android.view.accessibility.Flags.a11yQsShortcut()) {
+                resolver.registerContentObserver(QS_SHORTCUT_ENABLED_URI, true, this);
+            }
         }
 
         @Override
diff --git a/src/com/android/settings/gestures/SystemNavigationGestureSettings.java b/src/com/android/settings/gestures/SystemNavigationGestureSettings.java
index c40212b..c38be94 100644
--- a/src/com/android/settings/gestures/SystemNavigationGestureSettings.java
+++ b/src/com/android/settings/gestures/SystemNavigationGestureSettings.java
@@ -247,6 +247,7 @@
         switch (systemNavKey) {
             case KEY_SYSTEM_NAV_GESTURAL:
                 if (isGestureTutorialAvailable()){
+                    videoPref.setContentDescription(R.string.nav_tutorial_button_description);
                     videoPref.setOnPreferenceClickListener(preference -> {
                         startActivity(mLaunchSandboxIntent);
                         return true;
diff --git a/src/com/android/settings/inputmethod/TrackpadTapDraggingPreferenceController.java b/src/com/android/settings/inputmethod/TrackpadTapDraggingPreferenceController.java
index 28c2915..30253a8 100644
--- a/src/com/android/settings/inputmethod/TrackpadTapDraggingPreferenceController.java
+++ b/src/com/android/settings/inputmethod/TrackpadTapDraggingPreferenceController.java
@@ -16,16 +16,22 @@
 
 package com.android.settings.inputmethod;
 
+import android.app.settings.SettingsEnums;
 import android.content.Context;
 import android.hardware.input.InputSettings;
 
 import com.android.settings.R;
 import com.android.settings.core.TogglePreferenceController;
+import com.android.settings.overlay.FeatureFactory;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
 
 public class TrackpadTapDraggingPreferenceController extends TogglePreferenceController {
 
+    private MetricsFeatureProvider mMetricsFeatureProvider;
+
     public TrackpadTapDraggingPreferenceController(Context context, String key) {
         super(context, key);
+        mMetricsFeatureProvider = FeatureFactory.getFeatureFactory().getMetricsFeatureProvider();
     }
 
     @Override
@@ -36,7 +42,8 @@
     @Override
     public boolean setChecked(boolean isChecked) {
         InputSettings.setTouchpadTapDragging(mContext, isChecked);
-        // TODO(b/321978150): add a metric for tap dragging settings changes.
+        mMetricsFeatureProvider.action(
+                mContext, SettingsEnums.ACTION_GESTURE_TAP_DRAGGING_CHANGED, isChecked);
         return true;
     }
 
diff --git a/src/com/android/settings/localepicker/LocaleNotificationDataManager.java b/src/com/android/settings/localepicker/LocaleNotificationDataManager.java
index 0e89366..6ec578d 100644
--- a/src/com/android/settings/localepicker/LocaleNotificationDataManager.java
+++ b/src/com/android/settings/localepicker/LocaleNotificationDataManager.java
@@ -19,8 +19,11 @@
 import android.content.Context;
 import android.content.SharedPreferences;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
 
+import com.android.settingslib.datastore.SharedPreferencesStorage;
+
 import com.google.gson.Gson;
 
 import java.util.HashMap;
@@ -43,6 +46,12 @@
         this.mContext = context;
     }
 
+    /** Returns the underlying {@link SharedPreferences} storage. */
+    @NonNull
+    public static SharedPreferencesStorage getSharedPreferencesStorage(@NonNull Context context) {
+        return new SharedPreferencesStorage(context, LOCALE_NOTIFICATION, Context.MODE_PRIVATE);
+    }
+
     private static SharedPreferences getSharedPreferences(Context context) {
         return context.getSharedPreferences(LOCALE_NOTIFICATION, Context.MODE_PRIVATE);
     }
diff --git a/src/com/android/settings/location/LocationForPrivateProfilePreferenceController.java b/src/com/android/settings/location/LocationForPrivateProfilePreferenceController.java
index a7be7a5..d68cf72 100644
--- a/src/com/android/settings/location/LocationForPrivateProfilePreferenceController.java
+++ b/src/com/android/settings/location/LocationForPrivateProfilePreferenceController.java
@@ -68,6 +68,7 @@
     @Override
     public int getAvailabilityStatus() {
         if (!android.os.Flags.allowPrivateProfile()
+                || !android.multiuser.Flags.enablePrivateSpaceFeatures()
                 || !android.multiuser.Flags.handleInterleavedSettingsForPrivateSpace()
                 || !isPrivateProfileAvailable()) {
             return CONDITIONALLY_UNAVAILABLE;
diff --git a/src/com/android/settings/network/EraseEuiccDataController.java b/src/com/android/settings/network/EraseEuiccDataController.java
index 9892f0d..782ab7d 100644
--- a/src/com/android/settings/network/EraseEuiccDataController.java
+++ b/src/com/android/settings/network/EraseEuiccDataController.java
@@ -25,7 +25,6 @@
 
 import com.android.settings.Utils;
 import com.android.settings.core.BasePreferenceController;
-import com.android.settings.core.PreferenceControllerMixin;
 import com.android.settings.network.telephony.MobileNetworkUtils;
 import com.android.settings.system.ResetDashboardFragment;
 
@@ -51,7 +50,12 @@
         if (!TextUtils.equals(preference.getKey(), getPreferenceKey())) {
             return false;
         }
-        EraseEuiccDataDialogFragment.show(mHostFragment);
+        if (SubscriptionUtil.hasSubscriptionWithRacCarrier(mContext)
+                && !SubscriptionUtil.isConnectedToWifi(mContext)) {
+            EuiccRacConnectivityDialogFragment.show(mHostFragment);
+        } else {
+            EraseEuiccDataDialogFragment.show(mHostFragment);
+        }
         return true;
     }
 
diff --git a/src/com/android/settings/network/EuiccRacConnectivityDialogFragment.java b/src/com/android/settings/network/EuiccRacConnectivityDialogFragment.java
new file mode 100644
index 0000000..76a587e
--- /dev/null
+++ b/src/com/android/settings/network/EuiccRacConnectivityDialogFragment.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.network;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.settings.SettingsEnums;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentManager;
+
+import com.android.settings.R;
+import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
+import com.android.settings.system.ResetDashboardFragment;
+
+public class EuiccRacConnectivityDialogFragment extends InstrumentedDialogFragment
+        implements DialogInterface.OnClickListener {
+    public static final String TAG = "EuiccRacConnectivityDlg";
+
+    static void show(ResetDashboardFragment host) {
+        final EuiccRacConnectivityDialogFragment dialog = new EuiccRacConnectivityDialogFragment();
+        dialog.setTargetFragment(host, /* requestCode= */ 0);
+        final FragmentManager manager = host.getActivity().getSupportFragmentManager();
+        dialog.show(manager, TAG);
+    }
+
+    @Override
+    public int getMetricsCategory() {
+        return SettingsEnums.RESET_EUICC;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
+        String title = getString(R.string.wifi_warning_dialog_title);
+        String message = getString(R.string.wifi_warning_dialog_text);
+
+        AlertDialog.Builder builder =
+                new AlertDialog.Builder(getContext())
+                        .setOnDismissListener(this)
+                        // Return is on the right side
+                        .setPositiveButton(R.string.wifi_warning_return_button, null)
+                        // Continue is on the left side
+                        .setNegativeButton(R.string.wifi_warning_continue_button, this);
+
+        View content =
+                LayoutInflater.from(getContext())
+                        .inflate(R.layout.sim_warning_dialog_wifi_connectivity, null);
+
+        // Found the layout resource
+        if (content != null) {
+            TextView dialogTitle = content.findViewById(R.id.title);
+            if (!TextUtils.isEmpty(title) && dialogTitle != null) {
+                dialogTitle.setText(title);
+                dialogTitle.setVisibility(View.VISIBLE);
+            }
+            TextView dialogMessage = content.findViewById(R.id.msg);
+            if (!TextUtils.isEmpty(message) && dialogMessage != null) {
+                dialogMessage.setText(message);
+                dialogMessage.setVisibility(View.VISIBLE);
+            }
+
+            builder.setView(content);
+        } else { // Not found the layout resource, use standard layout
+            if (!TextUtils.isEmpty(title)) {
+                builder.setTitle(title);
+            }
+            if (!TextUtils.isEmpty(message)) {
+                builder.setMessage(message);
+            }
+        }
+
+        AlertDialog dialog = builder.create();
+        dialog.setCanceledOnTouchOutside(false);
+        return dialog;
+    }
+
+    @Override
+    public void onClick(@NonNull DialogInterface dialog, int which) {
+        final Fragment fragment = getTargetFragment();
+        if (!(fragment instanceof ResetDashboardFragment)) {
+            Log.e(TAG, "getTargetFragment return unexpected type");
+            return;
+        }
+
+        // Positions of the buttons have been switch:
+        // negative button = left button = the button to continue
+        if (which == DialogInterface.BUTTON_NEGATIVE) {
+            EraseEuiccDataDialogFragment.show(((ResetDashboardFragment) fragment));
+        }
+    }
+}
diff --git a/src/com/android/settings/network/SubscriptionUtil.java b/src/com/android/settings/network/SubscriptionUtil.java
index 497af25..6d6f4c5 100644
--- a/src/com/android/settings/network/SubscriptionUtil.java
+++ b/src/com/android/settings/network/SubscriptionUtil.java
@@ -523,20 +523,21 @@
 
     /**
      * Starts a dialog activity to handle eSIM deletion.
+     *
      * @param context {@code Context}
      * @param subId The id of subscription need to be deleted.
+     * @param carrierId The carrier id of the subscription.
      */
-    public static void startDeleteEuiccSubscriptionDialogActivity(Context context, int subId,
-            int carrierId) {
+    public static void startDeleteEuiccSubscriptionDialogActivity(
+            @NonNull Context context, int subId, int carrierId) {
         if (!SubscriptionManager.isUsableSubscriptionId(subId)) {
             Log.i(TAG, "Unable to delete subscription due to invalid subscription ID.");
             return;
         }
-        final int[] carriersThatUseRAC = context.getResources().getIntArray(
-                R.array.config_carrier_use_rac);
-        boolean isCarrierRac = Arrays.stream(carriersThatUseRAC).anyMatch(cid -> cid == carrierId);
 
-        if (isCarrierRac && !isConnectedToWifiOrDifferentSubId(context, subId)) {
+        if (isCarrierRac(context, carrierId)
+                && (!isConnectedToWifi(context)
+                        || isConnectedToMobileDataWithDifferentSubId(context, subId))) {
             context.startActivity(EuiccRacConnectivityDialogActivity.getIntent(context, subId));
         } else {
             context.startActivity(DeleteEuiccSubscriptionDialogActivity.getIntent(context, subId));
@@ -814,27 +815,75 @@
     }
 
     /**
-     * Returns {@code true} if device is connected to Wi-Fi or mobile data provided by a different
-     * subId.
+     * Checks if the device is connected to Wi-Fi.
+     *
+     * @param context context
+     * @return {@code true} if connected to Wi-Fi
+     */
+    static boolean isConnectedToWifi(@NonNull Context context) {
+        NetworkCapabilities capabilities = getNetworkCapabilities(context);
+
+        return capabilities != null
+                && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
+    }
+
+    /**
+     * Checks if the device is connected to mobile data provided by a different subId.
      *
      * @param context context
      * @param targetSubId subscription that is going to be deleted
+     * @return {@code true} if connected to mobile data provided by a different subId
      */
     @VisibleForTesting
-    static boolean isConnectedToWifiOrDifferentSubId(@NonNull Context context, int targetSubId) {
+    static boolean isConnectedToMobileDataWithDifferentSubId(
+            @NonNull Context context, int targetSubId) {
+        NetworkCapabilities capabilities = getNetworkCapabilities(context);
+
+        return capabilities != null
+                && capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
+                && targetSubId != SubscriptionManager.getActiveDataSubscriptionId();
+    }
+
+    /**
+     * Checks if any subscription carrier use reusable activation codes.
+     *
+     * @param context The context used to retrieve carriers that uses reusable activation codes.
+     * @return {@code true} if any subscription has a matching carrier that uses reusable activation
+     *     codes
+     */
+    static boolean hasSubscriptionWithRacCarrier(@NonNull Context context) {
+        List<SubscriptionInfo> subs = getAvailableSubscriptions(context);
+        final int[] carriersThatUseRac =
+                context.getResources().getIntArray(R.array.config_carrier_use_rac);
+
+        return Arrays.stream(carriersThatUseRac)
+                .anyMatch(cid -> subs.stream().anyMatch(sub -> sub.getCarrierId() == cid));
+    }
+
+    /**
+     * Checks if a carrier use reusable activation codes.
+     *
+     * @param context The context used to retrieve carriers that uses reusable activation codes.
+     * @param carrierId The carrier id to check if it use reusable activation codes.
+     * @return {@code true} if carrier id use reusable activation codes.
+     */
+    @VisibleForTesting
+    static boolean isCarrierRac(@NonNull Context context, int carrierId) {
+        final int[] carriersThatUseRAC =
+                context.getResources().getIntArray(R.array.config_carrier_use_rac);
+
+        return Arrays.stream(carriersThatUseRAC).anyMatch(cid -> cid == carrierId);
+    }
+
+    /**
+     * Retrieves NetworkCapabilities for the active network.
+     *
+     * @param context context
+     * @return NetworkCapabilities or null if not available
+     */
+    private static NetworkCapabilities getNetworkCapabilities(@NonNull Context context) {
         ConnectivityManager connectivityManager =
                 context.getSystemService(ConnectivityManager.class);
-        NetworkCapabilities capabilities =
-                connectivityManager.getNetworkCapabilities(connectivityManager.getActiveNetwork());
-
-        if (capabilities != null) {
-            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
-                // Connected to WiFi
-                return true;
-            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
-                return targetSubId != SubscriptionManager.getActiveDataSubscriptionId();
-            }
-        }
-        return false;
+        return connectivityManager.getNetworkCapabilities(connectivityManager.getActiveNetwork());
     }
 }
diff --git a/src/com/android/settings/network/telephony/DataUsagePreferenceController.kt b/src/com/android/settings/network/telephony/DataUsagePreferenceController.kt
index 240843d..6d326e0 100644
--- a/src/com/android/settings/network/telephony/DataUsagePreferenceController.kt
+++ b/src/com/android/settings/network/telephony/DataUsagePreferenceController.kt
@@ -33,6 +33,7 @@
 import com.android.settings.datausage.lib.DataUsageLib
 import com.android.settings.datausage.lib.NetworkCycleDataRepository
 import com.android.settings.datausage.lib.NetworkStatsRepository.Companion.AllTimeRange
+import com.android.settingslib.spaprivileged.framework.compose.getPlaceholder
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -63,6 +64,7 @@
     }
 
     override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
+        preference.summary = mContext.getPlaceholder()
         viewLifecycleOwner.lifecycleScope.launch {
             viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                 update()
@@ -113,7 +115,6 @@
         }
 
         val allTimeUsage = repository.queryUsage(AllTimeRange)
-        if (allTimeUsage.usage > 0) return allTimeUsage.getDataUsedString(mContext) to true
-        return null to false
+        return allTimeUsage.getDataUsedString(mContext) to (allTimeUsage.usage > 0)
     }
 }
diff --git a/src/com/android/settings/network/telephony/MobileNetworkEidPreferenceController.kt b/src/com/android/settings/network/telephony/MobileNetworkEidPreferenceController.kt
index 907bab1..1e635a5 100644
--- a/src/com/android/settings/network/telephony/MobileNetworkEidPreferenceController.kt
+++ b/src/com/android/settings/network/telephony/MobileNetworkEidPreferenceController.kt
@@ -84,6 +84,13 @@
     }
 
     override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
+        if (!this::lazyViewModel.isInitialized) {
+            Log.e(
+                this.javaClass.simpleName,
+                "lateinit property lazyViewModel has not been initialized"
+            )
+            return
+        }
         preference.isVisible = false
 
         val viewModel by lazyViewModel
diff --git a/src/com/android/settings/network/telephony/MobileNetworkImeiPreferenceController.kt b/src/com/android/settings/network/telephony/MobileNetworkImeiPreferenceController.kt
index 8ec313b..e134681 100644
--- a/src/com/android/settings/network/telephony/MobileNetworkImeiPreferenceController.kt
+++ b/src/com/android/settings/network/telephony/MobileNetworkImeiPreferenceController.kt
@@ -78,6 +78,13 @@
     }
 
     override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
+        if (!this::lazyViewModel.isInitialized) {
+            Log.e(
+                this.javaClass.simpleName,
+                "lateinit property lazyViewModel has not been initialized"
+            )
+            return
+        }
         val viewModel by lazyViewModel
         val coroutineScope = viewLifecycleOwner.lifecycleScope
 
diff --git a/src/com/android/settings/network/telephony/MobileNetworkPhoneNumberPreferenceController.kt b/src/com/android/settings/network/telephony/MobileNetworkPhoneNumberPreferenceController.kt
index 65a4b7e..10a8b53 100644
--- a/src/com/android/settings/network/telephony/MobileNetworkPhoneNumberPreferenceController.kt
+++ b/src/com/android/settings/network/telephony/MobileNetworkPhoneNumberPreferenceController.kt
@@ -19,6 +19,7 @@
 import android.content.Context
 import android.telephony.SubscriptionInfo
 import android.telephony.SubscriptionManager
+import android.util.Log
 import androidx.annotation.VisibleForTesting
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.viewModels
@@ -66,6 +67,13 @@
     }
 
     override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
+        if (!this::lazyViewModel.isInitialized) {
+            Log.e(
+                this.javaClass.simpleName,
+                "lateinit property lazyViewModel has not been initialized"
+            )
+            return
+        }
         val viewModel by lazyViewModel
         val coroutineScope = viewLifecycleOwner.lifecycleScope
 
diff --git a/src/com/android/settings/network/telephony/MobileNetworkSpnPreferenceController.kt b/src/com/android/settings/network/telephony/MobileNetworkSpnPreferenceController.kt
index ac055b0..4736eb7 100644
--- a/src/com/android/settings/network/telephony/MobileNetworkSpnPreferenceController.kt
+++ b/src/com/android/settings/network/telephony/MobileNetworkSpnPreferenceController.kt
@@ -19,6 +19,7 @@
 import android.content.Context
 import android.telephony.SubscriptionInfo
 import android.telephony.SubscriptionManager
+import android.util.Log
 import androidx.annotation.VisibleForTesting
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.viewModels
@@ -26,6 +27,7 @@
 import androidx.preference.Preference
 import androidx.preference.PreferenceScreen
 import com.android.settings.flags.Flags
+import com.android.settings.network.SimOnboardingActivity
 import com.android.settings.network.SubscriptionInfoListViewModel
 import com.android.settingslib.spa.framework.util.collectLatestWithLifecycle
 
@@ -57,6 +59,14 @@
     }
 
     override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
+        if (!this::lazyViewModel.isInitialized) {
+            Log.e(
+                this.javaClass.simpleName,
+                "lateinit property lazyViewModel has not been initialized"
+            )
+            return
+        }
+
         val viewModel by lazyViewModel
 
         viewModel.subscriptionInfoListFlow
diff --git a/src/com/android/settings/network/telephony/MobileNetworkSwitchController.java b/src/com/android/settings/network/telephony/MobileNetworkSwitchController.java
deleted file mode 100644
index 20a3d89..0000000
--- a/src/com/android/settings/network/telephony/MobileNetworkSwitchController.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.network.telephony;
-
-import static android.telephony.TelephonyManager.CALL_STATE_IDLE;
-
-import static androidx.lifecycle.Lifecycle.Event.ON_PAUSE;
-import static androidx.lifecycle.Lifecycle.Event.ON_RESUME;
-
-import android.content.Context;
-import android.telephony.SubscriptionInfo;
-import android.telephony.SubscriptionManager;
-import android.telephony.TelephonyCallback;
-import android.telephony.TelephonyManager;
-
-import androidx.lifecycle.LifecycleObserver;
-import androidx.lifecycle.OnLifecycleEvent;
-import androidx.preference.PreferenceScreen;
-
-import com.android.settings.core.BasePreferenceController;
-import com.android.settings.network.SubscriptionUtil;
-import com.android.settings.network.SubscriptionsChangeListener;
-import com.android.settings.widget.SettingsMainSwitchPreference;
-
-/** This controls a switch to allow enabling/disabling a mobile network */
-public class MobileNetworkSwitchController extends BasePreferenceController implements
-        SubscriptionsChangeListener.SubscriptionsChangeListenerClient, LifecycleObserver {
-    private static final String TAG = "MobileNetworkSwitchCtrl";
-    private SettingsMainSwitchPreference mSwitchBar;
-    private int mSubId;
-    private SubscriptionsChangeListener mChangeListener;
-    private SubscriptionManager mSubscriptionManager;
-    private TelephonyManager mTelephonyManager;
-    private CallStateTelephonyCallback mCallStateCallback;
-
-    public MobileNetworkSwitchController(Context context, String preferenceKey) {
-        super(context, preferenceKey);
-        mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
-        mSubscriptionManager = mContext.getSystemService(SubscriptionManager.class);
-        mTelephonyManager = mContext.getSystemService(TelephonyManager.class);
-        mChangeListener = new SubscriptionsChangeListener(context, this);
-    }
-
-    void init(int subId) {
-        mSubId = subId;
-        mTelephonyManager = mTelephonyManager.createForSubscriptionId(mSubId);
-    }
-
-    @OnLifecycleEvent(ON_RESUME)
-    public void onResume() {
-        mChangeListener.start();
-
-        if (mCallStateCallback == null) {
-            mCallStateCallback = new CallStateTelephonyCallback();
-            mTelephonyManager.registerTelephonyCallback(
-                    mContext.getMainExecutor(), mCallStateCallback);
-        }
-        update();
-    }
-
-    @OnLifecycleEvent(ON_PAUSE)
-    public void onPause() {
-        if (mCallStateCallback != null) {
-            mTelephonyManager.unregisterTelephonyCallback(mCallStateCallback);
-            mCallStateCallback = null;
-        }
-        mChangeListener.stop();
-    }
-
-    @Override
-    public void displayPreference(PreferenceScreen screen) {
-        super.displayPreference(screen);
-        mSwitchBar = (SettingsMainSwitchPreference) screen.findPreference(mPreferenceKey);
-
-        mSwitchBar.setOnBeforeCheckedChangeListener((isChecked) -> {
-            // TODO b/135222940: re-evaluate whether to use
-            // mSubscriptionManager#isSubscriptionEnabled
-            if (mSubscriptionManager.isActiveSubscriptionId(mSubId) != isChecked) {
-                SubscriptionUtil.startToggleSubscriptionDialogActivity(mContext, mSubId, isChecked);
-                return true;
-            }
-            return false;
-        });
-        update();
-    }
-
-    private void update() {
-        if (mSwitchBar == null) {
-            return;
-        }
-
-        SubscriptionInfo subInfo = null;
-        for (SubscriptionInfo info : SubscriptionUtil.getAvailableSubscriptions(mContext)) {
-            if (info.getSubscriptionId() == mSubId) {
-                subInfo = info;
-                break;
-            }
-        }
-
-        // For eSIM, we always want the toggle. If telephony stack support disabling a pSIM
-        // directly, we show the toggle.
-        if (subInfo == null || (!subInfo.isEmbedded() && !SubscriptionUtil.showToggleForPhysicalSim(
-                mSubscriptionManager))) {
-            mSwitchBar.hide();
-        } else {
-            mSwitchBar.show();
-            mSwitchBar.setCheckedInternal(mSubscriptionManager.isActiveSubscriptionId(mSubId));
-        }
-    }
-
-    @Override
-    public int getAvailabilityStatus() {
-        return AVAILABLE_UNSEARCHABLE;
-
-    }
-
-    @Override
-    public void onAirplaneModeChanged(boolean airplaneModeEnabled) {
-    }
-
-    @Override
-    public void onSubscriptionsChanged() {
-        update();
-    }
-
-    private class CallStateTelephonyCallback extends TelephonyCallback implements
-            TelephonyCallback.CallStateListener {
-        @Override
-        public void onCallStateChanged(int state) {
-            mSwitchBar.setSwitchBarEnabled(state == CALL_STATE_IDLE);
-        }
-    }
-}
diff --git a/src/com/android/settings/network/telephony/MobileNetworkSwitchController.kt b/src/com/android/settings/network/telephony/MobileNetworkSwitchController.kt
new file mode 100644
index 0000000..dcac74f
--- /dev/null
+++ b/src/com/android/settings/network/telephony/MobileNetworkSwitchController.kt
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.network.telephony
+
+import android.content.Context
+import android.telephony.SubscriptionManager
+import android.telephony.TelephonyManager
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.android.settings.R
+import com.android.settings.network.SubscriptionUtil
+import com.android.settings.spa.preference.ComposePreferenceController
+import com.android.settingslib.spa.widget.preference.MainSwitchPreference
+import com.android.settingslib.spa.widget.preference.SwitchPreferenceModel
+import kotlinx.coroutines.flow.map
+
+class MobileNetworkSwitchController @JvmOverloads constructor(
+    context: Context,
+    preferenceKey: String,
+    private val subscriptionRepository: SubscriptionRepository = SubscriptionRepository(context),
+) : ComposePreferenceController(context, preferenceKey) {
+
+    private var subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID
+
+    override fun getAvailabilityStatus() = AVAILABLE_UNSEARCHABLE
+
+    fun init(subId: Int) {
+        this.subId = subId
+    }
+
+    @Composable
+    override fun Content() {
+        val context = LocalContext.current
+        if (remember { !context.isVisible() }) return
+        val checked by remember {
+            subscriptionRepository.isSubscriptionEnabledFlow(subId)
+        }.collectAsStateWithLifecycle(initialValue = null)
+        val changeable by remember {
+            context.callStateFlow(subId).map { it == TelephonyManager.CALL_STATE_IDLE }
+        }.collectAsStateWithLifecycle(initialValue = true)
+        MainSwitchPreference(model = object : SwitchPreferenceModel {
+            override val title = stringResource(R.string.mobile_network_use_sim_on)
+            override val changeable = { changeable }
+            override val checked = { checked }
+            override val onCheckedChange = { newChecked: Boolean ->
+                SubscriptionUtil.startToggleSubscriptionDialogActivity(mContext, subId, newChecked)
+            }
+        })
+    }
+
+    private fun Context.isVisible(): Boolean {
+        val subInfo = subscriptionRepository.getSelectableSubscriptionInfoList()
+            .firstOrNull { it.subscriptionId == subId }
+            ?: return false
+        // For eSIM, we always want the toggle. If telephony stack support disabling a pSIM
+        // directly, we show the toggle.
+        return subInfo.isEmbedded || requireSubscriptionManager().canDisablePhysicalSubscription()
+    }
+}
diff --git a/src/com/android/settings/network/telephony/MobileNetworkUtils.java b/src/com/android/settings/network/telephony/MobileNetworkUtils.java
index 8a63505..0407b6a 100644
--- a/src/com/android/settings/network/telephony/MobileNetworkUtils.java
+++ b/src/com/android/settings/network/telephony/MobileNetworkUtils.java
@@ -308,7 +308,7 @@
     public static Boolean showEuiccSettingsDetecting(Context context) {
         final EuiccManager euiccManager =
                 (EuiccManager) context.getSystemService(EuiccManager.class);
-        if (!euiccManager.isEnabled()) {
+        if (euiccManager == null || !euiccManager.isEnabled()) {
             Log.w(TAG, "EuiccManager is not enabled.");
             return false;
         }
diff --git a/src/com/android/settings/network/telephony/NetworkSelectRepository.kt b/src/com/android/settings/network/telephony/NetworkSelectRepository.kt
new file mode 100644
index 0000000..1f5fbc2
--- /dev/null
+++ b/src/com/android/settings/network/telephony/NetworkSelectRepository.kt
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.network.telephony
+
+import android.content.Context
+import android.telephony.AccessNetworkConstants
+import android.telephony.NetworkRegistrationInfo
+import android.telephony.TelephonyManager
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class NetworkSelectRepository(context: Context, subId: Int) {
+    private val telephonyManager =
+        context.getSystemService(TelephonyManager::class.java)!!.createForSubscriptionId(subId)
+
+    data class NetworkRegistrationAndForbiddenInfo(
+        val networkList: List<NetworkRegistrationInfo>,
+        val forbiddenPlmns: List<String>,
+    )
+
+    /** TODO: Move this to UI layer, when UI layer migrated to Kotlin. */
+    fun launchUpdateNetworkRegistrationInfo(
+        lifecycleOwner: LifecycleOwner,
+        action: (NetworkRegistrationAndForbiddenInfo) -> Unit,
+    ) {
+        lifecycleOwner.lifecycleScope.launch {
+            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                withContext(Dispatchers.Default) {
+                    getNetworkRegistrationInfo()
+                }?.let(action)
+            }
+        }
+    }
+
+    fun getNetworkRegistrationInfo(): NetworkRegistrationAndForbiddenInfo? {
+        if (telephonyManager.dataState != TelephonyManager.DATA_CONNECTED) return null
+        // Try to get the network registration states
+        val serviceState = telephonyManager.serviceState ?: return null
+        val networkList = serviceState.getNetworkRegistrationInfoListForTransportType(
+            AccessNetworkConstants.TRANSPORT_TYPE_WWAN
+        )
+        if (networkList.isEmpty()) return null
+        // Due to the aggregation of cell between carriers, it's possible to get CellIdentity
+        // containing forbidden PLMN.
+        // Getting current network from ServiceState is no longer a good idea.
+        // Add an additional rule to avoid from showing forbidden PLMN to the user.
+        return NetworkRegistrationAndForbiddenInfo(networkList, getForbiddenPlmns())
+    }
+
+    /**
+     * Update forbidden PLMNs from the USIM App
+     */
+    private fun getForbiddenPlmns(): List<String> {
+        return telephonyManager.forbiddenPlmns?.toList() ?: emptyList()
+    }
+}
diff --git a/src/com/android/settings/network/telephony/NetworkSelectSettings.java b/src/com/android/settings/network/telephony/NetworkSelectSettings.java
index eb89d9e..19bc390 100644
--- a/src/com/android/settings/network/telephony/NetworkSelectSettings.java
+++ b/src/com/android/settings/network/telephony/NetworkSelectSettings.java
@@ -24,12 +24,10 @@
 import android.os.Message;
 import android.os.PersistableBundle;
 import android.provider.Settings;
-import android.telephony.AccessNetworkConstants;
 import android.telephony.CarrierConfigManager;
 import android.telephony.CellIdentity;
 import android.telephony.CellInfo;
 import android.telephony.NetworkRegistrationInfo;
-import android.telephony.ServiceState;
 import android.telephony.SignalStrength;
 import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
@@ -52,13 +50,11 @@
 import com.android.settings.network.telephony.scan.NetworkScanRepository.NetworkScanCellInfos;
 import com.android.settings.network.telephony.scan.NetworkScanRepository.NetworkScanComplete;
 import com.android.settings.network.telephony.scan.NetworkScanRepository.NetworkScanError;
-import com.android.settings.network.telephony.scan.NetworkScanRepository.NetworkScanResult;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
 import com.android.settingslib.utils.ThreadUtils;
 
 import kotlin.Unit;
-import kotlin.jvm.functions.Function1;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -101,6 +97,8 @@
     private NetworkScanRepository mNetworkScanRepository;
     private boolean mUpdateScanResult = false;
 
+    private NetworkSelectRepository mNetworkSelectRepository;
+
     @Override
     public void onCreate(Bundle icicle) {
         super.onCreate(icicle);
@@ -138,6 +136,7 @@
         mCarrierConfigManager.registerCarrierConfigChangeListener(mNetworkScanExecutor,
                 mCarrierConfigChangeListener);
         mNetworkScanRepository = new NetworkScanRepository(context, mSubId);
+        mNetworkSelectRepository = new NetworkSelectRepository(context, mSubId);
     }
 
     @Keep
@@ -202,35 +201,37 @@
         mProgressHeader = setPinnedHeaderView(
                 com.android.settingslib.widget.progressbar.R.layout.progress_header
         ).findViewById(com.android.settingslib.widget.progressbar.R.id.progress_bar_animation);
-        forceUpdateConnectedPreferenceCategory();
+        mNetworkSelectRepository.launchUpdateNetworkRegistrationInfo(
+                getViewLifecycleOwner(),
+                (info) -> {
+                    forceUpdateConnectedPreferenceCategory(info);
+                    return Unit.INSTANCE;
+                });
         launchNetworkScan();
     }
 
     private void launchNetworkScan() {
-        mNetworkScanRepository.launchNetworkScan(getViewLifecycleOwner(), new Function1<>() {
-            @Override
-            public Unit invoke(@NonNull NetworkScanResult networkScanResult) {
-                if (!mUpdateScanResult) {
-                    // Not update UI if not in scan mode.
-                    return Unit.INSTANCE;
-                }
-                if (networkScanResult instanceof NetworkScanCellInfos networkScanCellInfos) {
-                    scanResultHandler(networkScanCellInfos.getCellInfos());
-                    return Unit.INSTANCE;
-                }
-                if (!isPreferenceScreenEnabled()) {
-                    clearPreferenceSummary();
-                    enablePreferenceScreen(true);
-                } else if (networkScanResult instanceof NetworkScanComplete
-                        && mCellInfoList == null) {
-                    // In case the scan timeout before getting any results
-                    addMessagePreference(R.string.empty_networks_list);
-                } else if (networkScanResult instanceof NetworkScanError) {
-                    addMessagePreference(R.string.network_query_error);
-                }
-
+        mNetworkScanRepository.launchNetworkScan(getViewLifecycleOwner(), (networkScanResult) -> {
+            if (!mUpdateScanResult) {
+                // Not update UI if not in scan mode.
                 return Unit.INSTANCE;
             }
+            if (networkScanResult instanceof NetworkScanCellInfos networkScanCellInfos) {
+                scanResultHandler(networkScanCellInfos.getCellInfos());
+                return Unit.INSTANCE;
+            }
+            if (!isPreferenceScreenEnabled()) {
+                clearPreferenceSummary();
+                enablePreferenceScreen(true);
+            } else if (networkScanResult instanceof NetworkScanComplete
+                    && mCellInfoList == null) {
+                // In case the scan timeout before getting any results
+                addMessagePreference(R.string.empty_networks_list);
+            } else if (networkScanResult instanceof NetworkScanError) {
+                addMessagePreference(R.string.network_query_error);
+            }
+
+            return Unit.INSTANCE;
         });
     }
 
@@ -238,7 +239,6 @@
     public void onStart() {
         super.onStart();
 
-        updateForbiddenPlmns();
         setProgressBarVisible(true);
         mUpdateScanResult = true;
     }
@@ -477,45 +477,26 @@
      * - If the device has no data, we will remove the connected network operators list from the
      * screen.
      */
-    private void forceUpdateConnectedPreferenceCategory() {
-        if (mTelephonyManager.getDataState() == mTelephonyManager.DATA_CONNECTED) {
-            // Try to get the network registration states
-            final ServiceState ss = mTelephonyManager.getServiceState();
-            if (ss == null) {
-                return;
+    private void forceUpdateConnectedPreferenceCategory(
+            NetworkSelectRepository.NetworkRegistrationAndForbiddenInfo info) {
+        for (NetworkRegistrationInfo regInfo : info.getNetworkList()) {
+            final CellIdentity cellIdentity = regInfo.getCellIdentity();
+            if (cellIdentity == null) {
+                continue;
             }
-            final List<NetworkRegistrationInfo> networkList =
-                    ss.getNetworkRegistrationInfoListForTransportType(
-                            AccessNetworkConstants.TRANSPORT_TYPE_WWAN);
-            if (networkList == null || networkList.size() == 0) {
-                return;
+            final NetworkOperatorPreference pref = new NetworkOperatorPreference(
+                    getPrefContext(), info.getForbiddenPlmns(), mShow4GForLTE);
+            pref.updateCell(null, cellIdentity);
+            if (pref.isForbiddenNetwork()) {
+                continue;
             }
-            // Due to the aggregation of cell between carriers, it's possible to get CellIdentity
-            // containing forbidden PLMN.
-            // Getting current network from ServiceState is no longer a good idea.
-            // Add an additional rule to avoid from showing forbidden PLMN to the user.
-            if (mForbiddenPlmns == null) {
-                updateForbiddenPlmns();
-            }
-            for (NetworkRegistrationInfo regInfo : networkList) {
-                final CellIdentity cellIdentity = regInfo.getCellIdentity();
-                if (cellIdentity == null) {
-                    continue;
-                }
-                final NetworkOperatorPreference pref = new NetworkOperatorPreference(
-                        getPrefContext(), mForbiddenPlmns, mShow4GForLTE);
-                pref.updateCell(null, cellIdentity);
-                if (pref.isForbiddenNetwork()) {
-                    continue;
-                }
-                pref.setSummary(R.string.network_connected);
-                // Update the signal strength icon, since the default signalStrength value
-                // would be zero
-                // (it would be quite confusing why the connected network has no signal)
-                pref.setIcon(SignalStrength.NUM_SIGNAL_STRENGTH_BINS - 1);
-                mPreferenceCategory.addPreference(pref);
-                break;
-            }
+            pref.setSummary(R.string.network_connected);
+            // Update the signal strength icon, since the default signalStrength value
+            // would be zero
+            // (it would be quite confusing why the connected network has no signal)
+            pref.setIcon(SignalStrength.NUM_SIGNAL_STRENGTH_BINS - 1);
+            mPreferenceCategory.addPreference(pref);
+            break;
         }
     }
 
diff --git a/src/com/android/settings/network/telephony/SubscriptionRepository.kt b/src/com/android/settings/network/telephony/SubscriptionRepository.kt
index 1820df9..b0a39ec 100644
--- a/src/com/android/settings/network/telephony/SubscriptionRepository.kt
+++ b/src/com/android/settings/network/telephony/SubscriptionRepository.kt
@@ -26,12 +26,25 @@
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.filterNot
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 
 private const val TAG = "SubscriptionRepository"
 
+class SubscriptionRepository(private val context: Context) {
+    /**
+     * Return a list of subscriptions that are available and visible to the user.
+     *
+     * @return list of user selectable subscriptions.
+     */
+    fun getSelectableSubscriptionInfoList(): List<SubscriptionInfo> =
+        context.getSelectableSubscriptionInfoList()
+
+    fun isSubscriptionEnabledFlow(subId: Int) = context.isSubscriptionEnabledFlow(subId)
+}
+
 val Context.subscriptionManager: SubscriptionManager?
     get() = getSystemService(SubscriptionManager::class.java)
 
@@ -43,7 +56,7 @@
 
 fun Context.phoneNumberFlow(subscriptionInfo: SubscriptionInfo) = subscriptionsChangedFlow().map {
     SubscriptionUtil.getFormattedPhoneNumber(this, subscriptionInfo)
-}.flowOn(Dispatchers.Default)
+}.filterNot { it.isNullOrEmpty() }.flowOn(Dispatchers.Default)
 
 fun Context.subscriptionsChangedFlow() = callbackFlow {
     val subscriptionManager = requireSubscriptionManager()
diff --git a/src/com/android/settings/network/telephony/WifiCallingPreferenceController.kt b/src/com/android/settings/network/telephony/WifiCallingPreferenceController.kt
index 0ee1d87..f184092 100644
--- a/src/com/android/settings/network/telephony/WifiCallingPreferenceController.kt
+++ b/src/com/android/settings/network/telephony/WifiCallingPreferenceController.kt
@@ -22,6 +22,7 @@
 import android.telephony.SubscriptionManager
 import android.telephony.TelephonyManager
 import android.telephony.ims.ImsMmTelManager
+import android.util.Log
 import androidx.lifecycle.LifecycleOwner
 import androidx.preference.Preference
 import androidx.preference.PreferenceScreen
@@ -76,6 +77,13 @@
     }
 
     override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
+        if(mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID){
+            Log.e(
+                this.javaClass.simpleName,
+                "mSubId is INVALID_SUBSCRIPTION_ID"
+            )
+            return
+        }
         wifiCallingRepositoryFactory(mSubId).wifiCallingReadyFlow()
             .collectLatestWithLifecycle(viewLifecycleOwner) { isReady ->
                 preference.isVisible = isReady
diff --git a/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.kt b/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.kt
index d709574..67a2356 100644
--- a/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.kt
+++ b/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.kt
@@ -23,6 +23,7 @@
 import android.provider.Settings
 import android.telephony.CarrierConfigManager
 import android.telephony.ServiceState
+import android.telephony.SubscriptionManager
 import android.telephony.TelephonyManager
 import androidx.annotation.VisibleForTesting
 import androidx.compose.runtime.Composable
@@ -80,7 +81,7 @@
     @VisibleForTesting
     var progressDialog: ProgressDialog? = null
 
-    private var subId by notNull<Int>()
+    private var subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID
 
     /**
      * Initialization based on given subscription id.
diff --git a/src/com/android/settings/notification/app/BubblePreference.java b/src/com/android/settings/notification/app/BubblePreference.java
index ab5fc39..29d6d30 100644
--- a/src/com/android/settings/notification/app/BubblePreference.java
+++ b/src/com/android/settings/notification/app/BubblePreference.java
@@ -21,34 +21,27 @@
 import static android.app.NotificationManager.BUBBLE_PREFERENCE_SELECTED;
 
 import android.content.Context;
-import android.content.res.ColorStateList;
 import android.util.AttributeSet;
 import android.view.View;
-import android.widget.ImageView;
-import android.widget.TextView;
+import android.widget.RadioButton;
+import android.widget.RadioGroup;
 
+import androidx.annotation.NonNull;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceViewHolder;
 
 import com.android.settings.R;
-import com.android.settings.Utils;
 import com.android.settingslib.RestrictedLockUtils;
 import com.android.settingslib.RestrictedPreferenceHelper;
 
 /**
  * A tri-state preference allowing a user to specify what gets to bubble.
  */
-public class BubblePreference extends Preference implements View.OnClickListener {
+public class BubblePreference extends Preference implements RadioGroup.OnCheckedChangeListener {
     RestrictedPreferenceHelper mHelper;
 
     private int mSelectedPreference;
 
-    private Context mContext;
-
-    private ButtonViewHolder mBubbleAllButton;
-    private ButtonViewHolder mBubbleSelectedButton;
-    private ButtonViewHolder mBubbleNoneButton;
-
     private boolean mSelectedVisible;
 
     public BubblePreference(Context context) {
@@ -64,16 +57,16 @@
     }
 
     public BubblePreference(Context context, AttributeSet attrs,
-            int defStyleAttr, int defStyleRes) {
+                            int defStyleAttr, int defStyleRes) {
         super(context, attrs, defStyleAttr, defStyleRes);
         mHelper = new RestrictedPreferenceHelper(context, this, attrs);
         mHelper.useAdminDisabledSummary(true);
-        mContext = context;
         setLayoutResource(R.layout.bubble_preference);
     }
 
     public void setSelectedPreference(int preference) {
         mSelectedPreference = preference;
+        notifyChanged();
     }
 
     public int getSelectedPreference() {
@@ -92,9 +85,8 @@
     }
 
     @Override
-    public void onBindViewHolder(final PreferenceViewHolder holder) {
+    public void onBindViewHolder(@NonNull final PreferenceViewHolder holder) {
         super.onBindViewHolder(holder);
-
         final boolean disabledByAdmin = mHelper.isDisabledByAdmin();
         View summary = holder.findViewById(android.R.id.summary);
         if (disabledByAdmin) {
@@ -105,74 +97,34 @@
         }
         holder.itemView.setClickable(false);
 
-        View bubbleAll = holder.findViewById(R.id.bubble_all);
-        ImageView bubbleAllImage = (ImageView) holder.findViewById(R.id.bubble_all_icon);
-        TextView bubbleAllText = (TextView) holder.findViewById(R.id.bubble_all_label);
-        mBubbleAllButton = new ButtonViewHolder(bubbleAll, bubbleAllImage, bubbleAllText,
-                BUBBLE_PREFERENCE_ALL);
-        mBubbleAllButton.setSelected(mContext, mSelectedPreference == BUBBLE_PREFERENCE_ALL);
-        bubbleAll.setTag(BUBBLE_PREFERENCE_ALL);
-        bubbleAll.setOnClickListener(this);
-        bubbleAll.setVisibility(disabledByAdmin ? View.GONE : View.VISIBLE);
+        RadioButton bubbleAllButton = (RadioButton) holder.findViewById(R.id.bubble_all);
+        bubbleAllButton.setChecked(mSelectedPreference == BUBBLE_PREFERENCE_ALL);
+        bubbleAllButton.setTag(BUBBLE_PREFERENCE_ALL);
+        bubbleAllButton.setVisibility(disabledByAdmin ? View.GONE : View.VISIBLE);
 
-        View bubbleSelected = holder.findViewById(R.id.bubble_selected);
-        ImageView bubbleSelectedImage = (ImageView) holder.findViewById(R.id.bubble_selected_icon);
-        TextView bubbleSelectedText = (TextView) holder.findViewById(R.id.bubble_selected_label);
-        mBubbleSelectedButton = new ButtonViewHolder(bubbleSelected, bubbleSelectedImage,
-                bubbleSelectedText, BUBBLE_PREFERENCE_SELECTED);
-        mBubbleSelectedButton.setSelected(mContext,
-                mSelectedPreference == BUBBLE_PREFERENCE_SELECTED);
-        bubbleSelected.setTag(BUBBLE_PREFERENCE_SELECTED);
-        bubbleSelected.setOnClickListener(this);
-        bubbleSelected.setVisibility((!mSelectedVisible || disabledByAdmin)
-                ? View.GONE : View.VISIBLE);
+        RadioButton bubbleSelectedButton = (RadioButton) holder.findViewById(R.id.bubble_selected);
+        bubbleSelectedButton.setChecked(mSelectedPreference == BUBBLE_PREFERENCE_SELECTED);
+        bubbleSelectedButton.setTag(BUBBLE_PREFERENCE_SELECTED);
+        int selectedButtonVisibility =
+                (!mSelectedVisible || disabledByAdmin) ? View.GONE : View.VISIBLE;
+        bubbleSelectedButton.setVisibility(selectedButtonVisibility);
 
-        View bubbleNone = holder.findViewById(R.id.bubble_none);
-        ImageView bubbleNoneImage = (ImageView) holder.findViewById(R.id.bubble_none_icon);
-        TextView bubbleNoneText = (TextView) holder.findViewById(R.id.bubble_none_label);
-        mBubbleNoneButton = new ButtonViewHolder(bubbleNone, bubbleNoneImage, bubbleNoneText,
-                BUBBLE_PREFERENCE_NONE);
-        mBubbleNoneButton.setSelected(mContext, mSelectedPreference == BUBBLE_PREFERENCE_NONE);
-        bubbleNone.setTag(BUBBLE_PREFERENCE_NONE);
-        bubbleNone.setOnClickListener(this);
-        bubbleNone.setVisibility(disabledByAdmin ? View.GONE : View.VISIBLE);
+        RadioButton bubbleNoneButton = (RadioButton) holder.findViewById(R.id.bubble_none);
+        bubbleNoneButton.setChecked(mSelectedPreference == BUBBLE_PREFERENCE_NONE);
+        bubbleNoneButton.setTag(BUBBLE_PREFERENCE_NONE);
+        bubbleNoneButton.setVisibility(disabledByAdmin ? View.GONE : View.VISIBLE);
+
+        RadioGroup bublesRadioGroup = (RadioGroup) holder.findViewById(R.id.radio_group);
+        bublesRadioGroup.setOnCheckedChangeListener(this);
     }
 
     @Override
-    public void onClick(View v) {
-        final int selected = (int) v.getTag();
-        callChangeListener(selected);
-
-        mBubbleAllButton.setSelected(mContext, selected == BUBBLE_PREFERENCE_ALL);
-        mBubbleSelectedButton.setSelected(mContext, selected == BUBBLE_PREFERENCE_SELECTED);
-        mBubbleNoneButton.setSelected(mContext, selected == BUBBLE_PREFERENCE_NONE);
-    }
-
-    private class ButtonViewHolder {
-        private View mView;
-        private ImageView mImageView;
-        private TextView mTextView;
-        private int mId;
-
-        ButtonViewHolder(View v, ImageView iv, TextView tv, int identifier) {
-            mView = v;
-            mImageView = iv;
-            mTextView = tv;
-            mId = identifier;
+    public void onCheckedChanged(@NonNull RadioGroup group, int checkedId) {
+        View v = group.findViewById(checkedId);
+        if (v == null || v.getTag() == null) {
+            return;
         }
-
-        void setSelected(Context context, boolean selected) {
-            mView.setBackground(mContext.getDrawable(selected
-                ? R.drawable.notification_importance_button_background_selected
-                : R.drawable.notification_importance_button_background_unselected));
-            mView.setSelected(selected);
-
-            int colorResId = selected
-                    ? R.attr.notification_importance_button_foreground_color_selected
-                    : R.attr.notification_importance_button_foreground_color_unselected;
-            ColorStateList stateList = Utils.getColorAttr(context, colorResId);
-            mImageView.setImageTintList(stateList);
-            mTextView.setTextColor(stateList);
-        }
+        int selectedTag = (int) v.getTag();
+        callChangeListener(selectedTag);
     }
 }
diff --git a/src/com/android/settings/privatespace/HidePrivateSpaceController.java b/src/com/android/settings/privatespace/HidePrivateSpaceController.java
index 903defa..81814ad 100644
--- a/src/com/android/settings/privatespace/HidePrivateSpaceController.java
+++ b/src/com/android/settings/privatespace/HidePrivateSpaceController.java
@@ -19,13 +19,21 @@
 import static com.android.settings.privatespace.PrivateSpaceMaintainer.HIDE_PRIVATE_SPACE_ENTRY_POINT_DISABLED_VAL;
 import static com.android.settings.privatespace.PrivateSpaceMaintainer.HIDE_PRIVATE_SPACE_ENTRY_POINT_ENABLED_VAL;
 
+import android.app.AlertDialog;
 import android.content.Context;
+import android.content.DialogInterface;
 
+import com.android.settings.R;
 import com.android.settings.core.TogglePreferenceController;
 
 /**
- *  A class that is used to show details page for the setting to hide private space entry point
- *  in All Apps.
+ * Toggle Preference Controller responsible for managing the visibility of private space entry point
+ * in the "All Apps" section. This includes:
+ *
+ * <p>Toggling the entry point's visibility (hiding/unhiding)
+ *
+ * <p>Displaying a dialog to inform the user that the entry point will be hidden when private space
+ * is locked (if the hide option is enabled)
  */
 public class HidePrivateSpaceController extends TogglePreferenceController {
     private final PrivateSpaceMaintainer mPrivateSpaceMaintainer;
@@ -39,7 +47,7 @@
     @AvailabilityStatus
     public int getAvailabilityStatus() {
         return android.os.Flags.allowPrivateProfile()
-                && android.multiuser.Flags.enablePrivateSpaceFeatures()
+                        && android.multiuser.Flags.enablePrivateSpaceFeatures()
                 ? AVAILABLE
                 : UNSUPPORTED_ON_DEVICE;
     }
@@ -55,6 +63,9 @@
         mPrivateSpaceMaintainer.setHidePrivateSpaceEntryPointSetting(
                 isChecked ? HIDE_PRIVATE_SPACE_ENTRY_POINT_ENABLED_VAL
                         : HIDE_PRIVATE_SPACE_ENTRY_POINT_DISABLED_VAL);
+        if (isChecked) {
+            showAlertDialog();
+        }
         return true;
     }
 
@@ -62,4 +73,16 @@
     public int getSliceHighlightMenuRes() {
         return 0;
     }
+
+    private void showAlertDialog() {
+        new AlertDialog.Builder(mContext)
+                .setTitle(R.string.private_space_hide_dialog_title)
+                .setMessage(R.string.private_space_hide_dialog_message)
+                .setPositiveButton(
+                        R.string.private_space_hide_dialog_button,
+                        (DialogInterface dialog, int which) -> {
+                            dialog.dismiss();
+                        })
+                .show();
+    }
 }
diff --git a/src/com/android/settings/privatespace/PrivateSpaceGaiaEducationFragment.java b/src/com/android/settings/privatespace/PrivateSpaceGaiaEducationFragment.java
index 0fa0483..6c26186 100644
--- a/src/com/android/settings/privatespace/PrivateSpaceGaiaEducationFragment.java
+++ b/src/com/android/settings/privatespace/PrivateSpaceGaiaEducationFragment.java
@@ -46,7 +46,8 @@
 
     @Override
     public void onCreate(@Nullable Bundle savedInstanceState) {
-        if (android.os.Flags.allowPrivateProfile()) {
+        if (android.os.Flags.allowPrivateProfile()
+                && android.multiuser.Flags.enablePrivateSpaceFeatures()) {
             super.onCreate(savedInstanceState);
         }
     }
diff --git a/src/com/android/settings/security/ContentProtectionPreferenceUtils.java b/src/com/android/settings/security/ContentProtectionPreferenceUtils.java
index d84d7c5..b1167ea 100644
--- a/src/com/android/settings/security/ContentProtectionPreferenceUtils.java
+++ b/src/com/android/settings/security/ContentProtectionPreferenceUtils.java
@@ -15,15 +15,23 @@
  */
 package com.android.settings.security;
 
+import static android.view.contentprotection.flags.Flags.manageDevicePolicyEnabled;
+
 import static com.android.internal.R.string.config_defaultContentProtectionService;
 
+import android.app.admin.DevicePolicyManager;
 import android.content.ComponentName;
 import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.UserHandle;
+import android.os.UserManager;
 import android.provider.DeviceConfig;
 import android.view.contentcapture.ContentCaptureManager;
 
-import androidx.annotation.Nullable;
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.android.settings.Utils;
 
 /** Util class for content protection preference. */
 public class ContentProtectionPreferenceUtils {
@@ -60,4 +68,49 @@
                 ContentCaptureManager.DEVICE_CONFIG_PROPERTY_ENABLE_CONTENT_PROTECTION_RECEIVER,
                 ContentCaptureManager.DEFAULT_ENABLE_CONTENT_PROTECTION_RECEIVER);
     }
+
+    /** Returns the managed profile or null if none exists. */
+    @Nullable
+    public static UserHandle getManagedProfile(@NonNull Context context) {
+        UserManager userManager = context.getSystemService(UserManager.class);
+        if (userManager == null) {
+            return null;
+        }
+        return Utils.getManagedProfile(userManager);
+    }
+
+    /** Returns the current content protection policy. */
+    @DevicePolicyManager.ContentProtectionPolicy
+    public static int getContentProtectionPolicy(
+            @NonNull Context context, @Nullable UserHandle managedProfile) {
+        if (!manageDevicePolicyEnabled()) {
+            return DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+        }
+        Context policyContext = createContentProtectionPolicyContext(context, managedProfile);
+        return getContentProtectionPolicyWithGivenContext(policyContext);
+    }
+
+    @NonNull
+    private static Context createContentProtectionPolicyContext(
+            @NonNull Context context, @Nullable UserHandle managedProfile) {
+        if (managedProfile == null) {
+            return context;
+        }
+        try {
+            return context.createPackageContextAsUser(
+                    context.getPackageName(), /* flags= */ 0, managedProfile);
+        } catch (PackageManager.NameNotFoundException ex) {
+            throw new IllegalStateException(ex);
+        }
+    }
+
+    @DevicePolicyManager.ContentProtectionPolicy
+    private static int getContentProtectionPolicyWithGivenContext(@NonNull Context context) {
+        DevicePolicyManager devicePolicyManager =
+                context.getSystemService(DevicePolicyManager.class);
+        if (devicePolicyManager == null) {
+            return DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+        }
+        return devicePolicyManager.getContentProtectionPolicy(/* admin= */ null);
+    }
 }
diff --git a/src/com/android/settings/security/ContentProtectionTogglePreferenceController.java b/src/com/android/settings/security/ContentProtectionTogglePreferenceController.java
index 101364b..9203d61 100644
--- a/src/com/android/settings/security/ContentProtectionTogglePreferenceController.java
+++ b/src/com/android/settings/security/ContentProtectionTogglePreferenceController.java
@@ -15,12 +15,17 @@
  */
 package com.android.settings.security;
 
+import static android.view.contentprotection.flags.Flags.manageDevicePolicyEnabled;
+
+import android.app.admin.DevicePolicyManager;
 import android.content.ContentResolver;
 import android.content.Context;
+import android.os.UserHandle;
 import android.provider.Settings;
 import android.widget.CompoundButton;
 import android.widget.CompoundButton.OnCheckedChangeListener;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import androidx.preference.Preference;
@@ -40,12 +45,22 @@
     static final String KEY_CONTENT_PROTECTION_PREFERENCE = "content_protection_user_consent";
 
     @Nullable private SettingsMainSwitchPreference mSwitchBar;
+
     @Nullable private RestrictedLockUtils.EnforcedAdmin mEnforcedAdmin;
-    private final ContentResolver mContentResolver;
+
+    @NonNull private final ContentResolver mContentResolver;
+
+    @DevicePolicyManager.ContentProtectionPolicy
+    private int mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
 
     public ContentProtectionTogglePreferenceController(Context context, String preferenceKey) {
         super(context, preferenceKey);
         mContentResolver = context.getContentResolver();
+
+        if (manageDevicePolicyEnabled()) {
+            mEnforcedAdmin = getEnforcedAdmin();
+            mContentProtectionPolicy = getContentProtectionPolicy(getManagedProfile());
+        }
     }
 
     @Override
@@ -56,14 +71,30 @@
     @Override
     public boolean isChecked() {
         if (mEnforcedAdmin != null) {
-            // If fully managed device, it should always unchecked
-            return false;
+            if (!manageDevicePolicyEnabled()) {
+                // If fully managed device, it should always unchecked
+                return false;
+            }
+
+            if (mContentProtectionPolicy == DevicePolicyManager.CONTENT_PROTECTION_DISABLED) {
+                return false;
+            }
+            if (mContentProtectionPolicy == DevicePolicyManager.CONTENT_PROTECTION_ENABLED) {
+                return true;
+            }
         }
         return Settings.Global.getInt(mContentResolver, KEY_CONTENT_PROTECTION_PREFERENCE, 0) >= 0;
     }
 
     @Override
     public boolean setChecked(boolean isChecked) {
+        if (manageDevicePolicyEnabled()) {
+            if (mEnforcedAdmin != null
+                    && mContentProtectionPolicy
+                            != DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY) {
+                return false;
+            }
+        }
         Settings.Global.putInt(
                 mContentResolver, KEY_CONTENT_PROTECTION_PREFERENCE, isChecked ? 1 : -1);
         return true;
@@ -80,16 +111,20 @@
         }
     }
 
-    /**
-     * Temporary workaround for SettingsMainSwitchPreference.setDisabledByAdmin without user
-     * restriction.
-     */
+    // Workaround for SettingsMainSwitchPreference.setDisabledByAdmin without user restriction.
     @Override
     public void updateState(Preference preference) {
         super.updateState(preference);
-        // Assign the value to mEnforcedAdmin since it's needed in isChecked()
-        mEnforcedAdmin = getEnforcedAdmin();
-        if (mSwitchBar != null && mEnforcedAdmin != null) {
+
+        if (!manageDevicePolicyEnabled()) {
+            // Assign the value to mEnforcedAdmin since it's needed in isChecked()
+            mEnforcedAdmin = getEnforcedAdmin();
+            mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+        }
+        if (mSwitchBar != null
+                && mEnforcedAdmin != null
+                && mContentProtectionPolicy
+                        != DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY) {
             mSwitchBar.setDisabledByAdmin(mEnforcedAdmin);
         }
     }
@@ -107,7 +142,20 @@
     }
 
     @VisibleForTesting
+    @Nullable
+    protected UserHandle getManagedProfile() {
+        return ContentProtectionPreferenceUtils.getManagedProfile(mContext);
+    }
+
+    @VisibleForTesting
+    @Nullable
     protected RestrictedLockUtils.EnforcedAdmin getEnforcedAdmin() {
         return RestrictedLockUtilsInternal.getDeviceOwner(mContext);
     }
+
+    @VisibleForTesting
+    @DevicePolicyManager.ContentProtectionPolicy
+    protected int getContentProtectionPolicy(@Nullable UserHandle userHandle) {
+        return ContentProtectionPreferenceUtils.getContentProtectionPolicy(mContext, userHandle);
+    }
 }
diff --git a/src/com/android/settings/security/ContentProtectionWorkSwitchController.java b/src/com/android/settings/security/ContentProtectionWorkSwitchController.java
index 0404dcd..b9119ee 100644
--- a/src/com/android/settings/security/ContentProtectionWorkSwitchController.java
+++ b/src/com/android/settings/security/ContentProtectionWorkSwitchController.java
@@ -15,9 +15,11 @@
  */
 package com.android.settings.security;
 
+import static android.view.contentprotection.flags.Flags.manageDevicePolicyEnabled;
+
+import android.app.admin.DevicePolicyManager;
 import android.content.Context;
 import android.os.UserHandle;
-import android.os.UserManager;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -25,7 +27,6 @@
 import androidx.preference.PreferenceScreen;
 
 import com.android.settings.R;
-import com.android.settings.Utils;
 import com.android.settings.core.TogglePreferenceController;
 import com.android.settingslib.RestrictedLockUtils;
 import com.android.settingslib.RestrictedSwitchPreference;
@@ -33,25 +34,49 @@
 /** Preference controller for content protection work profile switch bar. */
 public class ContentProtectionWorkSwitchController extends TogglePreferenceController {
 
+    @Nullable private UserHandle mManagedProfile;
+
+    @DevicePolicyManager.ContentProtectionPolicy
+    private int mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+
     public ContentProtectionWorkSwitchController(
             @NonNull Context context, @NonNull String preferenceKey) {
         super(context, preferenceKey);
+
+        if (manageDevicePolicyEnabled()) {
+            mManagedProfile = getManagedProfile();
+            if (mManagedProfile != null) {
+                mContentProtectionPolicy = getContentProtectionPolicy(mManagedProfile);
+            }
+        }
     }
 
     @Override
     public int getAvailabilityStatus() {
-        return getManagedProfile() != null ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
+        if (!manageDevicePolicyEnabled()) {
+            return getManagedProfile() != null ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
+        }
+        if (mManagedProfile == null) {
+            return CONDITIONALLY_UNAVAILABLE;
+        }
+        if (mContentProtectionPolicy
+                == DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY) {
+            return CONDITIONALLY_UNAVAILABLE;
+        }
+        return AVAILABLE;
     }
 
-    // The switch is always set to unchecked until Android V by design
     @Override
     public boolean isChecked() {
-        return false;
+        if (!manageDevicePolicyEnabled()) {
+            return false;
+        }
+        return mContentProtectionPolicy == DevicePolicyManager.CONTENT_PROTECTION_ENABLED;
     }
 
-    // The switch is disabled until Android V by design
     @Override
     public boolean setChecked(boolean isChecked) {
+        // Controlled by the admin API
         return false;
     }
 
@@ -59,10 +84,13 @@
     public void displayPreference(PreferenceScreen screen) {
         super.displayPreference(screen);
 
-        RestrictedSwitchPreference switchPreference = screen.findPreference(getPreferenceKey());
-        UserHandle managedProfile = getManagedProfile();
+        UserHandle managedProfile =
+                manageDevicePolicyEnabled() ? mManagedProfile : getManagedProfile();
         if (managedProfile != null) {
-            switchPreference.setDisabledByAdmin(getEnforcedAdmin(managedProfile));
+            RestrictedSwitchPreference switchPreference = screen.findPreference(getPreferenceKey());
+            if (switchPreference != null) {
+                switchPreference.setDisabledByAdmin(getEnforcedAdmin(managedProfile));
+            }
         }
     }
 
@@ -74,13 +102,18 @@
     @VisibleForTesting
     @Nullable
     protected UserHandle getManagedProfile() {
-        return Utils.getManagedProfile(mContext.getSystemService(UserManager.class));
+        return ContentProtectionPreferenceUtils.getManagedProfile(mContext);
     }
 
     @VisibleForTesting
     @Nullable
-    protected RestrictedLockUtils.EnforcedAdmin getEnforcedAdmin(
-            @NonNull UserHandle managedProfile) {
-        return RestrictedLockUtils.getProfileOrDeviceOwner(mContext, managedProfile);
+    protected RestrictedLockUtils.EnforcedAdmin getEnforcedAdmin(@NonNull UserHandle userHandle) {
+        return RestrictedLockUtils.getProfileOrDeviceOwner(mContext, userHandle);
+    }
+
+    @VisibleForTesting
+    @DevicePolicyManager.ContentProtectionPolicy
+    protected int getContentProtectionPolicy(@Nullable UserHandle userHandle) {
+        return ContentProtectionPreferenceUtils.getContentProtectionPolicy(mContext, userHandle);
     }
 }
diff --git a/src/com/android/settings/spa/SettingsSpaEnvironment.kt b/src/com/android/settings/spa/SettingsSpaEnvironment.kt
index 568188f..f701323 100644
--- a/src/com/android/settings/spa/SettingsSpaEnvironment.kt
+++ b/src/com/android/settings/spa/SettingsSpaEnvironment.kt
@@ -22,11 +22,11 @@
 import com.android.settings.spa.about.AboutPhonePageProvider
 import com.android.settings.spa.app.AllAppListPageProvider
 import com.android.settings.spa.app.AppsMainPageProvider
-import com.android.settings.spa.app.battery.BatteryOptimizationModeAppListPageProvider
 import com.android.settings.spa.app.appcompat.UserAspectRatioAppsPageProvider
 import com.android.settings.spa.app.appinfo.AppInfoSettingsProvider
 import com.android.settings.spa.app.appinfo.CloneAppInfoSettingsProvider
 import com.android.settings.spa.app.backgroundinstall.BackgroundInstalledAppsPageProvider
+import com.android.settings.spa.app.battery.BatteryOptimizationModeAppListPageProvider
 import com.android.settings.spa.app.specialaccess.AlarmsAndRemindersAppListProvider
 import com.android.settings.spa.app.specialaccess.AllFilesAccessAppListProvider
 import com.android.settings.spa.app.specialaccess.BackupTasksAppsListProvider
diff --git a/src/com/android/settings/spa/network/NetworkCellularGroupProvider.kt b/src/com/android/settings/spa/network/NetworkCellularGroupProvider.kt
index a0c363a..5a2a394 100644
--- a/src/com/android/settings/spa/network/NetworkCellularGroupProvider.kt
+++ b/src/com/android/settings/spa/network/NetworkCellularGroupProvider.kt
@@ -44,13 +44,13 @@
 import com.android.settings.R
 import com.android.settings.network.SubscriptionInfoListViewModel
 import com.android.settings.network.telephony.MobileNetworkUtils
+import com.android.settings.spa.network.PrimarySimRepository.PrimarySimInfo
 import com.android.settings.wifi.WifiPickerTrackerHelper
 import com.android.settingslib.spa.framework.common.SettingsEntryBuilder
 import com.android.settingslib.spa.framework.common.SettingsPageProvider
 import com.android.settingslib.spa.framework.common.createSettingsPage
 import com.android.settingslib.spa.framework.compose.navigator
 import com.android.settingslib.spa.framework.util.collectLatestWithLifecycle
-import com.android.settingslib.spa.widget.preference.ListPreferenceOption
 import com.android.settingslib.spa.widget.preference.Preference
 import com.android.settingslib.spa.widget.preference.PreferenceModel
 import com.android.settingslib.spa.widget.preference.SwitchPreference
@@ -173,27 +173,23 @@
 ) {
     val selectableSubscriptionInfoList by selectableSubscriptionInfoListFlow
         .collectAsStateWithLifecycle(initialValue = emptyList())
-    val activeSubscriptionInfoList: List<SubscriptionInfo> =
-        selectableSubscriptionInfoList.filter { subscriptionInfo ->
-            subscriptionInfo.simSlotIndex != -1
-        }
 
     val stringSims = stringResource(R.string.provider_network_settings_title)
     RegularScaffold(title = stringSims) {
         SimsSection(selectableSubscriptionInfoList)
         PrimarySimSectionImpl(
-                activeSubscriptionInfoList,
-                defaultVoiceSubId,
-                defaultSmsSubId,
-                defaultDataSubId,
-                nonDds
+            selectableSubscriptionInfoListFlow,
+            defaultVoiceSubId,
+            defaultSmsSubId,
+            defaultDataSubId,
+            nonDds
         )
     }
 }
 
 @Composable
 fun PrimarySimImpl(
-    subscriptionInfoList: List<SubscriptionInfo>,
+    primarySimInfo: PrimarySimInfo,
     callsSelectedId: MutableIntState,
     textsSelectedId: MutableIntState,
     mobileDataSelectedId: MutableIntState,
@@ -237,108 +233,83 @@
         }
     },
 ) {
-    var state = rememberSaveable { mutableStateOf(false) }
-    var callsAndSmsList = remember {
-        mutableListOf(ListPreferenceOption(id = -1, text = "Loading"))
-    }
-    var dataList = remember {
-        mutableListOf(ListPreferenceOption(id = -1, text = "Loading"))
+    val telephonyManagerForNonDds: TelephonyManager? =
+            context.getSystemService(TelephonyManager::class.java)
+                    ?.createForSubscriptionId(nonDds.intValue)
+    val automaticDataChecked = rememberSaveable() {
+        mutableStateOf(false)
     }
 
-    if (subscriptionInfoList.size >= 2) {
-        state.value = true
-        callsAndSmsList.clear()
-        dataList.clear()
-        for (info in subscriptionInfoList) {
-            var item = ListPreferenceOption(
-                    id = info.subscriptionId,
-                    text = "${info.displayName}",
-                    summary = "${info.number}"
-            )
-            callsAndSmsList.add(item)
-            dataList.add(item)
-        }
-        callsAndSmsList.add(
-            ListPreferenceOption(
-                id = SubscriptionManager.INVALID_SUBSCRIPTION_ID,
-                text = stringResource(id = R.string.sim_calls_ask_first_prefs_title)
-            )
-        )
-    } else {
-        // hide the primary sim
-        state.value = false
-        Log.d(NetworkCellularGroupProvider.name, "Hide primary sim")
-    }
+    CreatePrimarySimListPreference(
+        stringResource(id = R.string.primary_sim_calls_title),
+        primarySimInfo.callsAndSmsList,
+        callsSelectedId,
+        ImageVector.vectorResource(R.drawable.ic_phone),
+        actionSetCalls
+    )
+    CreatePrimarySimListPreference(
+        stringResource(id = R.string.primary_sim_texts_title),
+        primarySimInfo.callsAndSmsList,
+        textsSelectedId,
+        Icons.AutoMirrored.Outlined.Message,
+        actionSetTexts
+    )
+    CreatePrimarySimListPreference(
+        stringResource(id = R.string.mobile_data_settings_title),
+        primarySimInfo.dataList,
+        mobileDataSelectedId,
+        Icons.Outlined.DataUsage,
+        actionSetMobileData
+    )
 
-    if (state.value) {
-        val telephonyManagerForNonDds: TelephonyManager? =
-                context.getSystemService(TelephonyManager::class.java)
-                        ?.createForSubscriptionId(nonDds.intValue)
-        val automaticDataChecked = rememberSaveable() {
-            mutableStateOf(false)
-        }
-
-        CreatePrimarySimListPreference(
-            stringResource(id = R.string.primary_sim_calls_title),
-            callsAndSmsList,
-            callsSelectedId,
-            ImageVector.vectorResource(R.drawable.ic_phone),
-            actionSetCalls
-        )
-        CreatePrimarySimListPreference(
-            stringResource(id = R.string.primary_sim_texts_title),
-            callsAndSmsList,
-            textsSelectedId,
-            Icons.AutoMirrored.Outlined.Message,
-            actionSetTexts
-        )
-        CreatePrimarySimListPreference(
-            stringResource(id = R.string.mobile_data_settings_title),
-            dataList,
-            mobileDataSelectedId,
-            Icons.Outlined.DataUsage,
-            actionSetMobileData
-        )
-
-        val autoDataTitle = stringResource(id = R.string.primary_sim_automatic_data_title)
-        val autoDataSummary = stringResource(id = R.string.primary_sim_automatic_data_msg)
-        SwitchPreference(
-            object : SwitchPreferenceModel {
-                override val title = autoDataTitle
-                override val summary = { autoDataSummary }
-                override val checked = {
-                    if (nonDds.intValue != SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
-                        coroutineScope.launch {
-                            automaticDataChecked.value = getAutomaticData(telephonyManagerForNonDds)
-                            Log.d(
-                                NetworkCellularGroupProvider.name,
-                                "NonDds:${nonDds.intValue}" +
-                                    "getAutomaticData:${automaticDataChecked.value}"
-                            )
-                        }
+    val autoDataTitle = stringResource(id = R.string.primary_sim_automatic_data_title)
+    val autoDataSummary = stringResource(id = R.string.primary_sim_automatic_data_msg)
+    SwitchPreference(
+        object : SwitchPreferenceModel {
+            override val title = autoDataTitle
+            override val summary = { autoDataSummary }
+            override val checked = {
+                if (nonDds.intValue != SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
+                    coroutineScope.launch {
+                        automaticDataChecked.value = getAutomaticData(telephonyManagerForNonDds)
+                        Log.d(
+                            NetworkCellularGroupProvider.name,
+                            "NonDds:${nonDds.intValue}" +
+                                "getAutomaticData:${automaticDataChecked.value}"
+                        )
                     }
-                    automaticDataChecked.value
                 }
-                override val onCheckedChange: ((Boolean) -> Unit)? = {
-                    automaticDataChecked.value = it
-                    actionSetAutoDataSwitch(it)
-                }
+                automaticDataChecked.value
             }
-        )
-    }
+            override val onCheckedChange: ((Boolean) -> Unit)? = {
+                automaticDataChecked.value = it
+                actionSetAutoDataSwitch(it)
+            }
+        }
+    )
 }
 
 @Composable
 fun PrimarySimSectionImpl(
-    subscriptionInfoList: List<SubscriptionInfo>,
+    subscriptionInfoListFlow: Flow<List<SubscriptionInfo>>,
     callsSelectedId: MutableIntState,
     textsSelectedId: MutableIntState,
     mobileDataSelectedId: MutableIntState,
     nonDds: MutableIntState,
 ) {
+    val context = LocalContext.current
+    val primarySimInfo = remember(subscriptionInfoListFlow) {
+        subscriptionInfoListFlow
+            .map { subscriptionInfoList ->
+                subscriptionInfoList.filter { subInfo -> subInfo.simSlotIndex != -1 }
+            }
+            .map(PrimarySimRepository(context)::getPrimarySimInfo)
+            .flowOn(Dispatchers.Default)
+    }.collectAsStateWithLifecycle(initialValue = null).value ?: return
+
     Category(title = stringResource(id = R.string.primary_sim_title)) {
         PrimarySimImpl(
-            subscriptionInfoList,
+            primarySimInfo,
             callsSelectedId,
             textsSelectedId,
             mobileDataSelectedId,
diff --git a/src/com/android/settings/spa/network/PrimarySimRepository.kt b/src/com/android/settings/spa/network/PrimarySimRepository.kt
new file mode 100644
index 0000000..b9eb3ff
--- /dev/null
+++ b/src/com/android/settings/spa/network/PrimarySimRepository.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.spa.network
+
+import android.content.Context
+import android.telephony.SubscriptionInfo
+import android.telephony.SubscriptionManager
+import android.util.Log
+import com.android.settings.R
+import com.android.settings.network.SubscriptionUtil
+import com.android.settingslib.spa.widget.preference.ListPreferenceOption
+
+class PrimarySimRepository(private val context: Context) {
+
+    data class PrimarySimInfo(
+        val callsAndSmsList: List<ListPreferenceOption>,
+        val dataList: List<ListPreferenceOption>,
+    )
+
+    fun getPrimarySimInfo(selectableSubscriptionInfoList: List<SubscriptionInfo>): PrimarySimInfo? {
+        if (selectableSubscriptionInfoList.size < 2) {
+            Log.d(TAG, "Hide primary sim")
+            return null
+        }
+
+        val callsAndSmsList = mutableListOf<ListPreferenceOption>()
+        val dataList = mutableListOf<ListPreferenceOption>()
+        for (info in selectableSubscriptionInfoList) {
+            val item = ListPreferenceOption(
+                id = info.subscriptionId,
+                text = "${info.displayName}",
+                summary = SubscriptionUtil.getFormattedPhoneNumber(context, info) ?: "",
+            )
+            callsAndSmsList += item
+            dataList += item
+        }
+        callsAndSmsList += ListPreferenceOption(
+            id = SubscriptionManager.INVALID_SUBSCRIPTION_ID,
+            text = context.getString(R.string.sim_calls_ask_first_prefs_title),
+        )
+
+        return PrimarySimInfo(callsAndSmsList, dataList)
+    }
+
+    private companion object {
+        private const val TAG = "PrimarySimRepository"
+    }
+}
diff --git a/src/com/android/settings/spa/network/SimOnboardingLabelSim.kt b/src/com/android/settings/spa/network/SimOnboardingLabelSim.kt
index 3b2d5ec..94e4a88 100644
--- a/src/com/android/settings/spa/network/SimOnboardingLabelSim.kt
+++ b/src/com/android/settings/spa/network/SimOnboardingLabelSim.kt
@@ -16,6 +16,7 @@
 
 package com.android.settings.spa.network
 
+import android.telephony.SubscriptionInfo
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
@@ -63,52 +64,55 @@
             cancelAction
         ),
     ) {
-        labelSimBody(onboardingService)
+        LabelSimBody(onboardingService)
     }
 }
 
 @Composable
-private fun labelSimBody(onboardingService: SimOnboardingService) {
+private fun LabelSimBody(onboardingService: SimOnboardingService) {
     Column(Modifier.padding(SettingsDimension.itemPadding)) {
         SettingsBody(stringResource(R.string.sim_onboarding_label_sim_msg))
     }
 
     for (subInfo in onboardingService.getSelectableSubscriptionInfoList()) {
-        var titleSimName by remember {
-            mutableStateOf(
-                onboardingService.getSubscriptionInfoDisplayName(subInfo)
-            )
-        }
-        var summaryNumber = subInfo.number
-            // TODO using the SubscriptionUtil.getFormattedPhoneNumber
-        val alertDialogPresenter = rememberAlertDialogPresenter(
-            confirmButton = AlertDialogButton(
-                stringResource(R.string.mobile_network_sim_name_rename)
-            ) {
-                onboardingService.addItemForRenaming(subInfo, titleSimName)
-            },
-            dismissButton = AlertDialogButton(stringResource(R.string.cancel)) {
-                titleSimName = onboardingService.getSubscriptionInfoDisplayName(subInfo)
-            },
-            title = stringResource(R.string.sim_onboarding_label_sim_dialog_title),
-            text = {
-                Text(summaryNumber,
-                    modifier = Modifier.padding(bottom = SettingsDimension.itemPaddingVertical))
-                SettingsOutlinedTextField(
-                    value = titleSimName,
-                    label = stringResource(R.string.sim_onboarding_label_sim_dialog_label),
-                    enabled = true,
-                    shape = MaterialTheme.shapes.extraLarge
-                ) {
-                    titleSimName = it
-                }
-            },
-        )
-        Preference(object : PreferenceModel {
-            override val title = titleSimName
-            override val summary: () -> String
-                get() = { summaryNumber }
-            override val onClick = alertDialogPresenter::open
-        })
+        LabelSimPreference(onboardingService, subInfo)
     }
-}
\ No newline at end of file
+}
+
+@Composable
+private fun LabelSimPreference(
+    onboardingService: SimOnboardingService,
+    subInfo: SubscriptionInfo,
+) {
+    var titleSimName by remember {
+        mutableStateOf(onboardingService.getSubscriptionInfoDisplayName(subInfo))
+    }
+    val phoneNumber = phoneNumber(subInfo)
+    val alertDialogPresenter = rememberAlertDialogPresenter(
+        confirmButton = AlertDialogButton(stringResource(R.string.mobile_network_sim_name_rename)) {
+            onboardingService.addItemForRenaming(subInfo, titleSimName)
+        },
+        dismissButton = AlertDialogButton(stringResource(R.string.cancel)) {
+            titleSimName = onboardingService.getSubscriptionInfoDisplayName(subInfo)
+        },
+        title = stringResource(R.string.sim_onboarding_label_sim_dialog_title),
+        text = {
+            Text(
+                phoneNumber.value ?: "",
+                modifier = Modifier.padding(bottom = SettingsDimension.itemPaddingVertical)
+            )
+            SettingsOutlinedTextField(
+                value = titleSimName,
+                label = stringResource(R.string.sim_onboarding_label_sim_dialog_label),
+                shape = MaterialTheme.shapes.extraLarge
+            ) {
+                titleSimName = it
+            }
+        },
+    )
+    Preference(object : PreferenceModel {
+        override val title = titleSimName
+        override val summary = { phoneNumber.value ?: "" }
+        override val onClick = alertDialogPresenter::open
+    })
+}
diff --git a/src/com/android/settings/spa/network/SimOnboardingPrimarySim.kt b/src/com/android/settings/spa/network/SimOnboardingPrimarySim.kt
index b984966..a8c0575 100644
--- a/src/com/android/settings/spa/network/SimOnboardingPrimarySim.kt
+++ b/src/com/android/settings/spa/network/SimOnboardingPrimarySim.kt
@@ -24,10 +24,13 @@
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.MutableIntState
 import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.android.settings.R
 import com.android.settings.network.SimOnboardingService
 import com.android.settingslib.spa.framework.theme.SettingsDimension
@@ -38,6 +41,9 @@
 import com.android.settingslib.spa.widget.scaffold.SuwScaffold
 import com.android.settingslib.spa.widget.ui.SettingsBody
 import com.android.settingslib.spa.widget.ui.SettingsIcon
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
 
 /**
  * the sim onboarding primary sim compose
@@ -77,13 +83,19 @@
             SettingsBody(stringResource(id = R.string.sim_onboarding_primary_sim_msg))
         }
 
-        var selectedSubscriptionInfoList =
-                onboardingService.getSelectedSubscriptionInfoListWithRenaming()
+        val context = LocalContext.current
+        val primarySimInfo = remember {
+            flow {
+                val selectableSubInfoList =
+                    onboardingService.getSelectedSubscriptionInfoListWithRenaming()
+                emit(PrimarySimRepository(context).getPrimarySimInfo(selectableSubInfoList))
+            }.flowOn(Dispatchers.Default)
+        }.collectAsStateWithLifecycle(initialValue = null).value ?: return@SuwScaffold
         callsSelectedId.intValue = onboardingService.targetPrimarySimCalls
         textsSelectedId.intValue = onboardingService.targetPrimarySimTexts
         mobileDataSelectedId.intValue = onboardingService.targetPrimarySimMobileData
         PrimarySimImpl(
-            subscriptionInfoList = selectedSubscriptionInfoList,
+            primarySimInfo = primarySimInfo,
             callsSelectedId = callsSelectedId,
             textsSelectedId = textsSelectedId,
             mobileDataSelectedId = mobileDataSelectedId,
diff --git a/src/com/android/settings/spa/network/SimsSection.kt b/src/com/android/settings/spa/network/SimsSection.kt
index 334ca61..0b638c4 100644
--- a/src/com/android/settings/spa/network/SimsSection.kt
+++ b/src/com/android/settings/spa/network/SimsSection.kt
@@ -25,6 +25,7 @@
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Add
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
 import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
@@ -36,10 +37,10 @@
 import com.android.settings.network.telephony.phoneNumberFlow
 import com.android.settingslib.spa.widget.preference.PreferenceModel
 import com.android.settingslib.spa.widget.preference.SwitchPreferenceModel
-import com.android.settingslib.spa.widget.preference.TwoTargetSwitchPreference
 import com.android.settingslib.spa.widget.ui.SettingsIcon
 import com.android.settingslib.spaprivileged.model.enterprise.Restrictions
 import com.android.settingslib.spaprivileged.template.preference.RestrictedPreference
+import com.android.settingslib.spaprivileged.template.preference.RestrictedTwoTargetSwitchPreference
 
 @Composable
 fun SimsSection(subscriptionInfoList: List<SubscriptionInfo>) {
@@ -58,12 +59,9 @@
     val checked = remember(subInfo.subscriptionId) {
         context.isSubscriptionEnabledFlow(subInfo.subscriptionId)
     }.collectAsStateWithLifecycle(initialValue = false)
-    val phoneNumber = remember(subInfo) {
-        context.phoneNumberFlow(subInfo)
-    }.collectAsStateWithLifecycle(initialValue = null)
-    //TODO: Add the Restricted TwoTargetSwitchPreference in SPA
-    TwoTargetSwitchPreference(
-        object : SwitchPreferenceModel {
+    val phoneNumber = phoneNumber(subInfo)
+    RestrictedTwoTargetSwitchPreference(
+        model = object : SwitchPreferenceModel {
             override val title = subInfo.displayName.toString()
             override val summary = { phoneNumber.value ?: "" }
             override val checked = { checked.value }
@@ -74,13 +72,22 @@
                     newChecked,
                 )
             }
-        }
+        },
+        restrictions = Restrictions(keys = listOf(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)),
     ) {
         MobileNetworkUtils.launchMobileNetworkSettings(context, subInfo)
     }
 }
 
 @Composable
+fun phoneNumber(subInfo: SubscriptionInfo): State<String?> {
+    val context = LocalContext.current
+    return remember(subInfo) {
+        context.phoneNumberFlow(subInfo)
+    }.collectAsStateWithLifecycle(initialValue = null)
+}
+
+@Composable
 private fun AddSim() {
     val context = LocalContext.current
     if (remember { MobileNetworkUtils.showEuiccSettings(context) }) {
diff --git a/src/com/android/settings/wifi/WifiConfigController.java b/src/com/android/settings/wifi/WifiConfigController.java
index 5d45cb2..39c77a1 100644
--- a/src/com/android/settings/wifi/WifiConfigController.java
+++ b/src/com/android/settings/wifi/WifiConfigController.java
@@ -72,6 +72,7 @@
 import com.android.settings.R;
 import com.android.settings.network.SubscriptionUtil;
 import com.android.settings.utils.AndroidKeystoreAliasLoader;
+import com.android.settings.wifi.details2.WifiPrivacyPreferenceController;
 import com.android.settings.wifi.dpp.WifiDppUtils;
 import com.android.settingslib.Utils;
 import com.android.settingslib.utils.ThreadUtils;
@@ -154,6 +155,10 @@
     @VisibleForTesting static final int PRIVACY_SPINNER_INDEX_RANDOMIZED_MAC = 0;
     @VisibleForTesting static final int PRIVACY_SPINNER_INDEX_DEVICE_MAC = 1;
 
+    // Should be the same index value as wifi_dhcp_entries in arrays.xml
+    @VisibleForTesting static final int DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_ENABLE = 0;
+    @VisibleForTesting static final int DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE = 1;
+
     /* Phase2 methods supported by PEAP are limited */
     private ArrayAdapter<CharSequence> mPhase2PeapAdapter;
     /* Phase2 methods supported by TTLS are limited */
@@ -194,6 +199,7 @@
     private Spinner mMeteredSettingsSpinner;
     private Spinner mHiddenSettingsSpinner;
     private Spinner mPrivacySettingsSpinner;
+    private Spinner mDhcpSettingsSpinner;
     private TextView mHiddenWarningView;
     private TextView mProxyHostView;
     private TextView mProxyPortView;
@@ -291,6 +297,7 @@
         mMeteredSettingsSpinner = mView.findViewById(R.id.metered_settings);
         mHiddenSettingsSpinner = mView.findViewById(R.id.hidden_settings);
         mPrivacySettingsSpinner = mView.findViewById(R.id.privacy_settings);
+        mDhcpSettingsSpinner = mView.findViewById(R.id.dhcp_settings);
         if (mWifiManager.isConnectedMacRandomizationSupported()) {
             View privacySettingsLayout = mView.findViewById(R.id.privacy_settings_fields);
             privacySettingsLayout.setVisibility(View.VISIBLE);
@@ -323,6 +330,12 @@
                         config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT
                         ? PRIVACY_SPINNER_INDEX_RANDOMIZED_MAC : PRIVACY_SPINNER_INDEX_DEVICE_MAC);
 
+                mDhcpSettingsSpinner.setSelection(
+                        config.isSendDhcpHostnameEnabled()
+                                ? DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_ENABLE :
+                                DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE
+                );
+
                 if (config.getIpConfiguration().getIpAssignment() == IpAssignment.STATIC) {
                     mIpSettingsSpinner.setSelection(STATIC_IP);
                     showAdvancedFields = true;
@@ -841,6 +854,12 @@
                     : WifiConfiguration.RANDOMIZATION_NONE;
         }
 
+        if (mDhcpSettingsSpinner != null) {
+            config.setSendDhcpHostnameEnabled(WifiPrivacyPreferenceController.Companion
+                    .translatePrefValueToSendDhcpHostnameEnabled(mDhcpSettingsSpinner
+                            .getSelectedItemPosition()));
+        }
+
         return config;
     }
 
diff --git a/src/com/android/settings/wifi/WifiConfigController2.java b/src/com/android/settings/wifi/WifiConfigController2.java
index 7c9b1d1..1e40568 100644
--- a/src/com/android/settings/wifi/WifiConfigController2.java
+++ b/src/com/android/settings/wifi/WifiConfigController2.java
@@ -74,6 +74,7 @@
 import com.android.settings.R;
 import com.android.settings.network.SubscriptionUtil;
 import com.android.settings.utils.AndroidKeystoreAliasLoader;
+import com.android.settings.wifi.details2.WifiPrivacyPreferenceController;
 import com.android.settings.wifi.details2.WifiPrivacyPreferenceController2;
 import com.android.settings.wifi.dpp.WifiDppUtils;
 import com.android.settingslib.Utils;
@@ -208,6 +209,8 @@
     private Spinner mHiddenSettingsSpinner;
     @Nullable
     private Spinner mPrivacySettingsSpinner;
+    @Nullable
+    private Spinner mDhcpSettingsSpinner;
     private TextView mHiddenWarningView;
     private TextView mProxyHostView;
     private TextView mProxyPortView;
@@ -308,6 +311,7 @@
         mHiddenSettingsSpinner = mView.findViewById(R.id.hidden_settings);
         if (!mHideMeteredAndPrivacy && mWifiManager.isConnectedMacRandomizationSupported()) {
             mPrivacySettingsSpinner = mView.findViewById(R.id.privacy_settings);
+            mDhcpSettingsSpinner  = mView.findViewById(R.id.dhcp_settings);
             mView.findViewById(R.id.privacy_settings_fields).setVisibility(View.VISIBLE);
         }
         mHiddenSettingsSpinner.setOnItemSelectedListener(this);
@@ -342,6 +346,13 @@
                     mPrivacySettingsSpinner.setSelection(prefMacValue);
                 }
 
+                if (mDhcpSettingsSpinner != null) {
+                    final int prefDhcpValue = WifiPrivacyPreferenceController.Companion
+                            .translateSendDhcpHostnameEnabledToPrefValue(
+                                    config.isSendDhcpHostnameEnabled());
+                    mDhcpSettingsSpinner.setSelection(prefDhcpValue);
+                }
+
                 if (config.getIpConfiguration().getIpAssignment() == IpAssignment.STATIC) {
                     mIpSettingsSpinner.setSelection(STATIC_IP);
                     showAdvancedFields = true;
@@ -854,6 +865,12 @@
                             .getSelectedItemPosition());
         }
 
+        if (mDhcpSettingsSpinner != null) {
+            config.setSendDhcpHostnameEnabled(WifiPrivacyPreferenceController.Companion
+                    .translatePrefValueToSendDhcpHostnameEnabled(mDhcpSettingsSpinner
+                            .getSelectedItemPosition()));
+        }
+
         return config;
     }
 
diff --git a/src/com/android/settings/wifi/details/WifiNetworkDetailsFragment.java b/src/com/android/settings/wifi/details/WifiNetworkDetailsFragment.java
index e1774e3..06b3e5d 100644
--- a/src/com/android/settings/wifi/details/WifiNetworkDetailsFragment.java
+++ b/src/com/android/settings/wifi/details/WifiNetworkDetailsFragment.java
@@ -55,6 +55,7 @@
 import com.android.settings.wifi.WifiDialog2;
 import com.android.settings.wifi.WifiUtils;
 import com.android.settings.wifi.details2.AddDevicePreferenceController2;
+import com.android.settings.wifi.details2.CertificateDetailsPreferenceController;
 import com.android.settings.wifi.details2.WifiAutoConnectPreferenceController2;
 import com.android.settings.wifi.details2.WifiDetailPreferenceController2;
 import com.android.settings.wifi.details2.WifiMeteredPreferenceController2;
@@ -122,8 +123,12 @@
     @Override
     public void onAttach(@NonNull Context context) {
         super.onAttach(context);
+        String wifiEntryKey = getArguments().getString(KEY_CHOSEN_WIFIENTRY_KEY);
+        setupNetworksDetailTracker();
         use(WifiPrivacyPreferenceController.class)
-                .setWifiEntryKey(getArguments().getString(KEY_CHOSEN_WIFIENTRY_KEY));
+                .setWifiEntryKey(wifiEntryKey);
+        use(CertificateDetailsPreferenceController.class)
+                .setWifiEntry(mNetworkDetailsTracker.getWifiEntry());
     }
 
     @Override
diff --git a/src/com/android/settings/wifi/details2/CertificateDetailsPreferenceController.kt b/src/com/android/settings/wifi/details2/CertificateDetailsPreferenceController.kt
new file mode 100644
index 0000000..8e1fa23
--- /dev/null
+++ b/src/com/android/settings/wifi/details2/CertificateDetailsPreferenceController.kt
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.wifi.details2
+
+import android.content.Context
+import android.content.DialogInterface
+import android.net.http.SslCertificate
+import android.security.KeyChain
+import android.security.keystore.KeyProperties
+import android.security.keystore2.AndroidKeyStoreLoadStoreParameter
+import android.util.Log
+import android.view.View
+import android.widget.ArrayAdapter
+import android.widget.LinearLayout
+import android.widget.Spinner
+import androidx.appcompat.app.AlertDialog
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import com.android.settings.R
+import com.android.settings.spa.preference.ComposePreferenceController
+import com.android.settingslib.spa.widget.preference.Preference
+import com.android.settingslib.spa.widget.preference.PreferenceModel
+import com.android.wifi.flags.Flags
+import com.android.wifitrackerlib.WifiEntry
+import java.security.KeyStore
+import java.security.cert.X509Certificate
+
+class CertificateDetailsPreferenceController(context: Context, preferenceKey: String) :
+    ComposePreferenceController(context, preferenceKey) {
+
+    private lateinit var wifiEntry: WifiEntry
+    lateinit var certificateAliases: String
+    lateinit var certX509: X509Certificate
+
+    fun setWifiEntry(entry: WifiEntry) {
+        wifiEntry = entry
+    }
+
+    override fun getAvailabilityStatus(): Int {
+        return if (Flags.androidVWifiApi() && getCertX509(wifiEntry)) AVAILABLE
+        else CONDITIONALLY_UNAVAILABLE
+    }
+
+    @Composable
+    override fun Content() {
+        CertificateDetails()
+    }
+
+    @Composable
+    fun CertificateDetails() {
+        val context = LocalContext.current
+        Preference(object : PreferenceModel {
+            override val title = stringResource(com.android.internal.R.string.ssl_certificate)
+            override val summary = { certificateAliases }
+            override val onClick: () -> Unit = { createCertificateDetailsDialog(context, certX509) }
+        })
+    }
+
+    private fun getCertX509(wifiEntry: WifiEntry): Boolean {
+        certificateAliases =
+            wifiEntry.wifiConfiguration?.enterpriseConfig?.caCertificateAliases?.get(0)
+                ?: return false
+        return try {
+            val keyStore = KeyStore.getInstance("AndroidKeyStore")
+            keyStore.load(AndroidKeyStoreLoadStoreParameter(KeyProperties.NAMESPACE_WIFI))
+            val cert = keyStore.getCertificate(certificateAliases)
+            certX509 = KeyChain.toCertificate(cert.encoded)
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to open Android Keystore.", e)
+            false
+        }
+    }
+
+    private fun createCertificateDetailsDialog(context: Context, certX509: X509Certificate) {
+        val listener =
+            DialogInterface.OnClickListener { dialog, id ->
+                dialog.dismiss()
+            }
+        val titles = ArrayList<String>()
+        val sslCert = SslCertificate(certX509)
+        titles.add(sslCert.issuedTo.cName)
+        val arrayAdapter = ArrayAdapter(
+            context,
+            android.R.layout.simple_spinner_item,
+            titles
+        )
+        arrayAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+        val spinner = Spinner(context)
+        spinner.setAdapter(arrayAdapter)
+
+        val certLayout = LinearLayout(context)
+        certLayout.orientation = LinearLayout.VERTICAL
+        // Prevent content overlapping with spinner
+        certLayout.setClipChildren(true)
+        certLayout.addView(spinner)
+
+        val view = sslCert.inflateCertificateView(context)
+        view.visibility = View.VISIBLE
+        certLayout.addView(view)
+        certLayout.visibility = View.VISIBLE
+
+        val dialog = AlertDialog.Builder(context)
+            .setView(certLayout)
+            .setTitle(com.android.internal.R.string.ssl_certificate)
+            .setPositiveButton(R.string.wifi_settings_ssid_block_button_close, null)
+            .setNegativeButton(R.string.trusted_credentials_remove_label, listener).create()
+        dialog.show()
+        dialog.getButton(AlertDialog.BUTTON_NEGATIVE).setEnabled(false)
+    }
+
+    companion object {
+        const val TAG = "CertificateDetailsPreferenceController"
+    }
+}
\ No newline at end of file
diff --git a/src/com/android/settings/wifi/details2/WifiPrivacyPreferenceController.kt b/src/com/android/settings/wifi/details2/WifiPrivacyPreferenceController.kt
index 42741e3..2ed2e5a 100644
--- a/src/com/android/settings/wifi/details2/WifiPrivacyPreferenceController.kt
+++ b/src/com/android/settings/wifi/details2/WifiPrivacyPreferenceController.kt
@@ -63,4 +63,32 @@
                 }
         })
     }
+
+    companion object {
+        private const val PREF_SEND_DHCP_HOST_NAME_ENABLE = 0
+        private const val PREF_SEND_DHCP_HOST_NAME_DISABLE = 1
+
+        /**
+         * Returns preference index value.
+         *
+         * @param isSendDhcpHostnameEnabled determines whether device name can be sent.
+         * @return index value of preference
+         */
+        fun translateSendDhcpHostnameEnabledToPrefValue(
+            isSendDhcpHostnameEnabled: Boolean
+        ): Int {
+            return if (isSendDhcpHostnameEnabled) PREF_SEND_DHCP_HOST_NAME_ENABLE
+            else PREF_SEND_DHCP_HOST_NAME_DISABLE
+        }
+
+        /**
+         * Returns whether device name can be sent.
+         *
+         * @param prefDhcpRandomized is preference index value
+         * @return is send dhcp host name enabled
+         */
+        fun translatePrefValueToSendDhcpHostnameEnabled(prefDhcpRandomized: Int): Boolean {
+            return prefDhcpRandomized == PREF_SEND_DHCP_HOST_NAME_ENABLE
+        }
+    }
 }
\ No newline at end of file
diff --git a/tests/robotests/src/com/android/settings/accessibility/AccessibilityGestureNavigationTutorialTest.java b/tests/robotests/src/com/android/settings/accessibility/AccessibilityGestureNavigationTutorialTest.java
index d6a2492..404dbe5 100644
--- a/tests/robotests/src/com/android/settings/accessibility/AccessibilityGestureNavigationTutorialTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/AccessibilityGestureNavigationTutorialTest.java
@@ -98,7 +98,20 @@
     @Test
     @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void createTutorialPages_turnOnTwoFingerTripleTapShortcut_hasOnePage() {
-        mShortcutTypes |= UserShortcutType.TWOFINGERTRIPLETAP;
+        mShortcutTypes |= UserShortcutType.TWOFINGER_DOUBLETAP;
+
+        final AlertDialog alertDialog =
+                createAccessibilityTutorialDialog(mContext, mShortcutTypes);
+
+        assertThat(createShortcutTutorialPages(mContext,
+                mShortcutTypes)).hasSize(/* expectedSize= */ 1);
+        assertThat(alertDialog).isNotNull();
+    }
+
+    @Test
+    @RequiresFlagsEnabled(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void createTutorialPages_turnOnQuickSettingShortcut_hasOnePage() {
+        mShortcutTypes |= UserShortcutType.QUICK_SETTINGS;
 
         final AlertDialog alertDialog =
                 createAccessibilityTutorialDialog(mContext, mShortcutTypes);
diff --git a/tests/robotests/src/com/android/settings/accessibility/AccessibilitySettingsTest.java b/tests/robotests/src/com/android/settings/accessibility/AccessibilitySettingsTest.java
index 05e56ca..624a39a 100644
--- a/tests/robotests/src/com/android/settings/accessibility/AccessibilitySettingsTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/AccessibilitySettingsTest.java
@@ -38,8 +38,12 @@
 import android.content.pm.ServiceInfo;
 import android.database.ContentObserver;
 import android.os.Build;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
 import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.Flags;
 
 import androidx.fragment.app.Fragment;
 import androidx.test.core.app.ApplicationProvider;
@@ -59,6 +63,8 @@
 import com.android.settingslib.search.SearchIndexableRaw;
 import com.android.settingslib.testutils.shadow.ShadowColorDisplayManager;
 
+import com.google.common.truth.BooleanSubject;
+
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -103,6 +109,7 @@
 
     @Rule
     public final MockitoRule mocks = MockitoJUnit.rule();
+    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     private final Context mContext = ApplicationProvider.getApplicationContext();
     @Spy
     private final AccessibilityServiceInfo mServiceInfo = getMockAccessibilityServiceInfo(
@@ -316,30 +323,39 @@
     }
 
     @Test
-    public void onCreate_haveRegisterToSpecificUrisAndActions() {
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void onCreate_flagDisabled_haveRegisterToSpecificUrisAndActions() {
         setupFragment();
 
-        ShadowContentResolver shadowContentResolver = shadowOf(mContext.getContentResolver());
-        Collection<ContentObserver> a11yButtonTargetsObservers =
-                shadowContentResolver.getContentObservers(
-                        Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS));
-        Collection<ContentObserver> a11yShortcutTargetServiceObservers =
-                shadowContentResolver.getContentObservers(Settings.Secure.getUriFor(
-                        Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE));
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS,
+                AccessibilitySettingsContentObserver.class).isTrue();
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE,
+                AccessibilitySettingsContentObserver.class).isTrue();
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_QS_TARGETS,
+                AccessibilitySettingsContentObserver.class).isFalse();
         List<BroadcastReceiver> broadcastReceivers =
                 shadowOf((Application) ApplicationProvider.getApplicationContext())
                         .getRegisteredReceivers()
                         .stream().map(wrapper -> wrapper.broadcastReceiver).toList();
-        assertThat(
-                a11yButtonTargetsObservers.stream()
-                        .anyMatch(contentObserver ->
-                                contentObserver instanceof AccessibilitySettingsContentObserver))
-                .isTrue();
-        assertThat(
-                a11yShortcutTargetServiceObservers.stream()
-                        .anyMatch(contentObserver ->
-                                contentObserver instanceof AccessibilitySettingsContentObserver))
-                .isTrue();
+        assertThat(broadcastReceivers.stream().anyMatch(
+                broadcastReceiver -> broadcastReceiver instanceof PackageMonitor)).isTrue();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void onCreate_flagEnabled_haveRegisterToSpecificUrisAndActions() {
+        setupFragment();
+
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS,
+                AccessibilitySettingsContentObserver.class).isTrue();
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE,
+                AccessibilitySettingsContentObserver.class).isTrue();
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_QS_TARGETS,
+                AccessibilitySettingsContentObserver.class).isTrue();
+        List<BroadcastReceiver> broadcastReceivers =
+                shadowOf((Application) ApplicationProvider.getApplicationContext())
+                        .getRegisteredReceivers()
+                        .stream().map(wrapper -> wrapper.broadcastReceiver).toList();
         assertThat(broadcastReceivers.stream().anyMatch(
                 broadcastReceiver -> broadcastReceiver instanceof PackageMonitor)).isTrue();
     }
@@ -350,27 +366,16 @@
 
         mActivityController.pause().stop().destroy();
 
-        ShadowContentResolver shadowContentResolver = shadowOf(mContext.getContentResolver());
-        Collection<ContentObserver> a11yButtonTargetsObservers =
-                shadowContentResolver.getContentObservers(
-                        Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS));
-        Collection<ContentObserver> a11yShortcutTargetServiceObservers =
-                shadowContentResolver.getContentObservers(Settings.Secure.getUriFor(
-                        Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE));
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS,
+                AccessibilitySettingsContentObserver.class).isFalse();
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE,
+                AccessibilitySettingsContentObserver.class).isFalse();
+        assertUriObserversContainsClazz(Settings.Secure.ACCESSIBILITY_QS_TARGETS,
+                AccessibilitySettingsContentObserver.class).isFalse();
         List<BroadcastReceiver> broadcastReceivers =
                 shadowOf((Application) ApplicationProvider.getApplicationContext())
                         .getRegisteredReceivers()
                         .stream().map(wrapper -> wrapper.broadcastReceiver).toList();
-        assertThat(
-                a11yButtonTargetsObservers.stream()
-                        .anyMatch(contentObserver ->
-                                contentObserver instanceof AccessibilitySettingsContentObserver))
-                .isFalse();
-        assertThat(
-                a11yShortcutTargetServiceObservers.stream()
-                        .anyMatch(contentObserver ->
-                                contentObserver instanceof AccessibilitySettingsContentObserver))
-                .isFalse();
         assertThat(broadcastReceivers.stream().anyMatch(
                 broadcastReceiver -> broadcastReceiver instanceof PackageMonitor)).isFalse();
     }
@@ -491,4 +496,14 @@
                 Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS,
                 enabled ? componentName.flattenToString() : "");
     }
+
+    private BooleanSubject assertUriObserversContainsClazz(
+            String settingUri, Class<?> clazz) {
+        ShadowContentResolver shadowContentResolver = shadowOf(mContext.getContentResolver());
+        Collection<ContentObserver> observers =
+                shadowContentResolver.getContentObservers(
+                        Settings.Secure.getUriFor(settingUri));
+
+        return assertThat(observers.stream().anyMatch(clazz::isInstance));
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/accessibility/AccessibilityShortcutPreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/AccessibilityShortcutPreferenceFragmentTest.java
index 4607a59..f108b8e 100644
--- a/tests/robotests/src/com/android/settings/accessibility/AccessibilityShortcutPreferenceFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/AccessibilityShortcutPreferenceFragmentTest.java
@@ -28,15 +28,24 @@
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+import static org.robolectric.Shadows.shadowOf;
 
+import android.app.Activity;
+import android.app.Application;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.DialogInterface;
+import android.content.Intent;
+import android.icu.text.CaseMap;
 import android.os.Bundle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.accessibility.Flags;
 import android.widget.PopupWindow;
 
 import androidx.annotation.Nullable;
@@ -46,9 +55,14 @@
 import androidx.preference.PreferenceScreen;
 import androidx.test.core.app.ApplicationProvider;
 
+import com.android.settings.R;
+import com.android.settings.SettingsActivity;
+import com.android.settings.SubSettings;
+import com.android.settings.accessibility.shortcuts.EditShortcutsPreferenceFragment;
 import com.android.settings.testutils.shadow.ShadowFragment;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
@@ -60,13 +74,14 @@
 import org.robolectric.shadow.api.Shadow;
 import org.robolectric.shadows.ShadowApplication;
 
+import java.util.Locale;
+
 /** Tests for {@link AccessibilityShortcutPreferenceFragment} */
 @RunWith(RobolectricTestRunner.class)
 @Config(shadows = {
         com.android.settings.testutils.shadow.ShadowFragment.class,
 })
 public class AccessibilityShortcutPreferenceFragmentTest {
-
     private static final String PLACEHOLDER_PACKAGE_NAME = "com.placeholder.example";
     private static final String PLACEHOLDER_CLASS_NAME = PLACEHOLDER_PACKAGE_NAME + ".placeholder";
     private static final String PLACEHOLDER_TILE_CLASS_NAME =
@@ -83,7 +98,8 @@
             Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS;
     private static final String HARDWARE_SHORTCUT_KEY =
             Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE;
-
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     private TestAccessibilityShortcutPreferenceFragment mFragment;
     private PreferenceScreen mScreen;
     private Context mContext = ApplicationProvider.getApplicationContext();
@@ -206,6 +222,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     @Config(shadows = ShadowFragment.class)
     public void restoreValueFromSavedInstanceState_showTooltipView() {
         mContext.setTheme(androidx.appcompat.R.style.Theme_AppCompat);
@@ -223,6 +240,15 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    @Config(shadows = ShadowFragment.class)
+    public void showQuickSettingsTooltipIfNeeded_qsFlagOn_dontShowTooltipView() {
+        mFragment.showQuickSettingsTooltipIfNeeded(QuickSettingsTooltipType.GUIDE_TO_EDIT);
+
+        assertThat(getLatestPopupWindow()).isNull();
+    }
+
+    @Test
     @Config(shadows = ShadowFragment.class)
     public void showGeneralCategory_shouldInitCategory() {
         final Bundle savedInstanceState = new Bundle();
@@ -238,6 +264,50 @@
         assertThat(mFragment.getGeneralCategoryDescription(null)).isNotNull();
     }
 
+    @Test
+    @EnableFlags(com.android.settings.accessibility.Flags.FLAG_EDIT_SHORTCUTS_IN_FULL_SCREEN)
+    public void onSettingsClicked_editShortcutsFullScreenFlagOn_showFullScreenEditShortcutScreen() {
+        Activity activity = Robolectric.setupActivity(FragmentActivity.class);
+        when(mFragment.getContext()).thenReturn(activity);
+        Context context = mFragment.getContext();
+        final ShortcutPreference shortcutPreference =
+                new ShortcutPreference(context, /* attrs= */ null);
+
+        mFragment.onSettingsClicked(shortcutPreference);
+
+        Intent intent = shadowOf(
+                (Application) context.getApplicationContext()).getNextStartedActivity();
+        assertThat(intent).isNotNull();
+        assertThat(intent.getAction()).isEqualTo(Intent.ACTION_MAIN);
+        assertThat(intent.getComponent()).isEqualTo(
+                new ComponentName(context, SubSettings.class));
+        assertThat(intent.getExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT))
+                .isEqualTo(EditShortcutsPreferenceFragment.class.getName());
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void getShortcutTypeSummary_shortcutSummaryIsCorrectlySet() {
+        final PreferredShortcut userPreferredShortcut = new PreferredShortcut(
+                PLACEHOLDER_COMPONENT_NAME.flattenToString(),
+                UserShortcutType.HARDWARE | UserShortcutType.QUICK_SETTINGS);
+        putUserShortcutTypeIntoSharedPreference(mContext, userPreferredShortcut);
+        final ShortcutPreference shortcutPreference =
+                new ShortcutPreference(mContext, /* attrs= */ null);
+        shortcutPreference.setChecked(true);
+        shortcutPreference.setSettingsEditable(true);
+        mFragment.mShortcutPreference = shortcutPreference;
+        String expected = CaseMap.toTitle().wholeString().noLowercase().apply(Locale.getDefault(),
+                /* iter= */ null,
+                mContext.getString(
+                        R.string.accessibility_feature_shortcut_setting_summary_quick_settings)
+                        + ", "
+                        + mContext.getString(R.string.accessibility_shortcut_hardware_keyword));
+
+        String summary = mFragment.getShortcutTypeSummary(mContext).toString();
+        assertThat(summary).isEqualTo(expected);
+    }
+
     private void callEmptyOnClicked(DialogInterface dialog, int which) {}
 
     private void putStringIntoSettings(String key, String componentName) {
diff --git a/tests/robotests/src/com/android/settings/accessibility/AccessibilityUtilTest.java b/tests/robotests/src/com/android/settings/accessibility/AccessibilityUtilTest.java
index 7825677..2d5deeb 100644
--- a/tests/robotests/src/com/android/settings/accessibility/AccessibilityUtilTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/AccessibilityUtilTest.java
@@ -18,6 +18,10 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
 import android.accessibilityservice.AccessibilityServiceInfo;
 import android.content.ComponentName;
 import android.content.Context;
@@ -25,20 +29,30 @@
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
 import android.os.Build;
+import android.os.UserHandle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.Flags;
 
 import androidx.test.core.app.ApplicationProvider;
 
+import com.android.internal.accessibility.util.ShortcutUtils;
 import com.android.settings.R;
 import com.android.settings.accessibility.AccessibilityUtil.UserShortcutType;
+import com.android.settings.testutils.AccessibilityTestUtils;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 import org.xmlpull.v1.XmlPullParserException;
 
 import java.io.IOException;
+import java.util.Set;
 import java.util.StringJoiner;
 
 @RunWith(RobolectricTestRunner.class)
@@ -55,14 +69,18 @@
             Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS;
     private static final String HARDWARE_SHORTCUT_KEY =
             Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE;
+    private static final String QUICK_SETTINGS_SHORTCUT_KEY =
+            Settings.Secure.ACCESSIBILITY_QS_TARGETS;
 
     private static final String PLACEHOLDER_SETTING_FEATURE = "placeholderSettingFeature";
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
 
     private Context mContext;
 
     @Before
     public void setUp() {
-        mContext = ApplicationProvider.getApplicationContext();
+        mContext = spy(ApplicationProvider.getApplicationContext());
     }
 
     @Test
@@ -151,11 +169,12 @@
     public void getUserShortcutTypeFromSettings_putOneValue_hasValue() {
         setShortcut(UserShortcutType.SOFTWARE, MOCK_COMPONENT_NAME.flattenToString());
 
-        final int shortcutType = AccessibilityUtil.getUserShortcutTypesFromSettings(mContext,
+        final int shortcutTypes = AccessibilityUtil.getUserShortcutTypesFromSettings(mContext,
                 MOCK_COMPONENT_NAME);
 
-        assertThat(
-                (shortcutType & UserShortcutType.SOFTWARE) == UserShortcutType.SOFTWARE).isTrue();
+        assertThat(shortcutTypes).isEqualTo(
+                UserShortcutType.SOFTWARE
+        );
     }
 
     @Test
@@ -163,16 +182,34 @@
         setShortcut(UserShortcutType.SOFTWARE, MOCK_COMPONENT_NAME.flattenToString());
         setShortcut(UserShortcutType.HARDWARE, MOCK_COMPONENT_NAME.flattenToString());
 
-        final int shortcutType = AccessibilityUtil.getUserShortcutTypesFromSettings(mContext,
+        final int shortcutTypes = AccessibilityUtil.getUserShortcutTypesFromSettings(mContext,
                 MOCK_COMPONENT_NAME);
 
-        assertThat(
-                (shortcutType & UserShortcutType.SOFTWARE) == UserShortcutType.SOFTWARE).isTrue();
-        assertThat(
-                (shortcutType & UserShortcutType.HARDWARE) == UserShortcutType.HARDWARE).isTrue();
+        assertThat(shortcutTypes).isEqualTo(
+                UserShortcutType.SOFTWARE
+                        | UserShortcutType.HARDWARE
+        );
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void getUserShortcutTypeFromSettings_threeShortcutTypesChosen() {
+        setShortcut(UserShortcutType.SOFTWARE, MOCK_COMPONENT_NAME.flattenToString());
+        setShortcut(UserShortcutType.HARDWARE, MOCK_COMPONENT_NAME.flattenToString());
+        setShortcut(UserShortcutType.QUICK_SETTINGS, MOCK_COMPONENT_NAME.flattenToString());
+
+        final int shortcutTypes = AccessibilityUtil.getUserShortcutTypesFromSettings(mContext,
+                MOCK_COMPONENT_NAME);
+
+        assertThat(shortcutTypes).isEqualTo(
+                UserShortcutType.SOFTWARE
+                        | UserShortcutType.HARDWARE
+                        | UserShortcutType.QUICK_SETTINGS
+        );
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optInAllValuesToSettings_optInValue_haveMatchString() {
         clearShortcuts();
         int shortcutTypes = UserShortcutType.SOFTWARE | UserShortcutType.HARDWARE;
@@ -187,6 +224,24 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void optInAllValuesToSettings_optInValue_callsA11yManager() {
+        AccessibilityManager a11yManager =
+                AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
+        Set<String> shortcutTargets = Set.of(MOCK_COMPONENT_NAME.flattenToString());
+        int shortcutTypes = UserShortcutType.SOFTWARE | UserShortcutType.HARDWARE
+                | UserShortcutType.QUICK_SETTINGS;
+
+        AccessibilityUtil.optInAllValuesToSettings(mContext, shortcutTypes, MOCK_COMPONENT_NAME);
+
+        verify(a11yManager).enableShortcutsForTargets(
+                /* enable= */ true, shortcutTypes,
+                shortcutTargets, UserHandle.myUserId());
+        verifyNoMoreInteractions(a11yManager);
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optInValueToSettings_optInValue_haveMatchString() {
         setShortcut(UserShortcutType.SOFTWARE, MOCK_COMPONENT_NAME.flattenToString());
 
@@ -199,6 +254,23 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void optInValueToSettings_optInValue_callsA11yManager() {
+        AccessibilityManager a11yManager =
+                AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
+        Set<String> shortcutTargets = Set.of(MOCK_COMPONENT_NAME2.flattenToString());
+
+        AccessibilityUtil.optInValueToSettings(
+                mContext, UserShortcutType.HARDWARE, MOCK_COMPONENT_NAME2);
+
+        verify(a11yManager).enableShortcutsForTargets(
+                /* enable= */ true, UserShortcutType.HARDWARE,
+                shortcutTargets, UserHandle.myUserId());
+        verifyNoMoreInteractions(a11yManager);
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optInValueToSettings_optInTwoValues_haveMatchString() {
         setShortcut(UserShortcutType.SOFTWARE, MOCK_COMPONENT_NAME.flattenToString());
 
@@ -213,6 +285,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optOutAllValuesToSettings_optOutValue_emptyString() {
         setShortcut(UserShortcutType.SOFTWARE, MOCK_COMPONENT_NAME.flattenToString());
         setShortcut(UserShortcutType.HARDWARE, MOCK_COMPONENT_NAME.flattenToString());
@@ -227,6 +300,27 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void optOutAllValuesToSettings_optOutValue_callsA1yManager() {
+        AccessibilityManager a11yManager =
+                AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
+        int shortcutTypes =
+                UserShortcutType.SOFTWARE | UserShortcutType.HARDWARE
+                        | UserShortcutType.QUICK_SETTINGS;
+        Set<String> shortcutTargets = Set.of(MOCK_COMPONENT_NAME.flattenToString());
+
+        AccessibilityUtil.optOutAllValuesFromSettings(mContext, shortcutTypes,
+                MOCK_COMPONENT_NAME);
+
+        verify(a11yManager).enableShortcutsForTargets(
+                /* enable= */ false,
+                shortcutTypes,
+                shortcutTargets, UserHandle.myUserId());
+        verifyNoMoreInteractions(a11yManager);
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optOutValueFromSettings_optOutValue_emptyString() {
         setShortcut(UserShortcutType.SOFTWARE, MOCK_COMPONENT_NAME.flattenToString());
 
@@ -237,6 +331,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optOutValueFromSettings_optOutValue_haveMatchString() {
         setShortcut(UserShortcutType.SOFTWARE, MOCK_COMPONENT_NAME.flattenToString(),
                 MOCK_COMPONENT_NAME2.flattenToString());
@@ -248,6 +343,55 @@
                 MOCK_COMPONENT_NAME.flattenToString());
     }
 
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void optOutValueFromSettings_optOutValue_callsA11yManager() {
+        AccessibilityManager a11yManager =
+                AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
+        Set<String> shortcutTargets = Set.of(MOCK_COMPONENT_NAME.flattenToString());
+
+        AccessibilityUtil.optOutValueFromSettings(
+                mContext, UserShortcutType.QUICK_SETTINGS, MOCK_COMPONENT_NAME);
+
+        verify(a11yManager).enableShortcutsForTargets(
+                /* enable= */ false, UserShortcutType.QUICK_SETTINGS,
+                shortcutTargets, UserHandle.myUserId());
+        verifyNoMoreInteractions(a11yManager);
+    }
+
+    @Test
+    public void convertKeyFromSettings_shortcutTypeSoftware() {
+        assertThat(AccessibilityUtil.convertKeyFromSettings(UserShortcutType.SOFTWARE))
+                .isEqualTo(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS);
+    }
+
+    @Test
+    public void convertKeyFromSettings_shortcutTypeHardware() {
+        assertThat(AccessibilityUtil.convertKeyFromSettings(UserShortcutType.HARDWARE))
+                .isEqualTo(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE);
+    }
+
+    @Test
+    public void convertKeyFromSettings_shortcutTypeTripleTap() {
+        assertThat(AccessibilityUtil.convertKeyFromSettings(UserShortcutType.TRIPLETAP))
+                .isEqualTo(Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED);
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void convertKeyFromSettings_shortcutTypeMultiFingersMultiTap() {
+        assertThat(AccessibilityUtil.convertKeyFromSettings(UserShortcutType.TWOFINGER_DOUBLETAP))
+                .isEqualTo(
+                        Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED);
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void convertKeyFromSettings_shortcutTypeQuickSettings() {
+        assertThat(AccessibilityUtil.convertKeyFromSettings(UserShortcutType.QUICK_SETTINGS))
+                .isEqualTo(Settings.Secure.ACCESSIBILITY_QS_TARGETS);
+    }
+
     private AccessibilityServiceInfo getMockAccessibilityServiceInfo() {
         final ApplicationInfo applicationInfo = new ApplicationInfo();
         final ServiceInfo serviceInfo = new ServiceInfo();
@@ -287,12 +431,12 @@
             shortcutComponents.add(componentName);
         }
         Settings.Secure.putString(mContext.getContentResolver(),
-                shortcutType == UserShortcutType.SOFTWARE ? SOFTWARE_SHORTCUT_KEY
-                        : HARDWARE_SHORTCUT_KEY, shortcutComponents.toString());
+                ShortcutUtils.convertToKey(shortcutType), shortcutComponents.toString());
     }
 
     private void clearShortcuts() {
         Settings.Secure.putString(mContext.getContentResolver(), SOFTWARE_SHORTCUT_KEY, "");
         Settings.Secure.putString(mContext.getContentResolver(), HARDWARE_SHORTCUT_KEY, "");
+        Settings.Secure.putString(mContext.getContentResolver(), QUICK_SETTINGS_SHORTCUT_KEY, "");
     }
 }
diff --git a/tests/robotests/src/com/android/settings/accessibility/HearingDevicePairingFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/HearingDevicePairingFragmentTest.java
index e14686e..db82be6 100644
--- a/tests/robotests/src/com/android/settings/accessibility/HearingDevicePairingFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/HearingDevicePairingFragmentTest.java
@@ -178,7 +178,7 @@
     }
 
     @Test
-    public void handleLeScanResult_isNotAndroidCompatible_() {
+    public void handleLeScanResult_isNotAndroidCompatible_discoverServices() {
         ScanResult scanResult = mock(ScanResult.class);
         doReturn(mDevice).when(scanResult).getDevice();
         doReturn(mCachedDevice).when(mCachedDeviceManager).findDevice(mDevice);
@@ -190,6 +190,19 @@
     }
 
     @Test
+    public void handleLeScanResult_alreadyBonded_doNothing() {
+        ScanResult scanResult = mock(ScanResult.class);
+        doReturn(mDevice).when(scanResult).getDevice();
+        doReturn(mCachedDevice).when(mCachedDeviceManager).findDevice(mDevice);
+        doReturn(BluetoothDevice.BOND_BONDED).when(mCachedDevice).getBondState();
+
+        mFragment.handleLeScanResult(scanResult);
+
+        verify(mFragment, never()).addDevice(mCachedDevice);
+        verify(mFragment, never()).discoverServices(mCachedDevice);
+    }
+
+    @Test
     public void onProfileConnectionStateChanged_deviceConnected_inSelectedList_finish() {
         doReturn(true).when(mCachedDevice).isConnected();
         mFragment.mSelectedDeviceList.add(mDevice);
diff --git a/tests/robotests/src/com/android/settings/accessibility/KeyboardVibrationTogglePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/KeyboardVibrationTogglePreferenceControllerTest.java
index 2d5905e..832a313 100644
--- a/tests/robotests/src/com/android/settings/accessibility/KeyboardVibrationTogglePreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/KeyboardVibrationTogglePreferenceControllerTest.java
@@ -30,6 +30,7 @@
 import static org.mockito.Mockito.verify;
 
 import android.app.settings.SettingsEnums;
+import android.content.ContentResolver;
 import android.content.Context;
 import android.content.res.Resources;
 import android.os.vibrator.Flags;
@@ -60,6 +61,9 @@
     @Mock
     private PreferenceScreen mPreferenceScreen;
 
+    @Mock
+    private ContentResolver mContentResolver;
+
     private Context mContext;
     private Resources mResources;
     private KeyboardVibrationTogglePreferenceController mController;
@@ -72,6 +76,7 @@
         mContext = spy(ApplicationProvider.getApplicationContext());
         mResources = spy(mContext.getResources());
         when(mContext.getResources()).thenReturn(mResources);
+        when(mContext.getContentResolver()).thenReturn(mContentResolver);
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         mController = new KeyboardVibrationTogglePreferenceController(mContext, "preferenceKey");
         mPreference = new SwitchPreference(mContext);
diff --git a/tests/robotests/src/com/android/settings/accessibility/MagnificationOneFingerPanningPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/MagnificationOneFingerPanningPreferenceControllerTest.java
index 326a7a0..4501d27 100644
--- a/tests/robotests/src/com/android/settings/accessibility/MagnificationOneFingerPanningPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/MagnificationOneFingerPanningPreferenceControllerTest.java
@@ -16,7 +16,6 @@
 
 package com.android.settings.accessibility;
 
-import static com.android.server.accessibility.Flags.enableMagnificationOneFingerPanningGesture;
 import static com.android.settings.accessibility.AccessibilityUtil.State.OFF;
 import static com.android.settings.accessibility.AccessibilityUtil.State.ON;
 import static com.android.settings.core.BasePreferenceController.AVAILABLE;
@@ -28,7 +27,10 @@
 import static org.mockito.Mockito.verify;
 
 import android.content.Context;
-import android.platform.test.flag.junit.SetFlagsRule;
+import android.platform.test.annotations.RequiresFlagsDisabled;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
 import android.provider.Settings;
 
 import androidx.preference.PreferenceManager;
@@ -51,8 +53,9 @@
     private static final String ONE_FINGER_PANNING_KEY =
             Settings.Secure.ACCESSIBILITY_SINGLE_FINGER_PANNING_ENABLED;
 
-    @Rule public final SetFlagsRule mSetFlagsRule =
-            new SetFlagsRule(SetFlagsRule.DefaultInitValueType.DEVICE_DEFAULT);
+    @Rule
+    public final CheckFlagsRule mCheckFlagsRule =
+            DeviceFlagsValueProvider.createCheckFlagsRule();
 
     private final Context mContext = ApplicationProvider.getApplicationContext();
     private final SwitchPreference mSwitchPreference = spy(new SwitchPreference(mContext));
@@ -88,16 +91,16 @@
     }
 
     @Test
-    public void getAvailabilityStatus_defaultState_disabled() {
+    @RequiresFlagsDisabled(Flags.FLAG_ENABLE_MAGNIFICATION_ONE_FINGER_PANNING_GESTURE)
+    public void getAvailabilityStatus_flagDisabled_disabled() {
         int status = mController.getAvailabilityStatus();
 
         assertThat(status).isEqualTo(DISABLED_FOR_USER);
     }
 
     @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_ONE_FINGER_PANNING_GESTURE)
     public void getAvailabilityStatus_featureFlagEnabled_enabled() {
-        enableFlag();
-
         int status = mController.getAvailabilityStatus();
 
         assertThat(status).isEqualTo(AVAILABLE);
@@ -158,9 +161,8 @@
     }
 
     @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_ONE_FINGER_PANNING_GESTURE)
     public void performClick_switchDefaultState_shouldReturnTrue() {
-        enableFlag();
-
         mSwitchPreference.performClick();
 
         verify(mSwitchPreference).setChecked(true);
@@ -168,13 +170,6 @@
         assertThat(mSwitchPreference.isChecked()).isTrue();
     }
 
-    private void enableFlag() {
-        mSetFlagsRule.enableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_ONE_FINGER_PANNING_GESTURE);
-        assertThat(enableMagnificationOneFingerPanningGesture()).isTrue();
-        // This ensures that preference change listeners are added correctly.
-        mController.displayPreference(mScreen);
-    }
-
     private String enabledSummary() {
         return mContext.getString(
                 R.string.accessibility_magnification_one_finger_panning_summary_on);
diff --git a/tests/robotests/src/com/android/settings/accessibility/ToggleColorInversionPreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/ToggleColorInversionPreferenceFragmentTest.java
index 9155113..1a82a25 100644
--- a/tests/robotests/src/com/android/settings/accessibility/ToggleColorInversionPreferenceFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/ToggleColorInversionPreferenceFragmentTest.java
@@ -31,10 +31,13 @@
 import android.content.ComponentName;
 import android.content.Context;
 import android.os.Bundle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.accessibility.Flags;
 import android.widget.PopupWindow;
 
 import androidx.fragment.app.FragmentActivity;
@@ -49,6 +52,7 @@
 import com.android.settings.widget.SettingsMainSwitchPreference;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
@@ -65,6 +69,8 @@
 @RunWith(RobolectricTestRunner.class)
 @Config(shadows = ShadowFragment.class)
 public class ToggleColorInversionPreferenceFragmentTest {
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     private final Context mContext = ApplicationProvider.getApplicationContext();
     private TestToggleColorInversionPreferenceFragment mFragment;
     private PreferenceScreen mScreen;
@@ -131,6 +137,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void onPreferenceToggled_colorCorrectDisabled_shouldReturnTrueAndShowTooltipView() {
         Settings.Secure.putInt(mContext.getContentResolver(),
                 Settings.Secure.ACCESSIBILITY_DISPLAY_INVERSION_ENABLED, OFF);
diff --git a/tests/robotests/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragmentTest.java
index 94db63b..850d1d79 100644
--- a/tests/robotests/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragmentTest.java
@@ -35,10 +35,13 @@
 import android.content.ComponentName;
 import android.content.Context;
 import android.os.Bundle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.accessibility.Flags;
 import android.widget.PopupWindow;
 
 import androidx.fragment.app.FragmentActivity;
@@ -54,6 +57,7 @@
 import com.android.settingslib.widget.SelectorWithWidgetPreference;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
@@ -70,6 +74,8 @@
 @RunWith(RobolectricTestRunner.class)
 @Config(shadows = ShadowFragment.class)
 public class ToggleDaltonizerPreferenceFragmentTest {
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     private final Context mContext = ApplicationProvider.getApplicationContext();
     private TestToggleDaltonizerPreferenceFragment mFragment;
     private PreferenceScreen mScreen;
@@ -154,6 +160,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void onPreferenceToggled_colorCorrectDisabled_shouldReturnTrueAndShowTooltipView() {
         Settings.Secure.putInt(mContext.getContentResolver(),
                 Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, OFF);
diff --git a/tests/robotests/src/com/android/settings/accessibility/ToggleFeaturePreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/ToggleFeaturePreferenceFragmentTest.java
index 70c7cd6..6fb1c3f 100644
--- a/tests/robotests/src/com/android/settings/accessibility/ToggleFeaturePreferenceFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/ToggleFeaturePreferenceFragmentTest.java
@@ -24,6 +24,7 @@
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -34,10 +35,11 @@
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.pm.PackageManager;
+import android.icu.text.CaseMap;
 import android.os.Bundle;
-import android.platform.test.annotations.RequiresFlagsEnabled;
-import android.platform.test.flag.junit.CheckFlagsRule;
-import android.platform.test.flag.junit.DeviceFlagsValueProvider;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -76,6 +78,8 @@
 import org.robolectric.shadow.api.Shadow;
 import org.robolectric.shadows.ShadowApplication;
 
+import java.util.Locale;
+
 /** Tests for {@link ToggleFeaturePreferenceFragment} */
 @RunWith(RobolectricTestRunner.class)
 @LooperMode(LooperMode.Mode.LEGACY)
@@ -83,9 +87,8 @@
         ShadowFragment.class,
 })
 public class ToggleFeaturePreferenceFragmentTest {
-
     @Rule
-    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
 
     private static final String PLACEHOLDER_PACKAGE_NAME = "com.placeholder.example";
     private static final String PLACEHOLDER_CLASS_NAME = PLACEHOLDER_PACKAGE_NAME + ".placeholder";
@@ -144,8 +147,9 @@
     }
 
     @Test
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     @Config(shadows = {ShadowFragment.class})
-    public void onResume_haveRegisterToSpecificUris() {
+    public void onResume_flagEnabled_haveRegisterToSpecificUris() {
         mFragment.onAttach(mContext);
         mFragment.onCreate(Bundle.EMPTY);
 
@@ -160,6 +164,36 @@
                         Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE)),
                 eq(false),
                 any(AccessibilitySettingsContentObserver.class));
+        verify(mContentResolver).registerContentObserver(
+                eq(Settings.Secure.getUriFor(
+                        Settings.Secure.ACCESSIBILITY_QS_TARGETS)),
+                eq(false),
+                any(AccessibilitySettingsContentObserver.class));
+    }
+
+    @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    @Config(shadows = {ShadowFragment.class})
+    public void onResume_flagDisabled_haveRegisterToSpecificUris() {
+        mFragment.onAttach(mContext);
+        mFragment.onCreate(Bundle.EMPTY);
+
+        mFragment.onResume();
+
+        verify(mContentResolver).registerContentObserver(
+                eq(Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS)),
+                eq(false),
+                any(AccessibilitySettingsContentObserver.class));
+        verify(mContentResolver).registerContentObserver(
+                eq(Settings.Secure.getUriFor(
+                        Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE)),
+                eq(false),
+                any(AccessibilitySettingsContentObserver.class));
+        verify(mContentResolver, never()).registerContentObserver(
+                eq(Settings.Secure.getUriFor(
+                        Settings.Secure.ACCESSIBILITY_QS_TARGETS)),
+                eq(false),
+                any(AccessibilitySettingsContentObserver.class));
     }
 
     @Test
@@ -295,6 +329,7 @@
     }
 
     @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     @Config(shadows = ShadowFragment.class)
     public void onPreferenceToggledOnEnabledService_showTooltipView() {
         mFragment.onPreferenceToggled(
@@ -304,7 +339,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(com.android.settings.accessibility.Flags.FLAG_REMOVE_QS_TOOLTIP_IN_SUW)
+    @EnableFlags(com.android.settings.accessibility.Flags.FLAG_REMOVE_QS_TOOLTIP_IN_SUW)
     @Config(shadows = ShadowFragment.class)
     public void onPreferenceToggledOnEnabledService_inSuw_toolTipViewShouldNotShow() {
         Intent suwIntent = new Intent();
@@ -318,6 +353,7 @@
     }
 
     @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     @Config(shadows = ShadowFragment.class)
     public void onPreferenceToggledOnEnabledService_tooltipViewShown_notShowTooltipView() {
         mFragment.onPreferenceToggled(
@@ -348,7 +384,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ACCESSIBILITY_SHOW_APP_INFO_BUTTON)
+    @EnableFlags(Flags.FLAG_ACCESSIBILITY_SHOW_APP_INFO_BUTTON)
     public void createAppInfoPreference_withValidComponentName() {
         when(mPackageManager.isPackageAvailable(PLACEHOLDER_PACKAGE_NAME)).thenReturn(true);
         mFragment.mComponentName = PLACEHOLDER_COMPONENT_NAME;
@@ -363,7 +399,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ACCESSIBILITY_SHOW_APP_INFO_BUTTON)
+    @EnableFlags(Flags.FLAG_ACCESSIBILITY_SHOW_APP_INFO_BUTTON)
     public void createAppInfoPreference_noComponentName_shouldBeNull() {
         mFragment.mComponentName = null;
 
@@ -373,7 +409,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ACCESSIBILITY_SHOW_APP_INFO_BUTTON)
+    @EnableFlags(Flags.FLAG_ACCESSIBILITY_SHOW_APP_INFO_BUTTON)
     public void createAppInfoPreference_withUnavailablePackage_shouldBeNull() {
         when(mPackageManager.isPackageAvailable(PLACEHOLDER_PACKAGE_NAME)).thenReturn(false);
         mFragment.mComponentName = PLACEHOLDER_COMPONENT_NAME;
@@ -384,7 +420,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ACCESSIBILITY_SHOW_APP_INFO_BUTTON)
+    @EnableFlags(Flags.FLAG_ACCESSIBILITY_SHOW_APP_INFO_BUTTON)
     public void createAppInfoPreference_inSetupWizard_shouldBeNull() {
         when(mFragment.isAnySetupWizard()).thenReturn(true);
         mFragment.mComponentName = PLACEHOLDER_COMPONENT_NAME;
@@ -421,6 +457,40 @@
                 .isEqualTo(PLACEHOLDER_COMPONENT_NAME.flattenToString());
     }
 
+    @Test
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    @Config(shadows = ShadowFragment.class)
+    public void showQuickSettingsTooltipIfNeeded_qsFlagOn_dontShowTooltipView() {
+        mFragment.showQuickSettingsTooltipIfNeeded(QuickSettingsTooltipType.GUIDE_TO_EDIT);
+
+        assertThat(getLatestPopupWindow()).isNull();
+    }
+
+    @Test
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void getShortcutTypeSummary_shortcutSummaryIsCorrectlySet() {
+        final PreferredShortcut userPreferredShortcut = new PreferredShortcut(
+                PLACEHOLDER_COMPONENT_NAME.flattenToString(),
+                UserShortcutType.HARDWARE | UserShortcutType.QUICK_SETTINGS);
+        putUserShortcutTypeIntoSharedPreference(mContext, userPreferredShortcut);
+        final ShortcutPreference shortcutPreference =
+                new ShortcutPreference(mContext, /* attrs= */ null);
+        shortcutPreference.setChecked(true);
+        shortcutPreference.setSettingsEditable(true);
+        mFragment.mComponentName = PLACEHOLDER_COMPONENT_NAME;
+        mFragment.mShortcutPreference = shortcutPreference;
+        String expected = CaseMap.toTitle().wholeString().noLowercase().apply(Locale.getDefault(),
+                /* iter= */ null,
+                mContext.getString(
+                        R.string.accessibility_feature_shortcut_setting_summary_quick_settings)
+                        + ", "
+                        + mContext.getString(R.string.accessibility_shortcut_hardware_keyword));
+
+        String summary = mFragment.getShortcutTypeSummary(mContext).toString();
+
+        assertThat(summary).isEqualTo(expected);
+    }
+
     private void putSecureStringIntoSettings(String key, String componentName) {
         Settings.Secure.putString(mContext.getContentResolver(), key, componentName);
     }
diff --git a/tests/robotests/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentTest.java
index b459faa..1d85705 100644
--- a/tests/robotests/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentTest.java
@@ -30,6 +30,7 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
 import android.app.settings.SettingsEnums;
@@ -39,13 +40,16 @@
 import android.content.pm.PackageManager;
 import android.content.res.Resources;
 import android.database.ContentObserver;
+import android.icu.text.CaseMap;
 import android.net.Uri;
 import android.os.Bundle;
-import android.platform.test.annotations.RequiresFlagsEnabled;
-import android.platform.test.flag.junit.CheckFlagsRule;
-import android.platform.test.flag.junit.DeviceFlagsValueProvider;
+import android.os.UserHandle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.DeviceConfig;
 import android.provider.Settings;
+import android.view.accessibility.AccessibilityManager;
 
 import androidx.appcompat.app.AlertDialog;
 import androidx.preference.Preference;
@@ -57,6 +61,7 @@
 import com.android.settings.R;
 import com.android.settings.SettingsActivity;
 import com.android.settings.accessibility.AccessibilityDialogUtils.DialogType;
+import com.android.settings.testutils.AccessibilityTestUtils;
 import com.android.settings.testutils.shadow.ShadowDeviceConfig;
 import com.android.settings.testutils.shadow.ShadowStorageManager;
 import com.android.settings.testutils.shadow.ShadowUserManager;
@@ -80,6 +85,8 @@
 
 import java.util.Collection;
 import java.util.List;
+import java.util.Locale;
+import java.util.Set;
 
 /** Tests for {@link ToggleScreenMagnificationPreferenceFragment}. */
 @RunWith(RobolectricTestRunner.class)
@@ -92,7 +99,7 @@
 public class ToggleScreenMagnificationPreferenceFragmentTest {
 
     @Rule
-    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
 
     private static final String PLACEHOLDER_PACKAGE_NAME = "com.mock.example";
     private static final String PLACEHOLDER_CLASS_NAME =
@@ -122,13 +129,15 @@
 
     private FragmentController<ToggleScreenMagnificationPreferenceFragment> mFragController;
     private Context mContext;
+    private AccessibilityManager mAccessibilityManager;
     private Resources mSpyResources;
     private ShadowPackageManager mShadowPackageManager;
 
     @Before
     public void setUpTestFragment() {
 
-        mContext = ApplicationProvider.getApplicationContext();
+        mContext = spy(ApplicationProvider.getApplicationContext());
+        mAccessibilityManager = AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
 
         // Set up the fragment that support window magnification feature
         mSpyResources = spy(mContext.getResources());
@@ -283,7 +292,39 @@
     }
 
     @Test
-    public void onResume_haveRegisterToSpecificUris() {
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void onResume_flagEnabled_haveRegisterToSpecificUris() {
+        ShadowContentResolver shadowContentResolver = Shadows.shadowOf(
+                mContext.getContentResolver());
+        Uri[] observedUri = new Uri[]{
+                Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS),
+                Settings.Secure.getUriFor(
+                        Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE),
+                Settings.Secure.getUriFor(
+                        Settings.Secure.ACCESSIBILITY_QS_TARGETS),
+                Settings.Secure.getUriFor(
+                        Settings.Secure.ACCESSIBILITY_MAGNIFICATION_FOLLOW_TYPING_ENABLED),
+                Settings.Secure.getUriFor(
+                        Settings.Secure.ACCESSIBILITY_MAGNIFICATION_ALWAYS_ON_ENABLED)
+        };
+        for (Uri uri : observedUri) {
+            // verify no observer registered before launching the fragment
+            assertThat(shadowContentResolver.getContentObservers(uri)).isEmpty();
+        }
+
+        mFragController.create(R.id.main_content, /* bundle= */ null).start().resume();
+
+        for (Uri uri : observedUri) {
+            Collection<ContentObserver> observers = shadowContentResolver.getContentObservers(uri);
+            assertThat(observers.size()).isEqualTo(1);
+            assertThat(observers.stream().findFirst().get()).isInstanceOf(
+                    AccessibilitySettingsContentObserver.class);
+        }
+    }
+
+    @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void onResume_flagDisabled_haveRegisterToSpecificUris() {
         ShadowContentResolver shadowContentResolver = Shadows.shadowOf(
                 mContext.getContentResolver());
         Uri[] observedUri = new Uri[]{
@@ -308,6 +349,9 @@
             assertThat(observers.stream().findFirst().get()).isInstanceOf(
                     AccessibilitySettingsContentObserver.class);
         }
+        assertThat(shadowContentResolver.getContentObservers(
+                Settings.Secure.getUriFor(
+                        Settings.Secure.ACCESSIBILITY_QS_TARGETS))).hasSize(0);
     }
 
     @Test
@@ -319,26 +363,27 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void hasMagnificationValuesInSettings_twoFingerTripleTapIsOn_isTrue() {
         Settings.Secure.putInt(
                 mContext.getContentResolver(), TWO_FINGER_TRIPLE_TAP_SHORTCUT_KEY, ON);
 
         assertThat(ToggleScreenMagnificationPreferenceFragment.hasMagnificationValuesInSettings(
-                mContext, UserShortcutType.TWOFINGERTRIPLETAP)).isTrue();
+                mContext, UserShortcutType.TWOFINGER_DOUBLETAP)).isTrue();
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void hasMagnificationValuesInSettings_twoFingerTripleTapIsOff_isFalse() {
         Settings.Secure.putInt(
                 mContext.getContentResolver(), TWO_FINGER_TRIPLE_TAP_SHORTCUT_KEY, OFF);
 
         assertThat(ToggleScreenMagnificationPreferenceFragment.hasMagnificationValuesInSettings(
-                mContext, UserShortcutType.TWOFINGERTRIPLETAP)).isFalse();
+                mContext, UserShortcutType.TWOFINGER_DOUBLETAP)).isFalse();
     }
 
     @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optInAllValuesToSettings_optInValue_haveMatchString() {
         int shortcutTypes = UserShortcutType.SOFTWARE | UserShortcutType.TRIPLETAP;
 
@@ -351,9 +396,36 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void optInAllValuesToSettings_optInValue_callA11yManager() {
+        int shortcutTypes =
+                UserShortcutType.SOFTWARE | UserShortcutType.TRIPLETAP | UserShortcutType.HARDWARE
+                        | UserShortcutType.QUICK_SETTINGS;
+        Set<String> shortcutTargets = Set.of(MAGNIFICATION_CONTROLLER_NAME);
+
+        ToggleScreenMagnificationPreferenceFragment.optInAllMagnificationValuesToSettings(mContext,
+                shortcutTypes);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ true, UserShortcutType.SOFTWARE,
+                shortcutTargets, UserHandle.myUserId());
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ true, UserShortcutType.HARDWARE,
+                shortcutTargets, UserHandle.myUserId());
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ true, UserShortcutType.QUICK_SETTINGS,
+                shortcutTargets, UserHandle.myUserId());
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ true, UserShortcutType.TRIPLETAP,
+                shortcutTargets, UserHandle.myUserId());
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optInAllValuesToSettings_twoFingerTripleTap_haveMatchString() {
-        int shortcutTypes = UserShortcutType.TWOFINGERTRIPLETAP;
+        int shortcutTypes = UserShortcutType.TWOFINGER_DOUBLETAP;
 
         ToggleScreenMagnificationPreferenceFragment.optInAllMagnificationValuesToSettings(mContext,
                 shortcutTypes);
@@ -363,6 +435,7 @@
     }
 
     @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optInAllValuesToSettings_existOtherValue_optInValue_haveMatchString() {
         putStringIntoSettings(SOFTWARE_SHORTCUT_KEY, PLACEHOLDER_COMPONENT_NAME.flattenToString());
 
@@ -374,6 +447,7 @@
     }
 
     @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optInAllValuesToSettings_software_sizeValueIsNull_putLargeSizeValue() {
         ShadowSettings.ShadowSecure.reset();
 
@@ -441,6 +515,7 @@
     }
 
     @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optOutAllValuesToSettings_optOutValue_emptyString() {
         putStringIntoSettings(SOFTWARE_SHORTCUT_KEY, MAGNIFICATION_CONTROLLER_NAME);
         putStringIntoSettings(HARDWARE_SHORTCUT_KEY, MAGNIFICATION_CONTROLLER_NAME);
@@ -457,19 +532,46 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void optOutAllValuesToSettings_optOutValue_callA11yManager() {
+        Set<String> shortcutTargets = Set.of(MAGNIFICATION_CONTROLLER_NAME);
+        putStringIntoSettings(SOFTWARE_SHORTCUT_KEY, MAGNIFICATION_CONTROLLER_NAME);
+        putStringIntoSettings(HARDWARE_SHORTCUT_KEY, MAGNIFICATION_CONTROLLER_NAME);
+        setMagnificationTripleTapEnabled(/* enabled= */ true);
+        int shortcutTypes =
+                UserShortcutType.SOFTWARE | UserShortcutType.HARDWARE | UserShortcutType.TRIPLETAP;
+
+        ToggleScreenMagnificationPreferenceFragment.optOutAllMagnificationValuesFromSettings(
+                mContext, shortcutTypes);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ false, UserShortcutType.SOFTWARE,
+                shortcutTargets, UserHandle.myUserId());
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ false, UserShortcutType.HARDWARE,
+                shortcutTargets, UserHandle.myUserId());
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ false, UserShortcutType.TRIPLETAP,
+                shortcutTargets, UserHandle.myUserId());
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optOutAllValuesToSettings_twoFingerTripleTap_settingsValueIsOff() {
         Settings.Secure.putInt(mContext.getContentResolver(),
                 TWO_FINGER_TRIPLE_TAP_SHORTCUT_KEY, ON);
 
         ToggleScreenMagnificationPreferenceFragment.optOutAllMagnificationValuesFromSettings(
-                mContext, UserShortcutType.TWOFINGERTRIPLETAP);
+                mContext, UserShortcutType.TWOFINGER_DOUBLETAP);
 
         assertThat(Settings.Secure.getInt(mContext.getContentResolver(),
                 TWO_FINGER_TRIPLE_TAP_SHORTCUT_KEY, ON)).isEqualTo(OFF);
     }
 
     @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void optOutValueFromSettings_existOtherValue_optOutValue_haveMatchString() {
         putStringIntoSettings(SOFTWARE_SHORTCUT_KEY,
                 PLACEHOLDER_COMPONENT_NAME.flattenToString() + ":" + MAGNIFICATION_CONTROLLER_NAME);
@@ -526,7 +628,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void updateShortcutPreferenceData_hasTwoFingerTripleTapInSettings_assignToVariable() {
         Settings.Secure.putInt(
                 mContext.getContentResolver(), TWO_FINGER_TRIPLE_TAP_SHORTCUT_KEY, ON);
@@ -536,14 +638,14 @@
 
         final int expectedType = PreferredShortcuts.retrieveUserShortcutType(mContext,
                 MAGNIFICATION_CONTROLLER_NAME);
-        assertThat(expectedType).isEqualTo(UserShortcutType.TWOFINGERTRIPLETAP);
+        assertThat(expectedType).isEqualTo(UserShortcutType.TWOFINGER_DOUBLETAP);
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void updateShortcutPreferenceData_hasTwoFingerTripleTapInSharedPref_assignToVariable() {
         final PreferredShortcut tripleTapShortcut = new PreferredShortcut(
-                MAGNIFICATION_CONTROLLER_NAME, UserShortcutType.TWOFINGERTRIPLETAP);
+                MAGNIFICATION_CONTROLLER_NAME, UserShortcutType.TWOFINGER_DOUBLETAP);
         putUserShortcutTypeIntoSharedPreference(mContext, tripleTapShortcut);
         mFragController.create(R.id.main_content, /* bundle= */ null).start().resume();
 
@@ -551,7 +653,7 @@
 
         final int expectedType = PreferredShortcuts.retrieveUserShortcutType(mContext,
                 MAGNIFICATION_CONTROLLER_NAME);
-        assertThat(expectedType).isEqualTo(UserShortcutType.TWOFINGERTRIPLETAP);
+        assertThat(expectedType).isEqualTo(UserShortcutType.TWOFINGER_DOUBLETAP);
     }
 
     @Test
@@ -590,7 +692,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void setupMagnificationEditShortcutDialog_twoFingerTripleTapOn_checkboxIsSavedValue() {
         ToggleScreenMagnificationPreferenceFragment fragment =
                 mFragController.create(R.id.main_content, /* bundle= */
@@ -598,7 +700,7 @@
         final ShortcutPreference shortcutPreference = new ShortcutPreference(mContext, /* attrs= */
                 null);
         final PreferredShortcut twoFingerTripleTapShortcut = new PreferredShortcut(
-                MAGNIFICATION_CONTROLLER_NAME, UserShortcutType.TWOFINGERTRIPLETAP);
+                MAGNIFICATION_CONTROLLER_NAME, UserShortcutType.TWOFINGER_DOUBLETAP);
         fragment.mShortcutPreference = shortcutPreference;
 
         PreferredShortcuts.saveUserShortcutType(mContext, twoFingerTripleTapShortcut);
@@ -607,7 +709,7 @@
                 createEditShortcutDialog(fragment.getActivity()));
 
         final int checkboxValue = fragment.getShortcutTypeCheckBoxValue();
-        assertThat(checkboxValue).isEqualTo(UserShortcutType.TWOFINGERTRIPLETAP);
+        assertThat(checkboxValue).isEqualTo(UserShortcutType.TWOFINGER_DOUBLETAP);
     }
 
     @Test
@@ -632,10 +734,10 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void restoreValueFromSavedInstanceState_twoFingerTripleTap_assignToVariable() {
         final Bundle fragmentState =
-                createFragmentSavedInstanceState(UserShortcutType.TWOFINGERTRIPLETAP);
+                createFragmentSavedInstanceState(UserShortcutType.TWOFINGER_DOUBLETAP);
         ToggleScreenMagnificationPreferenceFragment fragment = mFragController.get();
         // Had to use reflection to pass the savedInstanceState when launching the fragment
         ReflectionHelpers.setField(fragment, "mSavedFragmentState", fragmentState);
@@ -649,8 +751,8 @@
 
         final int expectedType = PreferredShortcuts.retrieveUserShortcutType(mContext,
                 MAGNIFICATION_CONTROLLER_NAME);
-        assertThat(value).isEqualTo(UserShortcutType.TWOFINGERTRIPLETAP);
-        assertThat(expectedType).isEqualTo(UserShortcutType.TWOFINGERTRIPLETAP);
+        assertThat(value).isEqualTo(UserShortcutType.TWOFINGER_DOUBLETAP);
+        assertThat(expectedType).isEqualTo(UserShortcutType.TWOFINGER_DOUBLETAP);
     }
 
     @Test
@@ -789,7 +891,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void getSummary_magnificationGestureEnabled_returnShortcutOnWithSummary() {
         Settings.Secure.putInt(
                 mContext.getContentResolver(), TWO_FINGER_TRIPLE_TAP_SHORTCUT_KEY, ON);
@@ -803,7 +905,7 @@
     }
 
     @Test
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void getSummary_magnificationGestureDisabled_returnShortcutOffWithSummary() {
         Settings.Secure.putInt(
                 mContext.getContentResolver(), TWO_FINGER_TRIPLE_TAP_SHORTCUT_KEY, OFF);
@@ -817,6 +919,33 @@
                                 mContext.getText(R.string.magnification_feature_summary)));
     }
 
+    @Test
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void getShortcutTypeSummary_shortcutSummaryIsCorrectlySet() {
+        final PreferredShortcut userPreferredShortcut = new PreferredShortcut(
+                MAGNIFICATION_CONTROLLER_NAME,
+                UserShortcutType.HARDWARE | UserShortcutType.QUICK_SETTINGS);
+        putUserShortcutTypeIntoSharedPreference(mContext, userPreferredShortcut);
+        final ShortcutPreference shortcutPreference =
+                new ShortcutPreference(mContext, /* attrs= */ null);
+        shortcutPreference.setChecked(true);
+        shortcutPreference.setSettingsEditable(true);
+        ToggleScreenMagnificationPreferenceFragment fragment =
+                mFragController.create(R.id.main_content, /* bundle= */
+                        null).start().resume().get();
+        fragment.mShortcutPreference = shortcutPreference;
+        String expected = CaseMap.toTitle().wholeString().noLowercase().apply(Locale.getDefault(),
+                /* iter= */ null,
+                mContext.getString(
+                        R.string.accessibility_feature_shortcut_setting_summary_quick_settings)
+                        + ", "
+                        + mContext.getString(R.string.accessibility_shortcut_hardware_keyword));
+
+        String summary = fragment.getShortcutTypeSummary(mContext).toString();
+
+        assertThat(summary).isEqualTo(expected);
+    }
+
     private void putStringIntoSettings(String key, String componentName) {
         Settings.Secure.putString(mContext.getContentResolver(), key, componentName);
     }
diff --git a/tests/robotests/src/com/android/settings/accessibility/shortcuts/EditShortcutsPreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/shortcuts/EditShortcutsPreferenceFragmentTest.java
index 56486d2..526b431 100644
--- a/tests/robotests/src/com/android/settings/accessibility/shortcuts/EditShortcutsPreferenceFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/shortcuts/EditShortcutsPreferenceFragmentTest.java
@@ -86,7 +86,10 @@
 /**
  * Tests for {@link EditShortcutsPreferenceFragment}
  */
-@Config(shadows = SettingsShadowResources.class)
+@Config(shadows = {
+        SettingsShadowResources.class,
+        com.android.settings.testutils.shadow.ShadowAccessibilityManager.class
+})
 @RunWith(RobolectricTestRunner.class)
 public class EditShortcutsPreferenceFragmentTest {
     private static final int METRICS_CATEGORY = 123;
@@ -99,7 +102,8 @@
     @Rule
     public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
 
-    private final Context mContext = ApplicationProvider.getApplicationContext();
+    private Context mContext = ApplicationProvider.getApplicationContext();
+
     private FragmentActivity mActivity;
     private FragmentScenario<EditShortcutsPreferenceFragment> mFragmentScenario;
 
@@ -291,7 +295,7 @@
         mFragmentScenario.onFragment(fragment -> {
             TwoStatePreference preference = fragment.findPreference(
                     mContext.getString(
-                            R.string.accessibility_shortcut_two_fingers_double_tap_pref));
+                            R.string.accessibility_shortcut_two_finger_double_tap_pref));
             assertThat(preference.isChecked()).isTrue();
         });
     }
@@ -476,7 +480,26 @@
                         ));
     }
 
+    @Test
+    public void onQuickSettingsShortcutSettingChanged_preferredShortcutsUpdated() {
+        mFragmentScenario = createFragScenario(/* isInSuw= */ false);
+        mFragmentScenario.moveToState(Lifecycle.State.CREATED);
+        int currentPreferredShortcut =
+                PreferredShortcuts.retrieveUserShortcutType(mContext, TARGET);
+        assertThat(currentPreferredShortcut
+                & ShortcutConstants.UserShortcutType.QUICK_SETTINGS).isEqualTo(0);
 
+        ShortcutUtils.optInValueToSettings(
+                mContext, ShortcutConstants.UserShortcutType.QUICK_SETTINGS, TARGET);
+
+        // Calls onFragment so that the change to Setting is notified to its observer
+        mFragmentScenario.onFragment(fragment ->
+                assertThat(
+                        PreferredShortcuts.retrieveUserShortcutType(
+                                mContext, TARGET)
+                ).isEqualTo(ShortcutConstants.UserShortcutType.QUICK_SETTINGS)
+        );
+    }
 
     private void assertLaunchSubSettingWithCurrentTargetComponents(
             String componentName, boolean isInSuw) {
diff --git a/tests/robotests/src/com/android/settings/accessibility/shortcuts/GestureShortcutOptionControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/shortcuts/GestureShortcutOptionControllerTest.java
index 010386c..155cb22 100644
--- a/tests/robotests/src/com/android/settings/accessibility/shortcuts/GestureShortcutOptionControllerTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/shortcuts/GestureShortcutOptionControllerTest.java
@@ -16,9 +16,10 @@
 
 package com.android.settings.accessibility.shortcuts;
 
+import static com.android.settings.testutils.AccessibilityTestUtils.setupMockAccessibilityManager;
+
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
 
@@ -148,8 +149,7 @@
     }
 
     private void enableTouchExploration(boolean enable) {
-        AccessibilityManager am = mock(AccessibilityManager.class);
-        when(mContext.getSystemService(AccessibilityManager.class)).thenReturn(am);
+        AccessibilityManager am = setupMockAccessibilityManager(mContext);
         when(am.isTouchExplorationEnabled()).thenReturn(enable);
     }
 }
diff --git a/tests/robotests/src/com/android/settings/accessibility/shortcuts/QuickSettingsShortcutOptionControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/shortcuts/QuickSettingsShortcutOptionControllerTest.java
new file mode 100644
index 0000000..6086b17
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/accessibility/shortcuts/QuickSettingsShortcutOptionControllerTest.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.accessibility.shortcuts;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.accessibilityservice.AccessibilityServiceInfo;
+import android.content.ComponentName;
+import android.content.Context;
+import android.os.UserHandle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.Flags;
+
+import androidx.preference.PreferenceManager;
+import androidx.preference.PreferenceScreen;
+import androidx.test.core.app.ApplicationProvider;
+
+import com.android.internal.accessibility.common.ShortcutConstants;
+import com.android.internal.accessibility.util.ShortcutUtils;
+import com.android.settings.R;
+import com.android.settings.testutils.AccessibilityTestUtils;
+import com.android.settings.testutils.shadow.SettingsShadowResources;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Tests for {@link QuickSettingsShortcutOptionController}
+ */
+@RunWith(RobolectricTestRunner.class)
+public class QuickSettingsShortcutOptionControllerTest {
+    private static final String PREF_KEY = "prefKey";
+    private static final ComponentName TARGET = new ComponentName("FakePackage", "FakeClass");
+    private static final String TARGET_FLATTEN = TARGET.flattenToString();
+    private static final ComponentName TARGET_TILE =
+            new ComponentName("FakePackage", "FakeTileClass");
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
+    private final Context mContext = spy(ApplicationProvider.getApplicationContext());
+    private QuickSettingsShortcutOptionController mController;
+    private ShortcutOptionPreference mShortcutOptionPreference;
+    private AccessibilityManager mAccessibilityManager;
+
+    private PreferenceScreen mPreferenceScreen;
+
+    @Before
+    public void setUp() {
+        SettingsShadowResources.overrideResource(
+                com.android.internal.R.bool.config_quickSettingsSupported, true);
+        mAccessibilityManager = AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
+        mController = new QuickSettingsShortcutOptionController(
+                mContext, PREF_KEY);
+        mController.setShortcutTargets(Set.of(TARGET_FLATTEN));
+        mShortcutOptionPreference = new ShortcutOptionPreference(mContext);
+        mShortcutOptionPreference.setKey(PREF_KEY);
+        mPreferenceScreen = new PreferenceManager(mContext).createPreferenceScreen(mContext);
+        mPreferenceScreen.addPreference(mShortcutOptionPreference);
+    }
+
+    @Test
+    public void displayPreference_verifyScreenTextSet() {
+        mController.displayPreference(mPreferenceScreen);
+
+        assertThat(mShortcutOptionPreference.getTitle().toString()).isEqualTo(
+                mContext.getString(
+                        R.string.accessibility_shortcut_edit_dialog_title_quick_settings));
+        assertThat(mShortcutOptionPreference.getSummary().toString()).isEqualTo(
+                mContext.getString(
+                        R.string.accessibility_shortcut_edit_dialog_summary_quick_settings));
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void isShortcutAvailable_a11yQsShortcutFlagDisabled_returnsFalse() {
+        assertThat(mController.isShortcutAvailable()).isFalse();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void isShortcutAvailable_qsNotSupported_returnsFalse() {
+        SettingsShadowResources.overrideResource(
+                com.android.internal.R.bool.config_quickSettingsSupported, false);
+
+        assertThat(mController.isShortcutAvailable()).isFalse();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void isShortcutAvailable_qsTileProvided_returnsTrue() {
+        when(mAccessibilityManager.getA11yFeatureToTileMap(UserHandle.myUserId()))
+                .thenReturn(Map.of(TARGET, TARGET_TILE));
+
+        assertThat(mController.isShortcutAvailable()).isTrue();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void isShortcutAvailable_qsTileNotProvided_returnsFalse() {
+        when(mAccessibilityManager.getA11yFeatureToTileMap(UserHandle.myUserId()))
+                .thenReturn(Collections.emptyMap());
+
+        assertThat(mController.isShortcutAvailable()).isFalse();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void isShortcutAvailable_qsTileProvided_invalidUseCase_returnFalse() {
+        AccessibilityServiceInfo mockStandardA11yService =
+                AccessibilityTestUtils.createAccessibilityServiceInfo(
+                        mContext, TARGET, /* isAlwaysOnService= */ false);
+        when(mAccessibilityManager.getA11yFeatureToTileMap(UserHandle.myUserId()))
+                .thenReturn(Map.of(TARGET, TARGET_TILE));
+        // setup target as a standard a11y service
+        when(mAccessibilityManager.getInstalledAccessibilityServiceList())
+                .thenReturn(List.of(mockStandardA11yService));
+
+        assertThat(mController.isShortcutAvailable()).isFalse();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void isShortcutAvailable_qsTileProvided_validUseCase_returnTrue() {
+        AccessibilityServiceInfo mockAlwaysOnA11yService =
+                AccessibilityTestUtils.createAccessibilityServiceInfo(
+                        mContext, TARGET, /* isAlwaysOnService= */ true);
+        when(mAccessibilityManager.getA11yFeatureToTileMap(UserHandle.myUserId()))
+                .thenReturn(Map.of(TARGET, TARGET_TILE));
+        // setup target as a always-on a11y service
+        when(mAccessibilityManager.getInstalledAccessibilityServiceList())
+                .thenReturn(List.of(mockAlwaysOnA11yService));
+
+
+        assertThat(mController.isShortcutAvailable()).isTrue();
+    }
+
+    @Test
+    public void isChecked_targetUseQsShortcut_returnTrue() {
+        ShortcutUtils.optInValueToSettings(
+                mContext, ShortcutConstants.UserShortcutType.QUICK_SETTINGS, TARGET_FLATTEN);
+
+        assertThat(mController.isChecked()).isTrue();
+    }
+
+    @Test
+    public void isChecked_targetNotUseQsShortcut_returnFalse() {
+        ShortcutUtils.optOutValueFromSettings(
+                mContext, ShortcutConstants.UserShortcutType.QUICK_SETTINGS, TARGET_FLATTEN);
+
+        assertThat(mController.isChecked()).isFalse();
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/accessibility/shortcuts/SoftwareShortcutOptionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/shortcuts/SoftwareShortcutOptionPreferenceControllerTest.java
index 1f7e019..1eeb944 100644
--- a/tests/robotests/src/com/android/settings/accessibility/shortcuts/SoftwareShortcutOptionPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/shortcuts/SoftwareShortcutOptionPreferenceControllerTest.java
@@ -22,6 +22,8 @@
 
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
 import android.accessibilityservice.AccessibilityServiceInfo;
@@ -30,14 +32,15 @@
 import android.content.Context;
 import android.content.ContextWrapper;
 import android.content.Intent;
-import android.content.pm.ApplicationInfo;
-import android.content.pm.ResolveInfo;
-import android.content.pm.ServiceInfo;
-import android.os.Build;
+import android.os.UserHandle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
 import android.text.SpannableStringBuilder;
 import android.view.View;
 import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.Flags;
 
 import androidx.fragment.app.FragmentActivity;
 
@@ -48,18 +51,18 @@
 import com.android.settings.SubSettings;
 import com.android.settings.accessibility.AccessibilityButtonFragment;
 import com.android.settings.accessibility.FloatingMenuSizePreferenceController;
+import com.android.settings.testutils.AccessibilityTestUtils;
 import com.android.settings.utils.AnnotationSpan;
 import com.android.settingslib.accessibility.AccessibilityUtils;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.Robolectric;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.Shadows;
-import org.xmlpull.v1.XmlPullParserException;
 
-import java.io.IOException;
 import java.util.List;
 import java.util.Set;
 
@@ -77,18 +80,23 @@
             new ComponentName("FakePackage", "StandardA11yService");
     private static final String SOFTWARE_SHORTCUT_SETTING_NAME =
             Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS;
-
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     private Context mContext;
+    private AccessibilityManager mAccessibilityManager;
     private TestSoftwareShortcutOptionPreferenceController mController;
 
     @Before
     public void setUp() {
         mContext = spy(Robolectric.buildActivity(FragmentActivity.class).get());
+        mAccessibilityManager = AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
 
-        AccessibilityServiceInfo mAlwaysOnServiceInfo = createAccessibilityServiceInfo(
-                TARGET_ALWAYS_ON_A11Y_SERVICE, /* isAlwaysOnService= */ true);
-        AccessibilityServiceInfo mStandardServiceInfo = createAccessibilityServiceInfo(
-                TARGET_STANDARD_A11Y_SERVICE, /* isAlwaysOnService= */ false);
+        AccessibilityServiceInfo mAlwaysOnServiceInfo =
+                AccessibilityTestUtils.createAccessibilityServiceInfo(
+                        mContext, TARGET_ALWAYS_ON_A11Y_SERVICE, /* isAlwaysOnService= */ true);
+        AccessibilityServiceInfo mStandardServiceInfo =
+                AccessibilityTestUtils.createAccessibilityServiceInfo(
+                        mContext, TARGET_STANDARD_A11Y_SERVICE, /* isAlwaysOnService= */ false);
         AccessibilityManager am = mock(AccessibilityManager.class);
         when(mContext.getSystemService(Context.ACCESSIBILITY_SERVICE)).thenReturn(am);
         when(am.getInstalledAccessibilityServiceList()).thenReturn(
@@ -170,6 +178,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_enableShortcut_shortcutTurnedOn() {
         String target = TARGET_ALWAYS_ON_A11Y_SERVICE.flattenToString();
         mController.setShortcutTargets(Set.of(target));
@@ -185,6 +194,27 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void enableShortcutForTargets_enableShortcut_callA11yManager() {
+        String target = TARGET_ALWAYS_ON_A11Y_SERVICE.flattenToString();
+        mController.setShortcutTargets(Set.of(target));
+        assertThat(ShortcutUtils.isComponentIdExistingInSettings(
+                mContext, ShortcutConstants.UserShortcutType.SOFTWARE, target
+        )).isFalse();
+
+        mController.enableShortcutForTargets(true);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ true,
+                ShortcutConstants.UserShortcutType.SOFTWARE,
+                Set.of(target),
+                UserHandle.myUserId()
+        );
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_disableShortcut_shortcutTurnedOff() {
         String target = TARGET_ALWAYS_ON_A11Y_SERVICE.flattenToString();
         ShortcutUtils.optInValueToSettings(
@@ -202,6 +232,29 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void enableShortcutForTargets_disableShortcut_callA11yManager() {
+        String target = TARGET_ALWAYS_ON_A11Y_SERVICE.flattenToString();
+        ShortcutUtils.optInValueToSettings(
+                mContext, ShortcutConstants.UserShortcutType.SOFTWARE, target);
+        assertThat(ShortcutUtils.isComponentIdExistingInSettings(
+                mContext, ShortcutConstants.UserShortcutType.SOFTWARE, target
+        )).isTrue();
+        mController.setShortcutTargets(Set.of(target));
+
+        mController.enableShortcutForTargets(false);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ false,
+                ShortcutConstants.UserShortcutType.SOFTWARE,
+                Set.of(target),
+                UserHandle.myUserId()
+        );
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_enableShortcutWithMagnification_menuSizeIncreased() {
         mController.setShortcutTargets(Set.of(TARGET_MAGNIFICATION));
 
@@ -216,6 +269,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_enableShortcutWithMagnification_userConfigureSmallMenuSize_menuSizeNotChanged() {
         Settings.Secure.putInt(mContext.getContentResolver(),
                 Settings.Secure.ACCESSIBILITY_FLOATING_MENU_SIZE,
@@ -233,6 +287,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_enableAlwaysOnServiceShortcut_turnsOnAlwaysOnService() {
         mController.setShortcutTargets(
                 Set.of(TARGET_ALWAYS_ON_A11Y_SERVICE.flattenToString()));
@@ -244,6 +299,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_disableAlwaysOnServiceShortcut_turnsOffAlwaysOnService() {
         mController.setShortcutTargets(
                 Set.of(TARGET_ALWAYS_ON_A11Y_SERVICE.flattenToString()));
@@ -255,6 +311,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_enableStandardServiceShortcut_wontTurnOnService() {
         mController.setShortcutTargets(
                 Set.of(TARGET_STANDARD_A11Y_SERVICE.flattenToString()));
@@ -266,6 +323,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_disableStandardServiceShortcutWithServiceOn_wontTurnOffService() {
         mController.setShortcutTargets(
                 Set.of(TARGET_STANDARD_A11Y_SERVICE.flattenToString()));
@@ -288,32 +346,6 @@
         assertThat(intent.getExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT)).isEqualTo(page);
     }
 
-    private AccessibilityServiceInfo createAccessibilityServiceInfo(
-            ComponentName componentName, boolean isAlwaysOnService) {
-        final ApplicationInfo applicationInfo = new ApplicationInfo();
-        applicationInfo.targetSdkVersion = Build.VERSION_CODES.R;
-        final ServiceInfo serviceInfo = new ServiceInfo();
-        applicationInfo.packageName = componentName.getPackageName();
-        serviceInfo.packageName = componentName.getPackageName();
-        serviceInfo.name = componentName.getClassName();
-        serviceInfo.applicationInfo = applicationInfo;
-
-        final ResolveInfo resolveInfo = new ResolveInfo();
-        resolveInfo.serviceInfo = serviceInfo;
-        try {
-            final AccessibilityServiceInfo info = new AccessibilityServiceInfo(resolveInfo,
-                    mContext);
-            info.setComponentName(componentName);
-            if (isAlwaysOnService) {
-                info.flags |= AccessibilityServiceInfo.FLAG_REQUEST_ACCESSIBILITY_BUTTON;
-            }
-            return info;
-        } catch (XmlPullParserException | IOException e) {
-            // Do nothing
-        }
-        return null;
-    }
-
     private static class TestSoftwareShortcutOptionPreferenceController
             extends SoftwareShortcutOptionPreferenceController {
 
diff --git a/tests/robotests/src/com/android/settings/accessibility/shortcuts/TripleTapShortcutOptionControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/shortcuts/TripleTapShortcutOptionControllerTest.java
index 800640a..b5daac5 100644
--- a/tests/robotests/src/com/android/settings/accessibility/shortcuts/TripleTapShortcutOptionControllerTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/shortcuts/TripleTapShortcutOptionControllerTest.java
@@ -21,19 +21,32 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
 import android.content.ComponentName;
 import android.content.Context;
 import android.icu.text.MessageFormat;
+import android.os.UserHandle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.Flags;
 
 import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceScreen;
 import androidx.test.core.app.ApplicationProvider;
 
+import com.android.internal.accessibility.common.ShortcutConstants;
 import com.android.settings.R;
 import com.android.settings.accessibility.AccessibilityUtil;
+import com.android.settings.testutils.AccessibilityTestUtils;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
@@ -50,13 +63,17 @@
             "com.android.server.accessibility.MagnificationController";
     private static final String TARGET_FAKE =
             new ComponentName("FakePackage", "FakeClass").flattenToString();
-    private final Context mContext = ApplicationProvider.getApplicationContext();
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+    private final Context mContext = spy(ApplicationProvider.getApplicationContext());
     private TripleTapShortcutOptionController mController;
     private ShortcutOptionPreference mShortcutOptionPreference;
+    private AccessibilityManager mAccessibilityManager;
     private PreferenceScreen mPreferenceScreen;
 
     @Before
     public void setUp() {
+        mAccessibilityManager = AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
         mController = new TripleTapShortcutOptionController(mContext, PREF_KEY);
         mController.setShortcutTargets(Set.of(TARGET_MAGNIFICATION));
         mShortcutOptionPreference = new ShortcutOptionPreference(mContext);
@@ -147,19 +164,26 @@
 
     @Test
     public void isChecked_tripleTapConfigured_returnTrue() {
-        mController.enableShortcutForTargets(true);
+        Settings.Secure.putInt(
+                mContext.getContentResolver(),
+                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
+                AccessibilityUtil.State.ON);
 
         assertThat(mController.isChecked()).isTrue();
     }
 
     @Test
     public void isChecked_tripleTapNotConfigured_returnFalse() {
-        mController.enableShortcutForTargets(false);
+        Settings.Secure.putInt(
+                mContext.getContentResolver(),
+                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
+                AccessibilityUtil.State.OFF);
 
         assertThat(mController.isChecked()).isFalse();
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_enableShortcut_settingUpdated() {
         mController.enableShortcutForTargets(true);
 
@@ -172,6 +196,21 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void enableShortcutForTargets_enableShortcut_callA11yManager() {
+        mController.enableShortcutForTargets(true);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ true,
+                ShortcutConstants.UserShortcutType.TRIPLETAP,
+                Set.of(TARGET_MAGNIFICATION),
+                UserHandle.myUserId()
+        );
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_disableShortcut_settingUpdated() {
         mController.enableShortcutForTargets(false);
 
@@ -182,4 +221,18 @@
                         AccessibilityUtil.State.OFF)
         ).isEqualTo(AccessibilityUtil.State.OFF);
     }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void enableShortcutForTargets_disableShortcut_callA11yManager() {
+        mController.enableShortcutForTargets(false);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ false,
+                ShortcutConstants.UserShortcutType.TRIPLETAP,
+                Set.of(TARGET_MAGNIFICATION),
+                UserHandle.myUserId()
+        );
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/accessibility/shortcuts/TwoFingersDoubleTapShortcutOptionControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/shortcuts/TwoFingerDoubleTapShortcutOptionControllerTest.java
similarity index 62%
rename from tests/robotests/src/com/android/settings/accessibility/shortcuts/TwoFingersDoubleTapShortcutOptionControllerTest.java
rename to tests/robotests/src/com/android/settings/accessibility/shortcuts/TwoFingerDoubleTapShortcutOptionControllerTest.java
index d27560b..716dcdb 100644
--- a/tests/robotests/src/com/android/settings/accessibility/shortcuts/TwoFingersDoubleTapShortcutOptionControllerTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/shortcuts/TwoFingerDoubleTapShortcutOptionControllerTest.java
@@ -18,22 +18,29 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
 import android.content.ComponentName;
 import android.content.Context;
 import android.icu.text.MessageFormat;
-import android.platform.test.annotations.RequiresFlagsDisabled;
-import android.platform.test.annotations.RequiresFlagsEnabled;
-import android.platform.test.flag.junit.CheckFlagsRule;
-import android.platform.test.flag.junit.DeviceFlagsValueProvider;
+import android.os.UserHandle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
+import android.view.accessibility.AccessibilityManager;
 
 import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceScreen;
 import androidx.test.core.app.ApplicationProvider;
 
+import com.android.internal.accessibility.common.ShortcutConstants;
 import com.android.server.accessibility.Flags;
 import com.android.settings.R;
 import com.android.settings.accessibility.AccessibilityUtil;
+import com.android.settings.testutils.AccessibilityTestUtils;
 
 import org.junit.Before;
 import org.junit.Rule;
@@ -44,26 +51,28 @@
 import java.util.Set;
 
 /**
- * Tests for {@link TwoFingersDoubleTapShortcutOptionController}
+ * Tests for {@link TwoFingerDoubleTapShortcutOptionController}
  */
 @RunWith(RobolectricTestRunner.class)
-public class TwoFingersDoubleTapShortcutOptionControllerTest {
+public class TwoFingerDoubleTapShortcutOptionControllerTest {
     private static final String PREF_KEY = "prefKey";
     private static final String TARGET_MAGNIFICATION =
             "com.android.server.accessibility.MagnificationController";
     private static final String TARGET_FAKE =
             new ComponentName("FakePackage", "FakeClass").flattenToString();
     @Rule
-    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
-    private final Context mContext = ApplicationProvider.getApplicationContext();
-    private TwoFingersDoubleTapShortcutOptionController mController;
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+    private final Context mContext = spy(ApplicationProvider.getApplicationContext());
+    private AccessibilityManager mAccessibilityManager;
+    private TwoFingerDoubleTapShortcutOptionController mController;
     private ShortcutOptionPreference mShortcutOptionPreference;
 
     private PreferenceScreen mPreferenceScreen;
 
     @Before
     public void setUp() {
-        mController = new TwoFingersDoubleTapShortcutOptionController(mContext, PREF_KEY);
+        mAccessibilityManager = AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
+        mController = new TwoFingerDoubleTapShortcutOptionController(mContext, PREF_KEY);
         mController.setShortcutTargets(Set.of(TARGET_MAGNIFICATION));
         mShortcutOptionPreference = new ShortcutOptionPreference(mContext);
         mShortcutOptionPreference.setKey(PREF_KEY);
@@ -84,30 +93,30 @@
                         2));
     }
 
-    @RequiresFlagsDisabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     @Test
+    @DisableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void isShortcutAvailable_featureFlagTurnedOff_returnFalse() {
         assertThat(mController.isShortcutAvailable()).isFalse();
     }
 
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     @Test
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void isShortcutAvailable_multipleTargets_returnFalse() {
         mController.setShortcutTargets(Set.of(TARGET_FAKE, TARGET_MAGNIFICATION));
 
         assertThat(mController.isShortcutAvailable()).isFalse();
     }
 
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     @Test
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void isShortcutAvailable_magnificationTargetOnly_returnTrue() {
         mController.setShortcutTargets(Set.of(TARGET_MAGNIFICATION));
 
         assertThat(mController.isShortcutAvailable()).isTrue();
     }
 
-    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     @Test
+    @EnableFlags(Flags.FLAG_ENABLE_MAGNIFICATION_MULTIPLE_FINGER_MULTIPLE_TAP_GESTURE)
     public void isShortcutAvailable_nonMagnificationTarget_returnFalse() {
         mController.setShortcutTargets(Set.of(TARGET_FAKE));
 
@@ -116,19 +125,26 @@
 
     @Test
     public void isChecked_twoFingersDoubleTapConfigured_returnTrue() {
-        mController.enableShortcutForTargets(true);
+        Settings.Secure.putInt(
+                mContext.getContentResolver(),
+                Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED,
+                AccessibilityUtil.State.ON);
 
         assertThat(mController.isChecked()).isTrue();
     }
 
     @Test
     public void isChecked_twoFingersDoubleTapNotConfigured_returnFalse() {
-        mController.enableShortcutForTargets(false);
+        Settings.Secure.putInt(
+                mContext.getContentResolver(),
+                Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED,
+                AccessibilityUtil.State.OFF);
 
         assertThat(mController.isChecked()).isFalse();
     }
 
     @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_enableShortcut_settingUpdated() {
         mController.enableShortcutForTargets(true);
 
@@ -141,6 +157,21 @@
     }
 
     @Test
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void enableShortcutForTargets_enableShortcut_callA11yManager() {
+        mController.enableShortcutForTargets(true);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ true,
+                ShortcutConstants.UserShortcutType.TWOFINGER_DOUBLETAP,
+                Set.of(TARGET_MAGNIFICATION),
+                UserHandle.myUserId()
+        );
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
+
+    @Test
+    @DisableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_disableShortcut_settingUpdated() {
         mController.enableShortcutForTargets(false);
 
@@ -151,4 +182,18 @@
                         AccessibilityUtil.State.OFF)
         ).isEqualTo(AccessibilityUtil.State.OFF);
     }
+
+    @Test
+    @EnableFlags(android.view.accessibility.Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void enableShortcutForTargets_disableShortcut_callA11yManager() {
+        mController.enableShortcutForTargets(false);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ false,
+                ShortcutConstants.UserShortcutType.TWOFINGER_DOUBLETAP,
+                Set.of(TARGET_MAGNIFICATION),
+                UserHandle.myUserId()
+        );
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/accessibility/shortcuts/VolumeKeysShortcutOptionControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/shortcuts/VolumeKeysShortcutOptionControllerTest.java
index 48a90a7..511503a 100644
--- a/tests/robotests/src/com/android/settings/accessibility/shortcuts/VolumeKeysShortcutOptionControllerTest.java
+++ b/tests/robotests/src/com/android/settings/accessibility/shortcuts/VolumeKeysShortcutOptionControllerTest.java
@@ -18,8 +18,18 @@
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
 import android.content.ComponentName;
 import android.content.Context;
+import android.os.UserHandle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.Flags;
 
 import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceScreen;
@@ -28,8 +38,10 @@
 import com.android.internal.accessibility.common.ShortcutConstants;
 import com.android.internal.accessibility.util.ShortcutUtils;
 import com.android.settings.R;
+import com.android.settings.testutils.AccessibilityTestUtils;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
@@ -45,7 +57,11 @@
     private static final String PREF_KEY = "prefKey";
     private static final String TARGET =
             new ComponentName("FakePackage", "FakeClass").flattenToString();
-    private final Context mContext = ApplicationProvider.getApplicationContext();
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
+    private final Context mContext = spy(ApplicationProvider.getApplicationContext());
+    private AccessibilityManager mAccessibilityManager;
     private VolumeKeysShortcutOptionController mController;
     private ShortcutOptionPreference mShortcutOptionPreference;
 
@@ -53,6 +69,7 @@
 
     @Before
     public void setUp() {
+        mAccessibilityManager = AccessibilityTestUtils.setupMockAccessibilityManager(mContext);
         mController = new VolumeKeysShortcutOptionController(
                 mContext, PREF_KEY);
         mController.setShortcutTargets(Set.of(TARGET));
@@ -94,6 +111,7 @@
     }
 
     @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_enableVolumeKeysShortcut_shortcutSet() {
         mController.enableShortcutForTargets(true);
 
@@ -103,6 +121,21 @@
     }
 
     @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void enableShortcutForTargets_enableVolumeKeysShortcut_callA11yManager() {
+        mController.enableShortcutForTargets(true);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ true,
+                ShortcutConstants.UserShortcutType.HARDWARE,
+                Set.of(TARGET),
+                UserHandle.myUserId()
+        );
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
     public void enableShortcutForTargets_disableVolumeKeysShortcut_shortcutNotSet() {
         mController.enableShortcutForTargets(false);
 
@@ -110,4 +143,18 @@
                 ShortcutUtils.isComponentIdExistingInSettings(
                         mContext, ShortcutConstants.UserShortcutType.HARDWARE, TARGET)).isFalse();
     }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void enableShortcutForTargets_disableVolumeKeysShortcut_callA11yManager() {
+        mController.enableShortcutForTargets(false);
+
+        verify(mAccessibilityManager).enableShortcutsForTargets(
+                /* enable= */ false,
+                ShortcutConstants.UserShortcutType.HARDWARE,
+                Set.of(TARGET),
+                UserHandle.myUserId()
+        );
+        verifyNoMoreInteractions(mAccessibilityManager);
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/applications/AppInfoWithHeaderTest.java b/tests/robotests/src/com/android/settings/applications/AppInfoWithHeaderTest.java
index ce52027..562212e 100644
--- a/tests/robotests/src/com/android/settings/applications/AppInfoWithHeaderTest.java
+++ b/tests/robotests/src/com/android/settings/applications/AppInfoWithHeaderTest.java
@@ -19,6 +19,7 @@
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -48,12 +49,13 @@
 
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
@@ -62,6 +64,8 @@
 @RunWith(RobolectricTestRunner.class)
 @Config(shadows = {ShadowEntityHeaderController.class, ShadowSettingsLibUtils.class})
 public class AppInfoWithHeaderTest {
+    @Rule
+    public final MockitoRule mMockitoRule = MockitoJUnit.rule();
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private EntityHeaderController mHeaderController;
@@ -71,7 +75,6 @@
 
     @Before
     public void setUp() {
-        MockitoAnnotations.initMocks(this);
         mFactory = FakeFeatureFactory.setupForTest();
         when(mFactory.metricsFeatureProvider.getMetricsCategory(any(Object.class)))
                 .thenReturn(MetricsProto.MetricsEvent.SETTINGS_APP_NOTIF_CATEGORY);
@@ -120,7 +123,6 @@
         assertThat(mAppInfoWithHeader.mPackageRemovedCalled).isTrue();
     }
 
-    @Ignore("b/315135755")
     @Test
     public void noExtraUserHandleInIntent_retrieveAppEntryWithMyUserId()
             throws PackageManager.NameNotFoundException {
@@ -133,10 +135,8 @@
 
         when(mAppInfoWithHeader.mState.getEntry(packageName,
                 UserHandle.myUserId())).thenReturn(entry);
-        when(mAppInfoWithHeader.mPm.getPackageInfoAsUser(entry.info.packageName,
-                PackageManager.MATCH_DISABLED_COMPONENTS |
-                        PackageManager.GET_SIGNING_CERTIFICATES |
-                        PackageManager.GET_PERMISSIONS, UserHandle.myUserId())).thenReturn(
+        when(mAppInfoWithHeader.mPm.getPackageInfoAsUser(eq(entry.info.packageName),
+                any(), eq(UserHandle.myUserId()))).thenReturn(
                 mAppInfoWithHeader.mPackageInfo);
 
         mAppInfoWithHeader.retrieveAppEntry();
@@ -146,7 +146,6 @@
         assertThat(mAppInfoWithHeader.mAppEntry).isNotNull();
     }
 
-    @Ignore("b/315135755")
     @Test
     public void extraUserHandleInIntent_retrieveAppEntryWithMyUserId()
             throws PackageManager.NameNotFoundException {
@@ -161,10 +160,8 @@
         entry.info.packageName = packageName;
 
         when(mAppInfoWithHeader.mState.getEntry(packageName, USER_ID)).thenReturn(entry);
-        when(mAppInfoWithHeader.mPm.getPackageInfoAsUser(entry.info.packageName,
-                PackageManager.MATCH_DISABLED_COMPONENTS |
-                        PackageManager.GET_SIGNING_CERTIFICATES |
-                        PackageManager.GET_PERMISSIONS, USER_ID)).thenReturn(
+        when(mAppInfoWithHeader.mPm.getPackageInfoAsUser(eq(entry.info.packageName),
+                any(), eq(USER_ID))).thenReturn(
                 mAppInfoWithHeader.mPackageInfo);
 
         mAppInfoWithHeader.retrieveAppEntry();
@@ -232,6 +229,8 @@
         }
 
         @Override
-        protected Intent getIntent() { return mIntent; }
+        protected Intent getIntent() {
+            return mIntent;
+        }
     }
 }
diff --git a/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingAidsPresetsControllerTest.java b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingAidsPresetsControllerTest.java
new file mode 100644
index 0000000..c08bb98
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingAidsPresetsControllerTest.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.bluetooth;
+
+import static android.bluetooth.BluetoothCsipSetCoordinator.GROUP_ID_INVALID;
+import static android.bluetooth.BluetoothHapClient.PRESET_INDEX_UNAVAILABLE;
+
+import static com.android.settings.bluetooth.BluetoothDetailsHearingDeviceController.KEY_HEARING_DEVICE_GROUP;
+import static com.android.settings.bluetooth.BluetoothDetailsHearingAidsPresetsController.KEY_HEARING_AIDS_PRESETS;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothHapClient;
+import android.bluetooth.BluetoothHapPresetInfo;
+
+import androidx.preference.ListPreference;
+import androidx.preference.PreferenceCategory;
+
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HapClientProfile;
+import com.android.settingslib.bluetooth.LocalBluetoothManager;
+import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Executor;
+
+/** Tests for {@link BluetoothDetailsHearingAidsPresetsController}. */
+@RunWith(RobolectricTestRunner.class)
+public class BluetoothDetailsHearingAidsPresetsControllerTest extends
+        BluetoothDetailsControllerTestBase {
+
+    private static final int TEST_PRESET_INDEX = 1;
+    private static final String TEST_PRESET_NAME = "test_preset";
+    private static final int TEST_HAP_GROUP_ID = 1;
+
+    @Rule
+    public final MockitoRule mockito = MockitoJUnit.rule();
+
+    @Mock
+    private LocalBluetoothManager mLocalManager;
+    @Mock
+    private LocalBluetoothProfileManager mProfileManager;
+    @Mock
+    private HapClientProfile mHapClientProfile;
+    @Mock
+    private CachedBluetoothDevice mCachedChildDevice;
+    @Mock
+    private BluetoothDevice mChildDevice;
+
+    private BluetoothDetailsHearingAidsPresetsController mController;
+
+    @Override
+    public void setUp() {
+        super.setUp();
+
+        when(mLocalManager.getProfileManager()).thenReturn(mProfileManager);
+        when(mProfileManager.getHapClientProfile()).thenReturn(mHapClientProfile);
+        when(mCachedDevice.getProfiles()).thenReturn(List.of(mHapClientProfile));
+        when(mCachedDevice.isConnectedHapClientDevice()).thenReturn(true);
+        when(mCachedChildDevice.getDevice()).thenReturn(mChildDevice);
+        PreferenceCategory deviceControls = new PreferenceCategory(mContext);
+        deviceControls.setKey(KEY_HEARING_DEVICE_GROUP);
+        mScreen.addPreference(deviceControls);
+        mController = new BluetoothDetailsHearingAidsPresetsController(mContext, mFragment,
+                mLocalManager, mCachedDevice, mLifecycle);
+        mController.init(mScreen);
+    }
+
+    @Test
+    public void isAvailable_supportHap_returnTrue() {
+        when(mCachedDevice.getProfiles()).thenReturn(List.of(mHapClientProfile));
+
+        assertThat(mController.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void isAvailable_notSupportHap_returnFalse() {
+        when(mCachedDevice.getProfiles()).thenReturn(new ArrayList<>());
+
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @Test
+    public void onResume_registerCallback() {
+        mController.onResume();
+
+        verify(mHapClientProfile).registerCallback(any(Executor.class),
+                any(BluetoothHapClient.Callback.class));
+    }
+
+    @Test
+    public void onPause_unregisterCallback() {
+        mController.onPause();
+
+        verify(mHapClientProfile).unregisterCallback(any(BluetoothHapClient.Callback.class));
+    }
+
+    @Test
+    public void onPreferenceChange_keyMatched_verifyStatusUpdated() {
+        final ListPreference presetPreference = getTestPresetPreference(KEY_HEARING_AIDS_PRESETS);
+
+        boolean handled = mController.onPreferenceChange(presetPreference,
+                String.valueOf(TEST_PRESET_INDEX));
+
+        assertThat(handled).isTrue();
+        verify(presetPreference).setSummary(TEST_PRESET_NAME);
+    }
+
+    @Test
+    public void onPreferenceChange_keyNotMatched_doNothing() {
+        final ListPreference presetPreference = getTestPresetPreference("wrong_key");
+
+        boolean handled = mController.onPreferenceChange(
+                presetPreference, String.valueOf(TEST_PRESET_INDEX));
+
+        assertThat(handled).isFalse();
+        verify(presetPreference, never()).setSummary(any());
+    }
+
+    @Test
+    public void onPreferenceChange_supportGroupOperation_validGroupId_verifySelectPresetForGroup() {
+        final ListPreference presetPreference = getTestPresetPreference(KEY_HEARING_AIDS_PRESETS);
+        when(mHapClientProfile.supportsSynchronizedPresets(mDevice)).thenReturn(true);
+        when(mHapClientProfile.getHapGroup(mDevice)).thenReturn(TEST_HAP_GROUP_ID);
+
+        mController.onPreferenceChange(presetPreference, String.valueOf(TEST_PRESET_INDEX));
+
+        verify(mHapClientProfile).selectPresetForGroup(TEST_HAP_GROUP_ID, TEST_PRESET_INDEX);
+    }
+
+    @Test
+    public void onPreferenceChange_notSupportGroupOperation_verifySelectPreset() {
+        final ListPreference presetPreference = getTestPresetPreference(KEY_HEARING_AIDS_PRESETS);
+        when(mHapClientProfile.supportsSynchronizedPresets(mDevice)).thenReturn(false);
+        when(mHapClientProfile.getHapGroup(mDevice)).thenReturn(TEST_HAP_GROUP_ID);
+
+        mController.onPreferenceChange(presetPreference, String.valueOf(TEST_PRESET_INDEX));
+
+        verify(mHapClientProfile).selectPreset(mDevice, TEST_PRESET_INDEX);
+    }
+
+    @Test
+    public void onPreferenceChange_invalidGroupId_verifySelectPreset() {
+        final ListPreference presetPreference = getTestPresetPreference(KEY_HEARING_AIDS_PRESETS);
+        when(mHapClientProfile.supportsSynchronizedPresets(mDevice)).thenReturn(true);
+        when(mHapClientProfile.getHapGroup(mDevice)).thenReturn(GROUP_ID_INVALID);
+
+        mController.onPreferenceChange(presetPreference, String.valueOf(TEST_PRESET_INDEX));
+
+        verify(mHapClientProfile).selectPreset(mDevice, TEST_PRESET_INDEX);
+    }
+
+    @Test
+    public void onPreferenceChange_notSupportGroupOperation_hasSubDevice_verifyStatusUpdated() {
+        final ListPreference presetPreference = getTestPresetPreference(KEY_HEARING_AIDS_PRESETS);
+        when(mHapClientProfile.supportsSynchronizedPresets(mDevice)).thenReturn(false);
+        when(mCachedDevice.getSubDevice()).thenReturn(mCachedChildDevice);
+
+        mController.onPreferenceChange(presetPreference, String.valueOf(TEST_PRESET_INDEX));
+
+        verify(mHapClientProfile).selectPreset(mDevice, TEST_PRESET_INDEX);
+        verify(mHapClientProfile).selectPreset(mChildDevice, TEST_PRESET_INDEX);
+    }
+
+    @Test
+    public void onPreferenceChange_notSupportGroupOperation_hasMemberDevice_verifyStatusUpdated() {
+        final ListPreference presetPreference = getTestPresetPreference(KEY_HEARING_AIDS_PRESETS);
+        when(mHapClientProfile.supportsSynchronizedPresets(mDevice)).thenReturn(false);
+        when(mCachedDevice.getMemberDevice()).thenReturn(Set.of(mCachedChildDevice));
+
+        mController.onPreferenceChange(presetPreference, String.valueOf(TEST_PRESET_INDEX));
+
+        verify(mHapClientProfile).selectPreset(mDevice, TEST_PRESET_INDEX);
+        verify(mHapClientProfile).selectPreset(mChildDevice, TEST_PRESET_INDEX);
+    }
+
+    @Test
+    public void refresh_emptyPresetInfo_preferenceDisabled() {
+        when(mHapClientProfile.getAllPresetInfo(mDevice)).thenReturn(new ArrayList<>());
+
+        mController.refresh();
+
+        assertThat(mController.getPreference()).isNotNull();
+        assertThat(mController.getPreference().isEnabled()).isFalse();
+    }
+
+    @Test
+    public void refresh_validPresetInfo_preferenceEnabled() {
+        BluetoothHapPresetInfo info = getTestPresetInfo();
+        when(mHapClientProfile.getAllPresetInfo(mDevice)).thenReturn(List.of(info));
+
+        mController.refresh();
+
+        assertThat(mController.getPreference()).isNotNull();
+        assertThat(mController.getPreference().isEnabled()).isTrue();
+    }
+
+    @Test
+    public void refresh_invalidActivePresetIndex_summaryIsNull() {
+        BluetoothHapPresetInfo info = getTestPresetInfo();
+        when(mHapClientProfile.getAllPresetInfo(mDevice)).thenReturn(List.of(info));
+        when(mHapClientProfile.getActivePresetIndex(mDevice)).thenReturn(PRESET_INDEX_UNAVAILABLE);
+
+        mController.refresh();
+
+        assertThat(mController.getPreference()).isNotNull();
+        assertThat(mController.getPreference().getSummary()).isNull();
+    }
+
+    @Test
+    public void refresh_validActivePresetIndex_summaryIsNotNull() {
+        BluetoothHapPresetInfo info = getTestPresetInfo();
+        when(mHapClientProfile.getAllPresetInfo(mDevice)).thenReturn(List.of(info));
+        when(mHapClientProfile.getActivePresetIndex(mDevice)).thenReturn(TEST_PRESET_INDEX);
+
+        mController.refresh();
+
+        assertThat(mController.getPreference()).isNotNull();
+        assertThat(mController.getPreference().getSummary()).isNotNull();
+    }
+
+    private BluetoothHapPresetInfo getTestPresetInfo() {
+        BluetoothHapPresetInfo info = mock(BluetoothHapPresetInfo.class);
+        when(info.getName()).thenReturn(TEST_PRESET_NAME);
+        when(info.getIndex()).thenReturn(TEST_PRESET_INDEX);
+        return info;
+    }
+
+    private ListPreference getTestPresetPreference(String key) {
+        final ListPreference presetPreference = spy(new ListPreference(mContext));
+        when(presetPreference.findIndexOfValue(String.valueOf(TEST_PRESET_INDEX))).thenReturn(0);
+        when(presetPreference.getEntries()).thenReturn(new CharSequence[]{TEST_PRESET_NAME});
+        when(presetPreference.getEntryValues()).thenReturn(
+                new CharSequence[]{String.valueOf(TEST_PRESET_INDEX)});
+        presetPreference.setKey(key);
+        return presetPreference;
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControllerTest.java b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControllerTest.java
new file mode 100644
index 0000000..2a50f89
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControllerTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.bluetooth;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.when;
+
+import android.platform.test.annotations.RequiresFlagsDisabled;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
+
+import com.android.settings.accessibility.Flags;
+import com.android.settingslib.bluetooth.LocalBluetoothManager;
+import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+
+/** Tests for {@link BluetoothDetailsHearingDeviceController}. */
+@RunWith(RobolectricTestRunner.class)
+public class BluetoothDetailsHearingDeviceControllerTest extends
+        BluetoothDetailsControllerTestBase {
+
+    @Rule
+    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
+
+    @Rule
+    public final MockitoRule mockito = MockitoJUnit.rule();
+
+    @Mock
+    private LocalBluetoothManager mLocalManager;
+    @Mock
+    private LocalBluetoothProfileManager mProfileManager;
+    @Mock
+    private BluetoothDetailsHearingDeviceController mHearingDeviceController;
+    @Mock
+    private BluetoothDetailsHearingAidsPresetsController mPresetsController;
+    @Mock
+    private BluetoothDetailsHearingDeviceSettingsController mHearingDeviceSettingsController;
+
+    @Override
+    public void setUp() {
+        super.setUp();
+
+        when(mLocalManager.getProfileManager()).thenReturn(mProfileManager);
+        mHearingDeviceController = new BluetoothDetailsHearingDeviceController(mContext,
+                mFragment, mLocalManager, mCachedDevice, mLifecycle);
+        mHearingDeviceController.setSubControllers(mHearingDeviceSettingsController,
+                mPresetsController);
+    }
+
+    @Test
+    public void isAvailable_hearingDeviceSettingsAvailable_returnTrue() {
+        when(mHearingDeviceSettingsController.isAvailable()).thenReturn(true);
+
+        assertThat(mHearingDeviceController.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void isAvailable_presetsControlsAvailable_returnTrue() {
+        when(mPresetsController.isAvailable()).thenReturn(true);
+
+        assertThat(mHearingDeviceController.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void isAvailable_noControllersAvailable_returnFalse() {
+        when(mHearingDeviceSettingsController.isAvailable()).thenReturn(false);
+        when(mPresetsController.isAvailable()).thenReturn(false);
+
+        assertThat(mHearingDeviceController.isAvailable()).isFalse();
+    }
+
+
+    @Test
+    public void initSubControllers_launchFromHearingDevicePage_hearingDeviceSettingsNotExist() {
+        mHearingDeviceController.initSubControllers(true);
+
+        assertThat(mHearingDeviceController.getSubControllers().stream().anyMatch(
+                c -> c instanceof BluetoothDetailsHearingDeviceSettingsController)).isFalse();
+    }
+
+    @Test
+    public void initSubControllers_notLaunchFromHearingDevicePage_hearingDeviceSettingsExist() {
+        mHearingDeviceController.initSubControllers(false);
+
+        assertThat(mHearingDeviceController.getSubControllers().stream().anyMatch(
+                c -> c instanceof BluetoothDetailsHearingDeviceSettingsController)).isTrue();
+    }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_ENABLE_HEARING_AID_PRESET_CONTROL)
+    public void initSubControllers_flagEnabled_presetControllerExist() {
+        mHearingDeviceController.initSubControllers(false);
+
+        assertThat(mHearingDeviceController.getSubControllers().stream().anyMatch(
+                c -> c instanceof BluetoothDetailsHearingAidsPresetsController)).isTrue();
+    }
+
+    @Test
+    @RequiresFlagsDisabled(Flags.FLAG_ENABLE_HEARING_AID_PRESET_CONTROL)
+    public void initSubControllers_flagDisabled_presetControllerNotExist() {
+        mHearingDeviceController.initSubControllers(false);
+
+        assertThat(mHearingDeviceController.getSubControllers().stream().anyMatch(
+                c -> c instanceof BluetoothDetailsHearingAidsPresetsController)).isFalse();
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControlsControllerTest.java b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceSettingsControllerTest.java
similarity index 81%
rename from tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControlsControllerTest.java
rename to tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceSettingsControllerTest.java
index 364d299..b420717 100644
--- a/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceControlsControllerTest.java
+++ b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDetailsHearingDeviceSettingsControllerTest.java
@@ -39,23 +39,24 @@
 import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
 
-/** Tests for {@link BluetoothDetailsHearingDeviceControlsController}. */
+/** Tests for {@link BluetoothDetailsHearingDeviceSettingsController}. */
 @RunWith(RobolectricTestRunner.class)
-public class BluetoothDetailsHearingDeviceControlsControllerTest extends
+public class BluetoothDetailsHearingDeviceSettingsControllerTest extends
         BluetoothDetailsControllerTestBase {
+
     @Rule
     public final MockitoRule mockito = MockitoJUnit.rule();
 
     @Captor
     private ArgumentCaptor<Intent> mIntentArgumentCaptor;
-    private BluetoothDetailsHearingDeviceControlsController mController;
+    private BluetoothDetailsHearingDeviceSettingsController mController;
 
     @Override
     public void setUp() {
         super.setUp();
 
         FakeFeatureFactory.setupForTest();
-        mController = new BluetoothDetailsHearingDeviceControlsController(mActivity, mFragment,
+        mController = new BluetoothDetailsHearingDeviceSettingsController(mActivity, mFragment,
                 mCachedDevice, mLifecycle);
         when(mCachedDevice.isHearingAidDevice()).thenReturn(true);
     }
@@ -75,12 +76,12 @@
     }
 
     @Test
-    public void onPreferenceClick_hearingDeviceControlsKey_LaunchExpectedFragment() {
-        final Preference hearingControlsKeyPreference = new Preference(mContext);
-        hearingControlsKeyPreference.setKey(
-                BluetoothDetailsHearingDeviceControlsController.KEY_HEARING_DEVICE_CONTROLS);
+    public void onPreferenceClick_hearingDeviceSettingsKey_launchExpectedFragment() {
+        final Preference hearingDeviceSettingsPreference = new Preference(mContext);
+        hearingDeviceSettingsPreference.setKey(
+                BluetoothDetailsHearingDeviceSettingsController.KEY_HEARING_DEVICE_SETTINGS);
 
-        mController.onPreferenceClick(hearingControlsKeyPreference);
+        mController.onPreferenceClick(hearingDeviceSettingsPreference);
 
         assertStartActivityWithExpectedFragment(mActivity,
                 AccessibilityHearingAidsFragment.class.getName());
diff --git a/tests/robotests/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragmentTest.java b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragmentTest.java
index fc72c41..50aa771 100644
--- a/tests/robotests/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/bluetooth/BluetoothDeviceDetailsFragmentTest.java
@@ -18,7 +18,7 @@
 
 import static android.bluetooth.BluetoothDevice.BOND_NONE;
 
-import static com.android.settings.bluetooth.BluetoothDetailsHearingDeviceControlsController.KEY_DEVICE_CONTROLS_GENERAL_GROUP;
+import static com.android.settings.bluetooth.BluetoothDetailsHearingDeviceSettingsController.KEY_HEARING_DEVICE_SETTINGS;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -237,7 +237,7 @@
 
         assertThat(controllerList.stream()
                 .anyMatch(controller -> controller.getPreferenceKey().equals(
-                        KEY_DEVICE_CONTROLS_GENERAL_GROUP))).isFalse();
+                        KEY_HEARING_DEVICE_SETTINGS))).isFalse();
     }
 
     @Test
@@ -253,7 +253,7 @@
 
         assertThat(controllerList.stream()
                 .anyMatch(controller -> controller.getPreferenceKey().equals(
-                        KEY_DEVICE_CONTROLS_GENERAL_GROUP))).isTrue();
+                        KEY_HEARING_DEVICE_SETTINGS))).isTrue();
     }
 
     private InputDevice createInputDeviceWithMatchingBluetoothAddress() {
diff --git a/tests/robotests/src/com/android/settings/dashboard/profileselector/ProfileSelectFragmentTest.java b/tests/robotests/src/com/android/settings/dashboard/profileselector/ProfileSelectFragmentTest.java
index 46e4ea5..3ab0e69 100644
--- a/tests/robotests/src/com/android/settings/dashboard/profileselector/ProfileSelectFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/dashboard/profileselector/ProfileSelectFragmentTest.java
@@ -17,6 +17,7 @@
 package com.android.settings.dashboard.profileselector;
 
 import static android.content.Intent.EXTRA_USER_ID;
+import static android.content.pm.UserInfo.FLAG_MAIN;
 import static android.os.UserManager.USER_TYPE_FULL_SYSTEM;
 import static android.os.UserManager.USER_TYPE_PROFILE_MANAGED;
 import static android.os.UserManager.USER_TYPE_PROFILE_PRIVATE;
@@ -208,7 +209,7 @@
         mSetFlagsRule.disableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
         mUserManager.addProfile(
-                new UserInfo(0, PRIMARY_USER_NAME, null, 0, USER_TYPE_FULL_SYSTEM));
+                new UserInfo(0, PRIMARY_USER_NAME, null, FLAG_MAIN, USER_TYPE_FULL_SYSTEM));
         Fragment[] fragments = ProfileSelectFragment.getFragments(
                 mContext,
                 null /* bundle */,
@@ -221,7 +222,7 @@
     @Test
     public void testGetFragments_whenPrivateDisabled_returnsOneFragment() {
         mUserManager.addProfile(
-                new UserInfo(0, PRIMARY_USER_NAME, null, 0, USER_TYPE_FULL_SYSTEM));
+                new UserInfo(0, PRIMARY_USER_NAME, null, FLAG_MAIN, USER_TYPE_FULL_SYSTEM));
         mUserManager.addProfile(
                 new UserInfo(11, PRIVATE_USER_NAME, null, 0, USER_TYPE_PROFILE_PRIVATE));
         Fragment[] fragments = ProfileSelectFragment.getFragments(
@@ -244,7 +245,7 @@
         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
         mUserManager.addProfile(
-                new UserInfo(0, PRIMARY_USER_NAME, null, 0, USER_TYPE_FULL_SYSTEM));
+                new UserInfo(0, PRIMARY_USER_NAME, null, FLAG_MAIN, USER_TYPE_FULL_SYSTEM));
         mUserManager.addProfile(
                 new UserInfo(11, PRIVATE_USER_NAME, null, 0, USER_TYPE_PROFILE_PRIVATE));
         Fragment[] fragments = ProfileSelectFragment.getFragments(
@@ -267,7 +268,7 @@
         mSetFlagsRule.disableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
         mUserManager.addProfile(
-                new UserInfo(0, PRIMARY_USER_NAME, null, 0, USER_TYPE_FULL_SYSTEM));
+                new UserInfo(0, PRIMARY_USER_NAME, null, FLAG_MAIN, USER_TYPE_FULL_SYSTEM));
         mUserManager.addProfile(
                 new UserInfo(10, MANAGED_USER_NAME, null, 0, USER_TYPE_PROFILE_MANAGED));
         Fragment[] fragments = ProfileSelectFragment.getFragments(
@@ -290,7 +291,7 @@
         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
         mUserManager.addProfile(
-                new UserInfo(0, PRIMARY_USER_NAME, null, 0, USER_TYPE_FULL_SYSTEM));
+                new UserInfo(0, PRIMARY_USER_NAME, null, FLAG_MAIN, USER_TYPE_FULL_SYSTEM));
         mUserManager.addProfile(
                 new UserInfo(10, MANAGED_USER_NAME, null, 0, USER_TYPE_PROFILE_MANAGED));
         mUserManager.addProfile(
@@ -315,7 +316,7 @@
         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
         mUserManager.addProfile(
-                new UserInfo(0, PRIMARY_USER_NAME, null, 0, USER_TYPE_FULL_SYSTEM));
+                new UserInfo(0, PRIMARY_USER_NAME, null, FLAG_MAIN, USER_TYPE_FULL_SYSTEM));
         mUserManager.addProfile(
                 new UserInfo(10, MANAGED_USER_NAME, null, 0, USER_TYPE_PROFILE_MANAGED));
         mUserManager.addProfile(
diff --git a/tests/robotests/src/com/android/settings/dashboard/profileselector/ProfileSelectLocationFragmentTest.java b/tests/robotests/src/com/android/settings/dashboard/profileselector/ProfileSelectLocationFragmentTest.java
index 22fec8f..3cc47a8 100644
--- a/tests/robotests/src/com/android/settings/dashboard/profileselector/ProfileSelectLocationFragmentTest.java
+++ b/tests/robotests/src/com/android/settings/dashboard/profileselector/ProfileSelectLocationFragmentTest.java
@@ -16,6 +16,7 @@
 
 package com.android.settings.dashboard.profileselector;
 
+import static android.content.pm.UserInfo.FLAG_MAIN;
 import static android.os.UserManager.USER_TYPE_FULL_SYSTEM;
 import static android.os.UserManager.USER_TYPE_PROFILE_MANAGED;
 import static android.os.UserManager.USER_TYPE_PROFILE_PRIVATE;
@@ -60,7 +61,7 @@
     public void setUp() {
         mUserManager = ShadowUserManager.getShadow();
         mUserManager.addProfile(
-                new UserInfo(0, PERSONAL_PROFILE_NAME, null, 0, USER_TYPE_FULL_SYSTEM));
+                new UserInfo(0, PERSONAL_PROFILE_NAME, null, FLAG_MAIN, USER_TYPE_FULL_SYSTEM));
         mUserManager.addProfile(
                 new UserInfo(1, WORK_PROFILE_NAME, null, 0, USER_TYPE_PROFILE_MANAGED));
         mUserManager.addProfile(
diff --git a/tests/robotests/src/com/android/settings/development/quarantine/QuarantinedAppsScreenControllerTest.java b/tests/robotests/src/com/android/settings/development/quarantine/QuarantinedAppsScreenControllerTest.java
deleted file mode 100644
index a93e529..0000000
--- a/tests/robotests/src/com/android/settings/development/quarantine/QuarantinedAppsScreenControllerTest.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.development.quarantine;
-
-import static org.mockito.AdditionalMatchers.aryEq;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNull;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-
-import android.content.Context;
-import android.content.pm.ApplicationInfo;
-import android.content.pm.PackageManager;
-import android.content.pm.SuspendDialogInfo;
-import android.os.UserHandle;
-
-import androidx.test.core.app.ApplicationProvider;
-
-import com.android.settingslib.applications.ApplicationsState.AppEntry;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.MockitoAnnotations;
-import org.robolectric.RobolectricTestRunner;
-
-@RunWith(RobolectricTestRunner.class)
-public class QuarantinedAppsScreenControllerTest {
-    private static final String PREF_KEY = "quarantined_apps_screen";
-    private static final String TEST_PACKAGE = "com.example.test.pkg";
-    private static final int TEST_APP_ID = 1234;
-    private static final int TEST_USER_ID = 10;
-
-    private Context mContext;
-    private QuarantinedAppsScreenController mController;
-
-    @Before
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-        mContext = spy(ApplicationProvider.getApplicationContext());
-        mController = new QuarantinedAppsScreenController(mContext, PREF_KEY);
-    }
-
-    @Test
-    public void testOnPreferenceChange() {
-        final Context userContext = mock(Context.class);
-        doReturn(userContext).when(mContext).createContextAsUser(
-                eq(UserHandle.of(TEST_USER_ID)), anyInt());
-        final PackageManager packageManager = mock(PackageManager.class);
-        doReturn(packageManager).when(userContext).getPackageManager();
-
-        final AppEntry entry = createAppEntry(TEST_PACKAGE, TEST_APP_ID, TEST_USER_ID);
-        final QuarantinedAppPreference preference = new QuarantinedAppPreference(mContext, entry);
-
-        mController.onPreferenceChange(preference, true);
-        verify(packageManager).setPackagesSuspended(aryEq(new String[] {TEST_PACKAGE}), eq(true),
-                isNull(), isNull(), any(SuspendDialogInfo.class),
-                eq(PackageManager.FLAG_SUSPEND_QUARANTINED));
-
-        mController.onPreferenceChange(preference, false);
-        verify(packageManager).setPackagesSuspended(aryEq(new String[] {TEST_PACKAGE}), eq(false),
-                isNull(), isNull(), isNull(),
-                eq(PackageManager.FLAG_SUSPEND_QUARANTINED));
-    }
-
-    private AppEntry createAppEntry(String packageName, int appId, int userId) {
-        final AppEntry entry = mock(AppEntry.class);
-        entry.info = createApplicationInfo(packageName, appId, userId);
-        entry.extraInfo = false;
-        return entry;
-    }
-
-    private ApplicationInfo createApplicationInfo(String packageName, int appId, int userId) {
-        final ApplicationInfo info = new ApplicationInfo();
-        info.packageName = packageName;
-        info.uid = UserHandle.getUid(userId, appId);
-        return info;
-    }
-}
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java
index 0648de4..80739e9 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetailTest.java
@@ -60,12 +60,8 @@
 import com.android.settingslib.applications.ApplicationsState;
 import com.android.settingslib.applications.instantapps.InstantAppDataProvider;
 import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
-import com.android.settingslib.datastore.ChangeReason;
-import com.android.settingslib.datastore.Observer;
 import com.android.settingslib.widget.LayoutPreference;
 
-import com.google.common.util.concurrent.MoreExecutors;
-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -119,10 +115,8 @@
     @Mock private AppOpsManager mAppOpsManager;
     @Mock private LoaderManager mLoaderManager;
     @Mock private BatteryOptimizeUtils mBatteryOptimizeUtils;
-    @Mock private Observer mObserver;
 
     private Context mContext;
-    private BatterySettingsStorage mBatterySettingsStorage;
     private PrimarySwitchPreference mAllowBackgroundUsagePreference;
     private AdvancedPowerUsageDetail mFragment;
     private SettingsActivity mTestActivity;
@@ -134,7 +128,6 @@
     @Before
     public void setUp() {
         mContext = spy(ApplicationProvider.getApplicationContext());
-        mBatterySettingsStorage = BatterySettingsStorage.get(mContext);
         when(mContext.getPackageName()).thenReturn("foo");
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         mMetricsFeatureProvider = mFeatureFactory.metricsFeatureProvider;
@@ -448,28 +441,4 @@
         TimeUnit.SECONDS.sleep(1);
         verifyNoInteractions(mMetricsFeatureProvider);
     }
-
-    @Test
-    public void notifyBackupManager_optimizationModeIsNotChanged_notInvokeDataChanged() {
-        mBatterySettingsStorage.addObserver(mObserver, MoreExecutors.directExecutor());
-        final int mode = BatteryOptimizeUtils.MODE_RESTRICTED;
-        mFragment.mOptimizationMode = mode;
-        when(mBatteryOptimizeUtils.getAppOptimizationMode()).thenReturn(mode);
-
-        mFragment.notifyBackupManager();
-
-        verifyNoInteractions(mObserver);
-    }
-
-    @Test
-    public void notifyBackupManager_optimizationModeIsChanged_invokeDataChanged() {
-        mBatterySettingsStorage.addObserver(mObserver, MoreExecutors.directExecutor());
-        mFragment.mOptimizationMode = BatteryOptimizeUtils.MODE_RESTRICTED;
-        when(mBatteryOptimizeUtils.getAppOptimizationMode())
-                .thenReturn(BatteryOptimizeUtils.MODE_UNRESTRICTED);
-
-        mFragment.notifyBackupManager();
-
-        verify(mObserver).onChanged(ChangeReason.UPDATE);
-    }
 }
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java
index 3551eeb..6085b9a 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryOptimizeUtilsTest.java
@@ -49,8 +49,12 @@
 import android.util.ArraySet;
 
 import com.android.settings.fuelgauge.BatteryOptimizeHistoricalLogEntry.Action;
+import com.android.settingslib.datastore.ChangeReason;
+import com.android.settingslib.datastore.Observer;
 import com.android.settingslib.fuelgauge.PowerAllowlistBackend;
 
+import com.google.common.util.concurrent.MoreExecutors;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -74,14 +78,18 @@
     @Mock private PowerAllowlistBackend mMockBackend;
     @Mock private IPackageManager mMockIPackageManager;
     @Mock private UserManager mMockUserManager;
+    @Mock private Observer mObserver;
 
     private Context mContext;
     private BatteryOptimizeUtils mBatteryOptimizeUtils;
+    private BatterySettingsStorage mBatterySettingsStorage;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = spy(RuntimeEnvironment.application);
+        mBatterySettingsStorage = BatterySettingsStorage.get(mContext);
+        mBatterySettingsStorage.addObserver(mObserver, MoreExecutors.directExecutor());
         mBatteryOptimizeUtils = spy(new BatteryOptimizeUtils(mContext, UID, PACKAGE_NAME));
         mBatteryOptimizeUtils.mAppOpsManager = mMockAppOpsManager;
         mBatteryOptimizeUtils.mBatteryUtils = mMockBatteryUtils;
@@ -156,6 +164,7 @@
         TimeUnit.SECONDS.sleep(1);
 
         verifySetAppOptimizationMode(AppOpsManager.MODE_IGNORED, /* allowListed */ false);
+        verify(mObserver).onChanged(ChangeReason.UPDATE);
     }
 
     @Test
@@ -169,6 +178,7 @@
         TimeUnit.SECONDS.sleep(1);
 
         verifySetAppOptimizationMode(AppOpsManager.MODE_ALLOWED, /* allowListed */ true);
+        verify(mObserver).onChanged(ChangeReason.UPDATE);
     }
 
     @Test
@@ -182,6 +192,7 @@
         TimeUnit.SECONDS.sleep(1);
 
         verifySetAppOptimizationMode(AppOpsManager.MODE_ALLOWED, /* allowListed */ false);
+        verify(mObserver).onChanged(ChangeReason.UPDATE);
     }
 
     @Test
@@ -197,6 +208,7 @@
         verify(mMockBatteryUtils, never()).setForceAppStandby(anyInt(), anyString(), anyInt());
         verify(mMockBackend, never()).addApp(anyString());
         verify(mMockBackend, never()).removeApp(anyString());
+        verifyNoInteractions(mObserver);
     }
 
     @Test
@@ -288,6 +300,7 @@
         inOrder.verify(mMockBackend).isAllowlisted(PACKAGE_NAME, UID);
         inOrder.verify(mMockBackend).isSysAllowlisted(PACKAGE_NAME);
         verifyNoMoreInteractions(mMockBackend);
+        verify(mObserver).onChanged(ChangeReason.DELETE);
     }
 
     @Test
@@ -298,6 +311,7 @@
                 /* isSystemOrDefaultApp */ false);
 
         verifySetAppOptimizationMode(AppOpsManager.MODE_ALLOWED, /* allowListed */ false);
+        verify(mObserver).onChanged(ChangeReason.DELETE);
     }
 
     @Test
@@ -308,6 +322,7 @@
                 /* isSystemOrDefaultApp */ false);
 
         verifySetAppOptimizationMode(AppOpsManager.MODE_ALLOWED, /* allowListed */ false);
+        verify(mObserver).onChanged(ChangeReason.DELETE);
     }
 
     private void runTestForResetWithMode(
diff --git a/tests/robotests/src/com/android/settings/gestures/OneHandedSettingsUtilsTest.java b/tests/robotests/src/com/android/settings/gestures/OneHandedSettingsUtilsTest.java
index 9559043..ee5f72e 100644
--- a/tests/robotests/src/com/android/settings/gestures/OneHandedSettingsUtilsTest.java
+++ b/tests/robotests/src/com/android/settings/gestures/OneHandedSettingsUtilsTest.java
@@ -16,13 +16,20 @@
 
 package com.android.settings.gestures;
 
+import static com.android.settings.gestures.OneHandedSettingsUtils.ONE_HANDED_MODE_TARGET_NAME;
+
 import static com.google.common.truth.Truth.assertThat;
 
 import android.content.Context;
 import android.os.UserHandle;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
+import android.view.accessibility.Flags;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
@@ -30,7 +37,8 @@
 
 @RunWith(RobolectricTestRunner.class)
 public class OneHandedSettingsUtilsTest {
-
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     private static final int OFF = 0;
     private static final int ON = 1;
 
@@ -120,4 +128,66 @@
                 OneHandedSettingsUtils.OneHandedTimeout.LONG.getValue(), mCurrentUserId))
                 .isEqualTo(12);
     }
+
+    @Test
+    public void getShortcutEnabled_a11yButtonVolumeKeysShortcutEnabled_returnTrue() {
+        setupShortcuts(
+                /* enableFab= */ true, /* enableVolumeKeys= */ true, /* enableQs=*/ false);
+
+        assertThat(OneHandedSettingsUtils.getShortcutEnabled(mContext)).isTrue();
+    }
+
+    @Test
+    public void getShortcutEnabled_a11yButtonShortcutEnabled_returnTrue() {
+        setupShortcuts(
+                /* enableFab= */ true, /* enableVolumeKeys= */ false, /* enableQs=*/ false);
+
+        assertThat(OneHandedSettingsUtils.getShortcutEnabled(mContext)).isTrue();
+    }
+
+    @Test
+    public void getShortcutEnabled_volumeKeysShortcutEnabled_returnTrue() {
+        setupShortcuts(
+                /* enableFab= */ false, /* enableVolumeKeys= */ true, /* enableQs=*/ false);
+
+        assertThat(OneHandedSettingsUtils.getShortcutEnabled(mContext)).isTrue();
+    }
+
+    @Test
+    public void getShortcutEnabled_noShortcutsEnabled_returnFalse() {
+        setupShortcuts(
+                /* enableFab= */ false, /* enableVolumeKeys= */ false, /* enableQs=*/ false);
+
+        assertThat(OneHandedSettingsUtils.getShortcutEnabled(mContext)).isFalse();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void getShortcutEnabled_qsShortcutEnabled_returnTrue() {
+        setupShortcuts(
+                /* enableFab= */ false, /* enableVolumeKeys= */ false, /* enableQs=*/ true);
+
+        assertThat(OneHandedSettingsUtils.getShortcutEnabled(mContext)).isTrue();
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void getShortcutEnabled_flagDisabled_qsShortcutEnabled_returnFalse() {
+        setupShortcuts(
+                /* enableFab= */ false, /* enableVolumeKeys= */ false, /* enableQs=*/ true);
+
+        assertThat(OneHandedSettingsUtils.getShortcutEnabled(mContext)).isFalse();
+    }
+
+    private void setupShortcuts(boolean enableFab, boolean enableVolumeKeys, boolean enableQs) {
+        setupShortcut(Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS, enableFab);
+        setupShortcut(Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE, enableVolumeKeys);
+        setupShortcut(Settings.Secure.ACCESSIBILITY_QS_TARGETS, enableQs);
+    }
+
+    private void setupShortcut(String shortcutSettingKey, boolean enabled) {
+        final String targetName = enabled ? ONE_HANDED_MODE_TARGET_NAME : "";
+        Settings.Secure.putStringForUser(
+                mContext.getContentResolver(), shortcutSettingKey, targetName, mCurrentUserId);
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/network/SubscriptionUtilRoboTest.java b/tests/robotests/src/com/android/settings/network/SubscriptionUtilRoboTest.java
index 2595510..ae504be 100644
--- a/tests/robotests/src/com/android/settings/network/SubscriptionUtilRoboTest.java
+++ b/tests/robotests/src/com/android/settings/network/SubscriptionUtilRoboTest.java
@@ -16,11 +16,11 @@
 
 package com.android.settings.network;
 
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertFalse;
-import static org.mockito.ArgumentMatchers.any;
 import static org.robolectric.Shadows.shadowOf;
 
 import android.content.Context;
@@ -59,19 +59,19 @@
     }
 
     @Test
-    public void isConnectedToWifiOrDifferentSubId_hasDataOnSubId2_returnTrue() {
+    public void isConnectedToMobileDataWithDifferentSubId_hasDataOnSubId2_returnTrue() {
         addNetworkTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);
         mShadowSubscriptionManager.setActiveDataSubscriptionId(SUBID_2);
 
-        assertTrue(SubscriptionUtil.isConnectedToWifiOrDifferentSubId(mContext, SUBID_1));
+        assertTrue(SubscriptionUtil.isConnectedToMobileDataWithDifferentSubId(mContext, SUBID_1));
     }
 
     @Test
-    public void isConnectedToWifiOrDifferentSubId_hasDataOnSubId1_returnFalse() {
+    public void isConnectedToMobileDataWithDifferentSubId_hasDataOnSubId1_returnFalse() {
         addNetworkTransportType(NetworkCapabilities.TRANSPORT_CELLULAR);
         mShadowSubscriptionManager.setActiveDataSubscriptionId(SUBID_1);
 
-        assertFalse(SubscriptionUtil.isConnectedToWifiOrDifferentSubId(mContext, SUBID_1));
+        assertFalse(SubscriptionUtil.isConnectedToMobileDataWithDifferentSubId(mContext, SUBID_1));
     }
 
     private void addNetworkTransportType(int networkType) {
diff --git a/tests/robotests/src/com/android/settings/privatespace/HidePrivateSpaceControllerTest.java b/tests/robotests/src/com/android/settings/privatespace/HidePrivateSpaceControllerTest.java
new file mode 100644
index 0000000..7ff18a5
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/privatespace/HidePrivateSpaceControllerTest.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.privatespace;
+
+import static com.android.settings.core.BasePreferenceController.AVAILABLE;
+import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.platform.test.flag.junit.SetFlagsRule;
+
+import androidx.fragment.app.FragmentActivity;
+import androidx.test.core.app.ApplicationProvider;
+
+import com.android.settings.R;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadow.api.Shadow;
+import org.robolectric.shadows.ShadowAlertDialog;
+import org.robolectric.shadows.ShadowApplication;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = {ShadowAlertDialog.class})
+public class HidePrivateSpaceControllerTest {
+    @Rule public final MockitoRule mMockitoRule = MockitoJUnit.rule();
+    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+    private static final String KEY = "private_space_hidden";
+    private static final String DETAIL_PAGE_KEY = "private_space_hidden_details";
+    private HidePrivateSpaceController mHidePrivateSpaceController;
+    private HidePrivateSpaceSummaryController mHidePrivateSpaceSummaryController;
+    private FragmentActivity mActivity;
+
+    @Before
+    public void setUp() {
+        Context context = RuntimeEnvironment.application;
+        mHidePrivateSpaceController = new HidePrivateSpaceController(context, DETAIL_PAGE_KEY);
+        mHidePrivateSpaceSummaryController = new HidePrivateSpaceSummaryController(context, KEY);
+        mActivity = Robolectric.setupActivity(FragmentActivity.class);
+    }
+
+    /** Tests that when flags enabled the controller is available. */
+    @Test
+    public void getAvailabilityStatus_flagEnabled_returnsAvailable() {
+        mSetFlagsRule.enableFlags(android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
+
+        assertThat(mHidePrivateSpaceController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
+    }
+
+    /** Tests that when flags disabled the controller is unsupported. */
+    @Test
+    public void getAvailabilityStatus_flagDisabled_returnsUnsupported() {
+        mSetFlagsRule.disableFlags(android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
+
+        assertThat(mHidePrivateSpaceController.getAvailabilityStatus())
+                .isEqualTo(UNSUPPORTED_ON_DEVICE);
+    }
+
+    /** Tests that when hide toggle is enabled dialog is displayed. */
+    @Test
+    public void setChecked_enabled_showsDialog() {
+        mSetFlagsRule.enableFlags(android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
+        mHidePrivateSpaceController.setChecked(true);
+
+        ShadowAlertDialog shadowAlertDialog = getShadowAlertDialog();
+        assertThat(shadowAlertDialog).isNotNull();
+        assertThat(shadowAlertDialog.getTitle().toString())
+                .isEqualTo(mActivity.getString(R.string.private_space_hide_dialog_title));
+        assertThat(shadowAlertDialog.getMessage().toString())
+                .isEqualTo(mActivity.getString(R.string.private_space_hide_dialog_message));
+    }
+
+    /** Tests that when hide toggle is disabled dialog is not displayed. */
+    @Test
+    public void setChecked_disabled_NoDialogShown() {
+        mSetFlagsRule.enableFlags(android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
+        mHidePrivateSpaceController.setChecked(false);
+
+        ShadowAlertDialog shadowAlertDialog = getShadowAlertDialog();
+        assertThat(shadowAlertDialog).isNull();
+    }
+
+    /** Tests that when hide toggle is enabled then isChecked returns true. */
+    @Test
+    public void setChecked_enabled_isCheckedIsTrue() {
+        mSetFlagsRule.enableFlags(android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
+        mHidePrivateSpaceController.setChecked(true);
+        assertThat(mHidePrivateSpaceController.isChecked()).isTrue();
+    }
+
+    /** Tests that when hide toggle is disabled then isChecked returns false. */
+    @Test
+    public void setChecked_disabled_isCheckedIsFalse() {
+        mSetFlagsRule.enableFlags(android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
+        mHidePrivateSpaceController.setChecked(false);
+        assertThat(mHidePrivateSpaceController.isChecked()).isFalse();
+    }
+
+    /** Tests that hide preference summary displays On when toggle is enabled. */
+    @Test
+    public void setChecked_enable_summaryShouldDisplayOn() {
+        mSetFlagsRule.enableFlags(android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
+        mHidePrivateSpaceController.setChecked(true);
+
+        assertThat(mHidePrivateSpaceSummaryController.getSummary().toString()).isEqualTo("On");
+    }
+
+    /** Tests that hide preference summary displays Off when toggle is disabled. */
+    @Test
+    public void setChecked_disable_summaryShouldDisplayOff() {
+        mSetFlagsRule.enableFlags(android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
+        mHidePrivateSpaceController.setChecked(false);
+
+        assertThat(mHidePrivateSpaceSummaryController.getSummary().toString()).isEqualTo("Off");
+    }
+
+    private ShadowAlertDialog getShadowAlertDialog() {
+        ShadowApplication shadowApplication =
+                Shadow.extract(ApplicationProvider.getApplicationContext());
+        ShadowAlertDialog shadowAlertDialog = shadowApplication.getLatestAlertDialog();
+        return shadowAlertDialog;
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/security/ContentProtectionPreferenceUtilsTest.java b/tests/robotests/src/com/android/settings/security/ContentProtectionPreferenceUtilsTest.java
index 9b49434..d6f9abd 100644
--- a/tests/robotests/src/com/android/settings/security/ContentProtectionPreferenceUtilsTest.java
+++ b/tests/robotests/src/com/android/settings/security/ContentProtectionPreferenceUtilsTest.java
@@ -16,47 +16,73 @@
 
 package com.android.settings.security;
 
+import static android.view.contentprotection.flags.Flags.FLAG_MANAGE_DEVICE_POLICY_ENABLED;
+
 import static com.android.internal.R.string.config_defaultContentProtectionService;
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.app.admin.DevicePolicyManager;
 import android.content.ComponentName;
 import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.pm.UserInfo;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.DeviceConfig;
 import android.view.contentcapture.ContentCaptureManager;
 
 import com.android.settings.testutils.shadow.ShadowDeviceConfig;
 
 import org.junit.After;
-import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
+import java.util.List;
+
 @RunWith(RobolectricTestRunner.class)
-@Config(
-        shadows = {
-            ShadowDeviceConfig.class,
-        })
+@Config(shadows = {ShadowDeviceConfig.class})
 public class ContentProtectionPreferenceUtilsTest {
+
     private static final String PACKAGE_NAME = "com.test.package";
 
     private static final ComponentName COMPONENT_NAME =
             new ComponentName(PACKAGE_NAME, "TestClass");
 
-    private String mConfigDefaultContentProtectionService = COMPONENT_NAME.flattenToString();
+    private static final UserHandle USER_HANDLE = UserHandle.of(111);
+
+    private static final int PROCESS_USER_ID = 222;
+
+    private final String mConfigDefaultContentProtectionService = COMPONENT_NAME.flattenToString();
+
+    @Rule public final MockitoRule mMockitoRule = MockitoJUnit.rule();
+
+    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
 
     @Mock private Context mMockContext;
 
-    @Before
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-    }
+    @Mock private Context mMockUserContext;
+
+    @Mock private UserManager mMockUserManager;
+
+    @Mock private DevicePolicyManager mMockDevicePolicyManager;
+
+    @Mock private UserInfo mMockUserInfo;
 
     @After
     public void tearDown() {
@@ -134,7 +160,6 @@
         assertThat(ContentProtectionPreferenceUtils.isAvailable(mMockContext)).isFalse();
     }
 
-
     @Test
     public void isAvailable_bothDisabled_false() {
         DeviceConfig.setProperty(
@@ -145,4 +170,113 @@
 
         assertThat(ContentProtectionPreferenceUtils.isAvailable(mMockContext)).isFalse();
     }
+
+    @Test
+    public void getManagedProfile_noProfiles() {
+        when(mMockContext.getSystemService(UserManager.class)).thenReturn(mMockUserManager);
+        when(mMockUserManager.getUserProfiles()).thenReturn(List.of());
+
+        UserHandle actual = ContentProtectionPreferenceUtils.getManagedProfile(mMockContext);
+
+        assertThat(actual).isNull();
+    }
+
+    @Test
+    public void getManagedProfile_notManaged() {
+        when(mMockContext.getSystemService(UserManager.class)).thenReturn(mMockUserManager);
+        when(mMockUserManager.getUserProfiles()).thenReturn(List.of(USER_HANDLE));
+        when(mMockUserManager.getProcessUserId()).thenReturn(PROCESS_USER_ID);
+        when(mMockUserManager.getUserInfo(USER_HANDLE.getIdentifier())).thenReturn(mMockUserInfo);
+
+        UserHandle actual = ContentProtectionPreferenceUtils.getManagedProfile(mMockContext);
+
+        assertThat(actual).isNull();
+        verify(mMockUserInfo).isManagedProfile();
+    }
+
+    @Test
+    public void getManagedProfile_managed() {
+        when(mMockContext.getSystemService(UserManager.class)).thenReturn(mMockUserManager);
+        when(mMockUserManager.getUserProfiles()).thenReturn(List.of(USER_HANDLE));
+        when(mMockUserManager.getProcessUserId()).thenReturn(PROCESS_USER_ID);
+        when(mMockUserManager.getUserInfo(USER_HANDLE.getIdentifier())).thenReturn(mMockUserInfo);
+        when(mMockUserInfo.isManagedProfile()).thenReturn(true);
+
+        UserHandle actual = ContentProtectionPreferenceUtils.getManagedProfile(mMockContext);
+
+        assertThat(actual).isEqualTo(USER_HANDLE);
+    }
+
+    @Test
+    public void getContentProtectionPolicy_flagDisabled_managedProfileNull() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+
+        int actual =
+                ContentProtectionPreferenceUtils.getContentProtectionPolicy(
+                        mMockContext, /* managedProfile= */ null);
+
+        assertThat(actual).isEqualTo(DevicePolicyManager.CONTENT_PROTECTION_DISABLED);
+    }
+
+    @Test
+    public void getContentProtectionPolicy_flagDisabled_managedProfileNotNull() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+
+        int actual =
+                ContentProtectionPreferenceUtils.getContentProtectionPolicy(
+                        mMockContext, USER_HANDLE);
+
+        assertThat(actual).isEqualTo(DevicePolicyManager.CONTENT_PROTECTION_DISABLED);
+    }
+
+    @Test
+    public void getContentProtectionPolicy_flagEnabled_managedProfileNull() throws Exception {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        when(mMockContext.getSystemService(DevicePolicyManager.class))
+                .thenReturn(mMockDevicePolicyManager);
+        when(mMockDevicePolicyManager.getContentProtectionPolicy(/* admin= */ null))
+                .thenReturn(DevicePolicyManager.CONTENT_PROTECTION_ENABLED);
+
+        int actual =
+                ContentProtectionPreferenceUtils.getContentProtectionPolicy(
+                        mMockContext, /* managedProfile= */ null);
+
+        assertThat(actual).isEqualTo(DevicePolicyManager.CONTENT_PROTECTION_ENABLED);
+        verify(mMockContext, never()).createPackageContextAsUser(anyString(), anyInt(), any());
+    }
+
+    @Test
+    public void getContentProtectionPolicy_flagEnabled_managedProfileNotNull() throws Exception {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        when(mMockContext.getPackageName()).thenReturn(PACKAGE_NAME);
+        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, /* flags= */ 0, USER_HANDLE))
+                .thenReturn(mMockUserContext);
+        when(mMockUserContext.getSystemService(DevicePolicyManager.class))
+                .thenReturn(mMockDevicePolicyManager);
+        when(mMockDevicePolicyManager.getContentProtectionPolicy(/* admin= */ null))
+                .thenReturn(DevicePolicyManager.CONTENT_PROTECTION_ENABLED);
+
+        int actual =
+                ContentProtectionPreferenceUtils.getContentProtectionPolicy(
+                        mMockContext, USER_HANDLE);
+
+        assertThat(actual).isEqualTo(DevicePolicyManager.CONTENT_PROTECTION_ENABLED);
+    }
+
+    @Test
+    public void getContentProtectionPolicy_flagEnabled_managedProfileNotNull_nameNotFound()
+            throws Exception {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        when(mMockContext.getPackageName()).thenReturn(PACKAGE_NAME);
+        when(mMockContext.createPackageContextAsUser(PACKAGE_NAME, /* flags= */ 0, USER_HANDLE))
+                .thenThrow(new PackageManager.NameNotFoundException());
+
+        assertThrows(
+                IllegalStateException.class,
+                () ->
+                        ContentProtectionPreferenceUtils.getContentProtectionPolicy(
+                                mMockContext, USER_HANDLE));
+
+        verify(mMockContext, never()).getSystemService(DevicePolicyManager.class);
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/security/ContentProtectionTogglePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/security/ContentProtectionTogglePreferenceControllerTest.java
index 50e9a5c..075ac6c 100644
--- a/tests/robotests/src/com/android/settings/security/ContentProtectionTogglePreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/security/ContentProtectionTogglePreferenceControllerTest.java
@@ -15,20 +15,25 @@
  */
 package com.android.settings.security;
 
+import static android.view.contentprotection.flags.Flags.FLAG_MANAGE_DEVICE_POLICY_ENABLED;
+
+import static com.android.settings.core.BasePreferenceController.AVAILABLE;
 import static com.android.settings.security.ContentProtectionTogglePreferenceController.KEY_CONTENT_PROTECTION_PREFERENCE;
 
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.app.admin.DevicePolicyManager;
 import android.content.Context;
+import android.os.UserHandle;
 import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
 
+import androidx.annotation.Nullable;
 import androidx.preference.PreferenceScreen;
 import androidx.test.core.app.ApplicationProvider;
 
@@ -42,37 +47,40 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
 @RunWith(RobolectricTestRunner.class)
-@Config(
-        shadows = {
-            ShadowUtils.class,
-        })
+@Config(shadows = {ShadowUtils.class})
 public class ContentProtectionTogglePreferenceControllerTest {
 
-    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     @Rule public final MockitoRule mMockitoRule = MockitoJUnit.rule();
 
-    @Mock private PreferenceScreen mMockScreen;
+    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
 
-    private RestrictedLockUtils.EnforcedAdmin mAdmin;
-    private SettingsMainSwitchPreference mSwitchPreference;
     private final Context mContext = ApplicationProvider.getApplicationContext();
-    private ContentProtectionTogglePreferenceController mController;
+
+    @Mock private PreferenceScreen mMockPreferenceScreen;
+
+    @Mock private SettingsMainSwitchPreference mMockSwitchPreference;
+
+    @Nullable private RestrictedLockUtils.EnforcedAdmin mEnforcedAdmin;
+
+    @DevicePolicyManager.ContentProtectionPolicy
+    private int mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+
+    private TestContentProtectionTogglePreferenceController mController;
+
     private int mSettingBackupValue;
 
     @Before
     public void setUp() {
-        MockitoAnnotations.initMocks(this);
         mController = new TestContentProtectionTogglePreferenceController();
-        mSwitchPreference = new SettingsMainSwitchPreference(mContext);
-        when(mMockScreen.findPreference(mController.getPreferenceKey()))
-                .thenReturn(mSwitchPreference);
+        SettingsMainSwitchPreference switchPreference = new SettingsMainSwitchPreference(mContext);
+        when(mMockPreferenceScreen.findPreference(mController.getPreferenceKey()))
+                .thenReturn(switchPreference);
         mSettingBackupValue = getContentProtectionGlobalSetting();
         Settings.Global.putInt(mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, 0);
     }
@@ -87,89 +95,223 @@
     }
 
     @Test
-    public void isAvailable_alwaysAvailable() {
+    public void constructor_flagDisabled_doesNotFetchData() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mController = new TestContentProtectionTogglePreferenceController();
+
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(0);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(0);
+        assertThat(mController.mCounterGetContentProtectionPolicy).isEqualTo(0);
+    }
+
+    @Test
+    public void constructor_flagEnabled_fetchesData() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mController = new TestContentProtectionTogglePreferenceController();
+
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(1);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        assertThat(mController.mCounterGetContentProtectionPolicy).isEqualTo(1);
+    }
+
+    @Test
+    public void getAvailabilityStatus_available() {
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
         assertThat(mController.isAvailable()).isTrue();
     }
 
     @Test
-    public void displayPreference() {
-        setUpFullyManagedMode();
-        SettingsMainSwitchPreference mockSwitchPreference =
-                mock(SettingsMainSwitchPreference.class);
-        when(mMockScreen.findPreference(any())).thenReturn(mockSwitchPreference);
-        when(mockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
-
-        mController = new TestContentProtectionTogglePreferenceController();
-        mController.displayPreference(mMockScreen);
-
-        assertThat(mockSwitchPreference).isNotNull();
-    }
-
-    @Test
-    public void updateState_notFullyManagedMode_enabled() {
-        SettingsMainSwitchPreference mockSwitchPreference =
-                mock(SettingsMainSwitchPreference.class);
-        when(mMockScreen.findPreference(any())).thenReturn(mockSwitchPreference);
-        when(mockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
-
-        mController = new TestContentProtectionTogglePreferenceController();
-        mController.displayPreference(mMockScreen);
-        mController.updateState(mockSwitchPreference);
-
-        verify(mockSwitchPreference, never()).setDisabledByAdmin(any());
-    }
-
-    @Test
-    public void updateState_fullyManagedMode_disabled() {
-        setUpFullyManagedMode();
-        SettingsMainSwitchPreference mockSwitchPreference =
-                mock(SettingsMainSwitchPreference.class);
-        when(mMockScreen.findPreference(any())).thenReturn(mockSwitchPreference);
-        when(mockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
-
-        mController = new TestContentProtectionTogglePreferenceController();
-        mController.displayPreference(mMockScreen);
-        mController.updateState(mockSwitchPreference);
-
-        verify(mockSwitchPreference).setDisabledByAdmin(mAdmin);
-    }
-
-    @Test
-    public void isChecked_settingTurnOn() {
+    public void isChecked_noEnforcedAdmin_readsSettingsTrue() {
         Settings.Global.putInt(mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, 1);
 
         assertThat(mController.isChecked()).isTrue();
     }
 
     @Test
-    public void isChecked_fullyManagedMode_settingTurnOff() {
-        setUpFullyManagedMode();
-        Settings.Global.putInt(mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, 1);
-        SettingsMainSwitchPreference mockSwitchPreference =
-                mock(SettingsMainSwitchPreference.class);
-        when(mMockScreen.findPreference(any())).thenReturn(mockSwitchPreference);
-        when(mockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
-
-        mController = new TestContentProtectionTogglePreferenceController();
-        mController.displayPreference(mMockScreen);
-        mController.updateState(mockSwitchPreference);
-
-        assertThat(mController.isChecked()).isFalse();
-    }
-
-    @Test
-    public void isChecked_settingTurnOff() {
+    public void isChecked_noEnforcedAdmin_readsSettingsFalse() {
         Settings.Global.putInt(
                 mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, -1);
 
         assertThat(mController.isChecked()).isFalse();
-        assertThat(getContentProtectionGlobalSetting()).isEqualTo(-1);
     }
 
     @Test
-    public void isChecked_settingDefaultOn() {
+    public void isChecked_noEnforcedAdmin_readsSettingsDefaultTrue() {
         assertThat(mController.isChecked()).isTrue();
-        assertThat(getContentProtectionGlobalSetting()).isEqualTo(0);
+    }
+
+    @Test
+    public void isChecked_enforcedAdmin_flagDisabled_false() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        Settings.Global.putInt(mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, 1);
+        setupForUpdateState();
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.isChecked()).isFalse();
+    }
+
+    @Test
+    public void isChecked_enforcedAdmin_flagEnabled_policyDisabled_false() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+        Settings.Global.putInt(mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, 1);
+        mController = new TestContentProtectionTogglePreferenceController();
+
+        assertThat(mController.isChecked()).isFalse();
+    }
+
+    @Test
+    public void isChecked_enforcedAdmin_flagEnabled_policyEnabled_true() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_ENABLED;
+        Settings.Global.putInt(
+                mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, -1);
+        mController = new TestContentProtectionTogglePreferenceController();
+
+        assertThat(mController.isChecked()).isTrue();
+    }
+
+    @Test
+    public void isChecked_enforcedAdmin_flagEnabled_policyNotControlled_readsSettingsTrue() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY;
+        Settings.Global.putInt(mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, 1);
+        mController = new TestContentProtectionTogglePreferenceController();
+
+        assertThat(mController.isChecked()).isTrue();
+    }
+
+    @Test
+    public void isChecked_enforcedAdmin_flagEnabled_policyNotControlled_readsSettingsFalse() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY;
+        Settings.Global.putInt(
+                mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, -1);
+        mController = new TestContentProtectionTogglePreferenceController();
+
+        assertThat(mController.isChecked()).isFalse();
+    }
+
+    @Test
+    public void isChecked_enforcedAdmin_flagEnabled_policyNotControlled_readsSettingsDefaultTrue() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY;
+        mController = new TestContentProtectionTogglePreferenceController();
+
+        assertThat(mController.isChecked()).isTrue();
+    }
+
+    @Test
+    public void displayPreference() {
+        setupForDisplayPreference();
+
+        mController.displayPreference(mMockPreferenceScreen);
+
+        verify(mMockSwitchPreference).addOnSwitchChangeListener(mController);
+    }
+
+    @Test
+    public void updateState_flagDisabled_noEnforcedAdmin() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        setupForUpdateState();
+
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        verify(mMockSwitchPreference, never()).setDisabledByAdmin(any());
+    }
+
+    @Test
+    public void updateState_flagDisabled_enforcedAdmin() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        setupForUpdateState();
+
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        verify(mMockSwitchPreference).setDisabledByAdmin(mEnforcedAdmin);
+    }
+
+    @Test
+    public void updateState_flagEnabled_noEnforcedAdmin_policyDisabled() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+        setupForUpdateState();
+
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        verify(mMockSwitchPreference, never()).setDisabledByAdmin(any());
+    }
+
+    @Test
+    public void updateState_flagEnabled_noEnforcedAdmin_policyEnabled() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_ENABLED;
+        setupForUpdateState();
+
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        verify(mMockSwitchPreference, never()).setDisabledByAdmin(any());
+    }
+
+    @Test
+    public void updateState_flagEnabled_noEnforcedAdmin_policyNotControlled() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY;
+        setupForUpdateState();
+
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        verify(mMockSwitchPreference, never()).setDisabledByAdmin(any());
+    }
+
+    @Test
+    public void updateState_flagEnabled_enforcedAdmin_policyDisabled() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+        setupForUpdateState();
+
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        verify(mMockSwitchPreference).setDisabledByAdmin(mEnforcedAdmin);
+    }
+
+    @Test
+    public void updateState_flagEnabled_enforcedAdmin_policyEnabled() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_ENABLED;
+        setupForUpdateState();
+
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        verify(mMockSwitchPreference).setDisabledByAdmin(mEnforcedAdmin);
+    }
+
+    @Test
+    public void updateState_flagEnabled_enforcedAdmin_policyNotControlled() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY;
+        setupForUpdateState();
+
+        mController.updateState(mMockSwitchPreference);
+
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
+        verify(mMockSwitchPreference, never()).setDisabledByAdmin(any());
     }
 
     @Test
@@ -193,20 +335,49 @@
                 mContext.getContentResolver(), KEY_CONTENT_PROTECTION_PREFERENCE, 0);
     }
 
-    private void setUpFullyManagedMode() {
-        mAdmin = new RestrictedLockUtils.EnforcedAdmin();
+    private void setupForDisplayPreference() {
+        when(mMockPreferenceScreen.findPreference(any())).thenReturn(mMockSwitchPreference);
+        when(mMockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
+        mController = new TestContentProtectionTogglePreferenceController();
+    }
+
+    private void setupForUpdateState() {
+        setupForDisplayPreference();
+        mController.displayPreference(mMockPreferenceScreen);
     }
 
     private class TestContentProtectionTogglePreferenceController
             extends ContentProtectionTogglePreferenceController {
 
+        public int mCounterGetManagedProfile;
+
+        public int mCounterGetEnforcedAdmin;
+
+        public int mCounterGetContentProtectionPolicy;
+
         TestContentProtectionTogglePreferenceController() {
             super(ContentProtectionTogglePreferenceControllerTest.this.mContext, "key");
         }
 
         @Override
+        @Nullable
+        protected UserHandle getManagedProfile() {
+            mCounterGetManagedProfile++;
+            return null;
+        }
+
+        @Override
+        @Nullable
         protected RestrictedLockUtils.EnforcedAdmin getEnforcedAdmin() {
-            return mAdmin;
+            mCounterGetEnforcedAdmin++;
+            return mEnforcedAdmin;
+        }
+
+        @Override
+        @DevicePolicyManager.ContentProtectionPolicy
+        protected int getContentProtectionPolicy(@Nullable UserHandle userHandle) {
+            mCounterGetContentProtectionPolicy++;
+            return mContentProtectionPolicy;
         }
     }
 }
diff --git a/tests/robotests/src/com/android/settings/security/ContentProtectionWorkSwitchControllerTest.java b/tests/robotests/src/com/android/settings/security/ContentProtectionWorkSwitchControllerTest.java
index 8d35e4d..3d367de 100644
--- a/tests/robotests/src/com/android/settings/security/ContentProtectionWorkSwitchControllerTest.java
+++ b/tests/robotests/src/com/android/settings/security/ContentProtectionWorkSwitchControllerTest.java
@@ -16,19 +16,22 @@
 
 package com.android.settings.security;
 
+import static android.view.contentprotection.flags.Flags.FLAG_MANAGE_DEVICE_POLICY_ENABLED;
+
 import static com.android.settings.core.BasePreferenceController.AVAILABLE;
 import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE;
 
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.app.admin.DevicePolicyManager;
 import android.content.Context;
 import android.os.UserHandle;
+import android.platform.test.flag.junit.SetFlagsRule;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -39,55 +42,169 @@
 import com.android.settingslib.RestrictedSwitchPreference;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
 
 @RunWith(RobolectricTestRunner.class)
 public class ContentProtectionWorkSwitchControllerTest {
+
     private static final UserHandle TEST_USER_HANDLE = UserHandle.of(10);
 
+    @Rule public final MockitoRule mMockitoRule = MockitoJUnit.rule();
+
+    @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+
     private final Context mContext = ApplicationProvider.getApplicationContext();
 
     @Mock private PreferenceScreen mMockPreferenceScreen;
-    private ContentProtectionWorkSwitchController mController;
-    private UserHandle mManagedProfileUserHandle;
-    private RestrictedLockUtils.EnforcedAdmin mEnforcedAdmin;
+
+    @Mock private RestrictedSwitchPreference mMockSwitchPreference;
+
+    @Nullable private UserHandle mManagedProfileUserHandle;
+
+    @Nullable private RestrictedLockUtils.EnforcedAdmin mEnforcedAdmin;
+
+    @DevicePolicyManager.ContentProtectionPolicy
+    private int mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+
+    private TestContentProtectionWorkSwitchController mController;
 
     @Before
     public void setUp() {
-        MockitoAnnotations.initMocks(this);
         mController = new TestContentProtectionWorkSwitchController();
     }
 
     @Test
-    public void isAvailable_managedProfile_available() {
+    public void constructor_flagDisabled_doesNotFetchData() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(0);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(0);
+        assertThat(mController.mCounterGetContentProtectionPolicy).isEqualTo(0);
+    }
+
+    @Test
+    public void constructor_flagEnabled_fetchesManagedProfile() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(1);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(0);
+        assertThat(mController.mCounterGetContentProtectionPolicy).isEqualTo(0);
+    }
+
+    @Test
+    public void constructor_flagEnabled_withManagedProfile_fetchesPolicy() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
         mManagedProfileUserHandle = TEST_USER_HANDLE;
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(1);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(0);
+        assertThat(mController.mCounterGetContentProtectionPolicy).isEqualTo(1);
+    }
+
+    @Test
+    public void getAvailabilityStatus_flagDisabled_managedProfile_available() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mManagedProfileUserHandle = TEST_USER_HANDLE;
+        mController = new TestContentProtectionWorkSwitchController();
 
         assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
         assertThat(mController.isAvailable()).isTrue();
     }
 
     @Test
-    public void isAvailable_noManagedProfile_notAvailable() {
-        mManagedProfileUserHandle = null;
+    public void getAvailabilityStatus_flagDisabled_noManagedProfile_unavailable() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mController = new TestContentProtectionWorkSwitchController();
 
         assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
         assertThat(mController.isAvailable()).isFalse();
     }
 
     @Test
-    public void isChecked_noManagedProfile_alwaysOff() {
-        mManagedProfileUserHandle = null;
+    public void getAvailabilityStatus_flagEnabled_managedProfile_policyDisabled_available() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mManagedProfileUserHandle = TEST_USER_HANDLE;
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
+        assertThat(mController.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void getAvailabilityStatus_flagEnabled_managedProfile_policyEnabled_available() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mManagedProfileUserHandle = TEST_USER_HANDLE;
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_ENABLED;
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
+        assertThat(mController.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void getAvailabilityStatus_flagEnabled_managedProfile_policyNotControlled_unavailable() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mManagedProfileUserHandle = TEST_USER_HANDLE;
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY;
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @Test
+    public void getAvailabilityStatus_flagEnabled_noManagedProfile_unavailable() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @Test
+    public void isChecked_flagDisabled_false() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mController = new TestContentProtectionWorkSwitchController();
 
         assertThat(mController.isChecked()).isFalse();
     }
 
     @Test
-    public void isChecked_managedProfile_alwaysOff() {
+    public void isChecked_flagEnabled_policyEnabled_true() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
         mManagedProfileUserHandle = TEST_USER_HANDLE;
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_ENABLED;
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.isChecked()).isTrue();
+    }
+
+    @Test
+    public void isChecked_flagEnabled_policyDisabled_false() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mManagedProfileUserHandle = TEST_USER_HANDLE;
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_DISABLED;
+        mController = new TestContentProtectionWorkSwitchController();
+
+        assertThat(mController.isChecked()).isFalse();
+    }
+
+    @Test
+    public void isChecked_flagEnabled_policyNotControlled_false() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mManagedProfileUserHandle = TEST_USER_HANDLE;
+        mContentProtectionPolicy = DevicePolicyManager.CONTENT_PROTECTION_NOT_CONTROLLED_BY_POLICY;
+        mController = new TestContentProtectionWorkSwitchController();
 
         assertThat(mController.isChecked()).isFalse();
     }
@@ -99,50 +216,72 @@
     }
 
     @Test
-    public void displayPreference_managedProfile_disabled() {
+    public void displayPreference_flagDisabled_managedProfile_disabledByAdmin() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
         mManagedProfileUserHandle = TEST_USER_HANDLE;
         mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
-        RestrictedSwitchPreference mockSwitchPreference = mock(RestrictedSwitchPreference.class);
-        when(mMockPreferenceScreen.findPreference(any())).thenReturn(mockSwitchPreference);
-        when(mockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
+        setupForDisplayPreference();
 
         mController.displayPreference(mMockPreferenceScreen);
 
-        assertThat(mController.isAvailable()).isTrue();
-        verify(mockSwitchPreference).setDisabledByAdmin(mEnforcedAdmin);
+        verify(mMockSwitchPreference).setDisabledByAdmin(mEnforcedAdmin);
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(3);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
     }
 
     @Test
-    public void displayPreference_noManagedProfile_notDisabled() {
-        mManagedProfileUserHandle = null;
+    public void displayPreference_flagDisabled_noManagedProfile_notDisabledByAdmin() {
+        mSetFlagsRule.disableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        setupForDisplayPreference();
+
+        mController.displayPreference(mMockPreferenceScreen);
+
+        verify(mMockSwitchPreference, never()).setDisabledByAdmin(any());
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(3);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(0);
+    }
+
+    @Test
+    public void displayPreference_flagEnabled_managedProfile_disabledByAdmin() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        mManagedProfileUserHandle = TEST_USER_HANDLE;
         mEnforcedAdmin = new RestrictedLockUtils.EnforcedAdmin();
-        RestrictedSwitchPreference mockSwitchPreference = mock(RestrictedSwitchPreference.class);
-        when(mMockPreferenceScreen.findPreference(any())).thenReturn(mockSwitchPreference);
-        when(mockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
+        setupForDisplayPreference();
 
         mController.displayPreference(mMockPreferenceScreen);
 
-        assertThat(mController.isAvailable()).isFalse();
-        verify(mockSwitchPreference, never()).setDisabledByAdmin(any());
+        verify(mMockSwitchPreference).setDisabledByAdmin(mEnforcedAdmin);
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(1);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(1);
     }
 
     @Test
-    public void displayPreference_noEnforcedAdmin_notDisabled() {
-        mManagedProfileUserHandle = null;
-        mEnforcedAdmin = null;
-        RestrictedSwitchPreference mockSwitchPreference = mock(RestrictedSwitchPreference.class);
-        when(mMockPreferenceScreen.findPreference(any())).thenReturn(mockSwitchPreference);
-        when(mockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
+    public void displayPreference_flagEnabled_noManagedProfile_notDisabledByAdmin() {
+        mSetFlagsRule.enableFlags(FLAG_MANAGE_DEVICE_POLICY_ENABLED);
+        setupForDisplayPreference();
 
         mController.displayPreference(mMockPreferenceScreen);
 
-        assertThat(mController.isAvailable()).isFalse();
-        verify(mockSwitchPreference, never()).setDisabledByAdmin(any());
+        verify(mMockSwitchPreference, never()).setDisabledByAdmin(any());
+        assertThat(mController.mCounterGetManagedProfile).isEqualTo(1);
+        assertThat(mController.mCounterGetEnforcedAdmin).isEqualTo(0);
+    }
+
+    private void setupForDisplayPreference() {
+        when(mMockPreferenceScreen.findPreference(any())).thenReturn(mMockSwitchPreference);
+        when(mMockSwitchPreference.getKey()).thenReturn(mController.getPreferenceKey());
+        mController = new TestContentProtectionWorkSwitchController();
     }
 
     private class TestContentProtectionWorkSwitchController
             extends ContentProtectionWorkSwitchController {
 
+        public int mCounterGetManagedProfile;
+
+        public int mCounterGetEnforcedAdmin;
+
+        public int mCounterGetContentProtectionPolicy;
+
         TestContentProtectionWorkSwitchController() {
             super(ContentProtectionWorkSwitchControllerTest.this.mContext, "key");
         }
@@ -150,14 +289,23 @@
         @Override
         @Nullable
         protected UserHandle getManagedProfile() {
+            mCounterGetManagedProfile++;
             return mManagedProfileUserHandle;
         }
 
         @Override
         @Nullable
         protected RestrictedLockUtils.EnforcedAdmin getEnforcedAdmin(
-                @NonNull UserHandle managedProfile) {
+                @NonNull UserHandle userHandle) {
+            mCounterGetEnforcedAdmin++;
             return mEnforcedAdmin;
         }
+
+        @Override
+        @DevicePolicyManager.ContentProtectionPolicy
+        protected int getContentProtectionPolicy(@Nullable UserHandle userHandle) {
+            mCounterGetContentProtectionPolicy++;
+            return mContentProtectionPolicy;
+        }
     }
 }
diff --git a/tests/robotests/src/com/android/settings/testutils/AccessibilityTestUtils.java b/tests/robotests/src/com/android/settings/testutils/AccessibilityTestUtils.java
index 8cda2d9..5d895d9 100644
--- a/tests/robotests/src/com/android/settings/testutils/AccessibilityTestUtils.java
+++ b/tests/robotests/src/com/android/settings/testutils/AccessibilityTestUtils.java
@@ -20,11 +20,25 @@
 import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_3BUTTON;
 import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import android.accessibilityservice.AccessibilityServiceInfo;
+import android.content.ComponentName;
 import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
 import android.provider.Settings;
+import android.view.accessibility.AccessibilityManager;
 
 import com.android.settings.testutils.shadow.SettingsShadowResources;
 
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.IOException;
+
 /**
  * Utility class for common methods used in the accessibility feature related tests
  */
@@ -47,4 +61,39 @@
                     NAV_BAR_MODE_3BUTTON);
         }
     }
+
+    /**
+     * Returns a mock {@link AccessibilityManager}
+     */
+    public static AccessibilityManager setupMockAccessibilityManager(Context mockContext) {
+        AccessibilityManager am = mock(AccessibilityManager.class);
+        when(mockContext.getSystemService(AccessibilityManager.class)).thenReturn(am);
+        return am;
+    }
+
+    public static AccessibilityServiceInfo createAccessibilityServiceInfo(
+            Context context, ComponentName componentName, boolean isAlwaysOnService) {
+        final ApplicationInfo applicationInfo = new ApplicationInfo();
+        applicationInfo.targetSdkVersion = Build.VERSION_CODES.R;
+        final ServiceInfo serviceInfo = new ServiceInfo();
+        applicationInfo.packageName = componentName.getPackageName();
+        serviceInfo.packageName = componentName.getPackageName();
+        serviceInfo.name = componentName.getClassName();
+        serviceInfo.applicationInfo = applicationInfo;
+
+        final ResolveInfo resolveInfo = new ResolveInfo();
+        resolveInfo.serviceInfo = serviceInfo;
+        try {
+            final AccessibilityServiceInfo info = new AccessibilityServiceInfo(resolveInfo,
+                    context);
+            info.setComponentName(componentName);
+            if (isAlwaysOnService) {
+                info.flags |= AccessibilityServiceInfo.FLAG_REQUEST_ACCESSIBILITY_BUTTON;
+            }
+            return info;
+        } catch (XmlPullParserException | IOException e) {
+            // Do nothing
+        }
+        return null;
+    }
 }
diff --git a/tests/robotests/src/com/android/settings/testutils/shadow/ShadowAccessibilityManager.java b/tests/robotests/src/com/android/settings/testutils/shadow/ShadowAccessibilityManager.java
new file mode 100644
index 0000000..d6e17d4
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/testutils/shadow/ShadowAccessibilityManager.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.testutils.shadow;
+
+import android.annotation.UserIdInt;
+import android.content.ComponentName;
+import android.view.accessibility.AccessibilityManager;
+
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * Shadow of {@link AccessibilityManager} with the hidden methods
+ */
+@Implements(AccessibilityManager.class)
+public class ShadowAccessibilityManager extends org.robolectric.shadows.ShadowAccessibilityManager {
+    /**
+     * Implements a hidden method {@link AccessibilityManager.getA11yFeatureToTileMap} and returns
+     * an empty map.
+     */
+    @Implementation
+    public Map<ComponentName, ComponentName> getA11yFeatureToTileMap(@UserIdInt int userId) {
+        return Collections.emptyMap();
+    }
+}
diff --git a/tests/robotests/src/com/android/settings/wifi/WifiConfigController2Test.java b/tests/robotests/src/com/android/settings/wifi/WifiConfigController2Test.java
index 4fcc93d..7d96496 100644
--- a/tests/robotests/src/com/android/settings/wifi/WifiConfigController2Test.java
+++ b/tests/robotests/src/com/android/settings/wifi/WifiConfigController2Test.java
@@ -16,6 +16,7 @@
 
 package com.android.settings.wifi;
 
+import static com.android.settings.wifi.WifiConfigController.DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE;
 import static com.android.settings.wifi.WifiConfigController2.DEFAULT_ANONYMOUS_ID;
 import static com.android.settings.wifi.WifiConfigController2.WIFI_EAP_METHOD_SIM;
 
@@ -56,6 +57,7 @@
 import com.android.settings.R;
 import com.android.settings.network.SubscriptionUtil;
 import com.android.settings.utils.AndroidKeystoreAliasLoader;
+import com.android.settings.wifi.details2.WifiPrivacyPreferenceController;
 import com.android.settings.wifi.details2.WifiPrivacyPreferenceController2;
 import com.android.wifitrackerlib.WifiEntry;
 
@@ -513,6 +515,42 @@
     }
 
     @Test
+    public void loadSavedDhcpValue_true() {
+        checkSavedDhcpValue(true);
+    }
+
+    @Test
+    public void loadSavedDhcpValue_false() {
+        checkSavedDhcpValue(false);
+    }
+
+    private void checkSavedDhcpValue(boolean dhcpValue) {
+        when(mWifiEntry.isSaved()).thenReturn(true);
+        final WifiConfiguration mockWifiConfig = mock(WifiConfiguration.class);
+        when(mockWifiConfig.getIpConfiguration()).thenReturn(mock(IpConfiguration.class));
+        when(mockWifiConfig.isSendDhcpHostnameEnabled()).thenReturn(dhcpValue);
+        when(mWifiEntry.getWifiConfiguration()).thenReturn(mockWifiConfig);
+        createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false);
+        final Spinner dhcpSetting = mView.findViewById(R.id.dhcp_settings);
+        final int expectedPrefValue =
+                WifiPrivacyPreferenceController.Companion
+                        .translateSendDhcpHostnameEnabledToPrefValue(dhcpValue);
+
+        assertThat(dhcpSetting.getVisibility()).isEqualTo(View.VISIBLE);
+        assertThat(dhcpSetting.getSelectedItemPosition()).isEqualTo(expectedPrefValue);
+    }
+
+    @Test
+    public void saveDhcpValue_changedToFalse() {
+        createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false);
+        final Spinner privacySetting = mView.findViewById(R.id.dhcp_settings);
+        privacySetting.setSelection(DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE);
+
+        WifiConfiguration config = mController.getConfig();
+        assertThat(config.isSendDhcpHostnameEnabled()).isEqualTo(false);
+    }
+
+    @Test
     public void replaceTtsString_whenTargetMatched_shouldSuccess() {
         createController(mWifiEntry, WifiConfigUiBase2.MODE_CONNECT, false);
         final CharSequence[] display = {"PEAP", "AKA1", "AKA2'"};
diff --git a/tests/robotests/src/com/android/settings/wifi/WifiConfigControllerTest.java b/tests/robotests/src/com/android/settings/wifi/WifiConfigControllerTest.java
index 2ff4596..d80464d 100644
--- a/tests/robotests/src/com/android/settings/wifi/WifiConfigControllerTest.java
+++ b/tests/robotests/src/com/android/settings/wifi/WifiConfigControllerTest.java
@@ -18,6 +18,8 @@
 
 import static com.android.settings.wifi.WifiConfigController.PRIVACY_SPINNER_INDEX_DEVICE_MAC;
 import static com.android.settings.wifi.WifiConfigController.PRIVACY_SPINNER_INDEX_RANDOMIZED_MAC;
+import static com.android.settings.wifi.WifiConfigController.DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_ENABLE;
+import static com.android.settings.wifi.WifiConfigController.DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -451,6 +453,41 @@
     }
 
     @Test
+    public void loadSavedDhcpValue_true() {
+        checkSavedDhcpValue(true);
+    }
+
+    @Test
+    public void loadSavedDhcpValue_false() {
+        checkSavedDhcpValue(false);
+    }
+
+    private void checkSavedDhcpValue(boolean dhcpValue) {
+        when(mAccessPoint.isSaved()).thenReturn(true);
+        final WifiConfiguration mockWifiConfig = mock(WifiConfiguration.class);
+        when(mockWifiConfig.getIpConfiguration()).thenReturn(mock(IpConfiguration.class));
+        when(mockWifiConfig.isSendDhcpHostnameEnabled()).thenReturn(dhcpValue);
+        when(mAccessPoint.getConfig()).thenReturn(mockWifiConfig);
+        mController = new TestWifiConfigController(mConfigUiBase, mView, mAccessPoint,
+                WifiConfigUiBase.MODE_CONNECT);
+        final Spinner dhcpSetting = mView.findViewById(R.id.dhcp_settings);
+
+        assertThat(dhcpSetting.getVisibility()).isEqualTo(View.VISIBLE);
+        assertThat(dhcpSetting.getSelectedItemPosition()).isEqualTo(
+                dhcpValue ? DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_ENABLE :
+                        DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE);
+    }
+
+    @Test
+    public void saveDhcpValue_changedToFalse() {
+        final Spinner privacySetting = mView.findViewById(R.id.dhcp_settings);
+        privacySetting.setSelection(DHCP_SPINNER_INDEX_SEND_DHCP_HOST_NAME_DISABLE);
+
+        WifiConfiguration config = mController.getConfig();
+        assertThat(config.isSendDhcpHostnameEnabled()).isEqualTo(false);
+    }
+
+    @Test
     public void replaceTtsString_whenTargetMatched_shouldSuccess() {
         final CharSequence[] display = {"PEAP", "AKA1", "AKA2'"};
         final CharSequence[] target = {"AKA1", "AKA2'"};
diff --git a/tests/screenshot/assets/robolectric/fp_enroll_confirmation.png b/tests/screenshot/assets/robolectric/fp_enroll_confirmation.png
index db9009b..fe3353e 100644
--- a/tests/screenshot/assets/robolectric/fp_enroll_confirmation.png
+++ b/tests/screenshot/assets/robolectric/fp_enroll_confirmation.png
Binary files differ
diff --git a/tests/screenshot/assets/robolectric/fp_enroll_enrolling.png b/tests/screenshot/assets/robolectric/fp_enroll_enrolling.png
index 1299f2a..7a3b8da 100644
--- a/tests/screenshot/assets/robolectric/fp_enroll_enrolling.png
+++ b/tests/screenshot/assets/robolectric/fp_enroll_enrolling.png
Binary files differ
diff --git a/tests/screenshot/assets/robolectric/fp_enroll_find_sensor.png b/tests/screenshot/assets/robolectric/fp_enroll_find_sensor.png
index a252e5e..e92d606 100644
--- a/tests/screenshot/assets/robolectric/fp_enroll_find_sensor.png
+++ b/tests/screenshot/assets/robolectric/fp_enroll_find_sensor.png
Binary files differ
diff --git a/tests/screenshot/assets/robolectric/fp_enroll_intro.png b/tests/screenshot/assets/robolectric/fp_enroll_intro.png
index 3cd9f4a..a0c7556 100644
--- a/tests/screenshot/assets/robolectric/fp_enroll_intro.png
+++ b/tests/screenshot/assets/robolectric/fp_enroll_intro.png
Binary files differ
diff --git a/tests/screenshot/src/com/android/settings/tests/screenshot/biometrics/fingerprint/Injector.kt b/tests/screenshot/src/com/android/settings/tests/screenshot/biometrics/fingerprint/Injector.kt
index 3cd2002..9d97fbf 100644
--- a/tests/screenshot/src/com/android/settings/tests/screenshot/biometrics/fingerprint/Injector.kt
+++ b/tests/screenshot/src/com/android/settings/tests/screenshot/biometrics/fingerprint/Injector.kt
@@ -50,7 +50,7 @@
 import platform.test.screenshot.DeviceEmulationSpec
 import platform.test.screenshot.DisplaySpec
 import platform.test.screenshot.FragmentScreenshotTestRule
-import platform.test.screenshot.GoldenImagePathManager
+import platform.test.screenshot.GoldenPathManager
 import platform.test.screenshot.matchers.PixelPerfectMatcher
 
 class Injector(step: FingerprintNavigationStep.UiStep) {
@@ -154,7 +154,7 @@
     fun BiometricFragmentScreenShotRule() =
       FragmentScreenshotTestRule(
         DeviceEmulationSpec.forDisplays(Phone).first(),
-        GoldenImagePathManager(
+        GoldenPathManager(
           InstrumentationRegistry.getInstrumentation().context,
           InstrumentationRegistry.getInstrumentation().targetContext.filesDir.absolutePath +
             screenshotPath,
diff --git a/tests/spa_unit/AndroidManifest.xml b/tests/spa_unit/AndroidManifest.xml
index 51ac1b7..d234b5d 100644
--- a/tests/spa_unit/AndroidManifest.xml
+++ b/tests/spa_unit/AndroidManifest.xml
@@ -19,11 +19,14 @@
           xmlns:tools="http://schemas.android.com/tools"
           package="com.android.settings.tests.spa_unit">
 
+    <uses-permission android:name="android.permission.ACCESS_KEYGUARD_SECURE_STORAGE" />
+    <uses-permission android:name="android.permission.LOG_COMPAT_CHANGE" />
     <uses-permission android:name="android.permission.MANAGE_APPOPS" />
+    <uses-permission android:name="android.permission.MANAGE_NETWORK_POLICY" />
+    <uses-permission android:name="android.permission.READ_COMPAT_CHANGE_CONFIG" />
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
     <uses-permission android:name="android.permission.UPDATE_APP_OPS_STATS" />
     <uses-permission android:name="android.permission.WRITE_DEVICE_CONFIG" />
-    <uses-permission android:name="android.permission.READ_COMPAT_CHANGE_CONFIG" />
-    <uses-permission android:name="android.permission.LOG_COMPAT_CHANGE" />
 
     <application android:debuggable="true">
         <provider android:name="com.android.settings.slices.SettingsSliceProvider"
diff --git a/tests/spa_unit/src/com/android/settings/network/telephony/DataUsagePreferenceControllerTest.kt b/tests/spa_unit/src/com/android/settings/network/telephony/DataUsagePreferenceControllerTest.kt
index 5f80855..7124b6a 100644
--- a/tests/spa_unit/src/com/android/settings/network/telephony/DataUsagePreferenceControllerTest.kt
+++ b/tests/spa_unit/src/com/android/settings/network/telephony/DataUsagePreferenceControllerTest.kt
@@ -120,7 +120,7 @@
             on { loadFirstCycle() } doReturn usageData
         }
         controller.onViewCreated(TestLifecycleOwner())
-        waitUntil { preference.summary != null }
+        waitUntil { !preference.summary.isNullOrBlank() }
 
         controller.handlePreferenceTreeClick(preference)
 
diff --git a/tests/spa_unit/src/com/android/settings/network/telephony/MobileNetworkSwitchControllerTest.kt b/tests/spa_unit/src/com/android/settings/network/telephony/MobileNetworkSwitchControllerTest.kt
new file mode 100644
index 0000000..ca37082
--- /dev/null
+++ b/tests/spa_unit/src/com/android/settings/network/telephony/MobileNetworkSwitchControllerTest.kt
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.network.telephony
+
+import android.content.Context
+import android.telephony.SubscriptionInfo
+import android.telephony.SubscriptionManager
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.isOff
+import androidx.compose.ui.test.isOn
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.settings.R
+import com.android.settingslib.spa.testutils.waitUntilExists
+import kotlinx.coroutines.flow.flowOf
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doNothing
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.stub
+import org.mockito.kotlin.whenever
+
+@RunWith(AndroidJUnit4::class)
+class MobileNetworkSwitchControllerTest {
+    @get:Rule
+    val composeTestRule = createComposeRule()
+
+    private val mockSubscriptionManager = mock<SubscriptionManager> {
+        on { isSubscriptionEnabled(SUB_ID) } doReturn true
+    }
+
+    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {
+        on { subscriptionManager } doReturn mockSubscriptionManager
+        doNothing().whenever(mock).startActivity(any())
+    }
+
+    private val mockSubscriptionRepository = mock<SubscriptionRepository> {
+        on { getSelectableSubscriptionInfoList() } doReturn listOf(SubInfo)
+        on { isSubscriptionEnabledFlow(SUB_ID) } doReturn flowOf(false)
+    }
+
+    private val controller = MobileNetworkSwitchController(
+        context = context,
+        preferenceKey = TEST_KEY,
+        subscriptionRepository = mockSubscriptionRepository,
+    ).apply { init(SUB_ID) }
+
+    @Test
+    fun isVisible_pSimAndCanDisablePhysicalSubscription_returnTrue() {
+        val pSimSubInfo = SubscriptionInfo.Builder().apply {
+            setId(SUB_ID)
+            setEmbedded(false)
+        }.build()
+        mockSubscriptionManager.stub {
+            on { canDisablePhysicalSubscription() } doReturn true
+        }
+        mockSubscriptionRepository.stub {
+            on { getSelectableSubscriptionInfoList() } doReturn listOf(pSimSubInfo)
+        }
+
+        setContent()
+
+        composeTestRule.onNodeWithText(context.getString(R.string.mobile_network_use_sim_on))
+            .assertIsDisplayed()
+    }
+
+    @Test
+    fun isVisible_pSimAndCannotDisablePhysicalSubscription_returnFalse() {
+        val pSimSubInfo = SubscriptionInfo.Builder().apply {
+            setId(SUB_ID)
+            setEmbedded(false)
+        }.build()
+        mockSubscriptionManager.stub {
+            on { canDisablePhysicalSubscription() } doReturn false
+        }
+        mockSubscriptionRepository.stub {
+            on { getSelectableSubscriptionInfoList() } doReturn listOf(pSimSubInfo)
+        }
+
+        setContent()
+
+        composeTestRule.onNodeWithText(context.getString(R.string.mobile_network_use_sim_on))
+            .assertDoesNotExist()
+    }
+
+    @Test
+    fun isVisible_eSim_returnTrue() {
+        val eSimSubInfo = SubscriptionInfo.Builder().apply {
+            setId(SUB_ID)
+            setEmbedded(true)
+        }.build()
+        mockSubscriptionRepository.stub {
+            on { getSelectableSubscriptionInfoList() } doReturn listOf(eSimSubInfo)
+        }
+
+        setContent()
+
+        composeTestRule.onNodeWithText(context.getString(R.string.mobile_network_use_sim_on))
+            .assertIsDisplayed()
+    }
+
+    @Test
+    fun isChecked_subscriptionEnabled_switchIsOn() {
+        mockSubscriptionRepository.stub {
+            on { isSubscriptionEnabledFlow(SUB_ID) } doReturn flowOf(true)
+        }
+
+        setContent()
+
+        composeTestRule.waitUntilExists(
+            hasText(context.getString(R.string.mobile_network_use_sim_on)) and isOn()
+        )
+    }
+
+    @Test
+    fun isChecked_subscriptionNotEnabled_switchIsOff() {
+        mockSubscriptionRepository.stub {
+            on { isSubscriptionEnabledFlow(SUB_ID) } doReturn flowOf(false)
+        }
+
+        setContent()
+
+        composeTestRule.waitUntilExists(
+            hasText(context.getString(R.string.mobile_network_use_sim_on)) and isOff()
+        )
+    }
+
+    private fun setContent() {
+        composeTestRule.setContent {
+            CompositionLocalProvider(LocalContext provides context) {
+                controller.Content()
+            }
+        }
+    }
+
+    private companion object {
+        const val TEST_KEY = "test_key"
+        const val SUB_ID = 123
+
+        val SubInfo: SubscriptionInfo = SubscriptionInfo.Builder().apply {
+            setId(SUB_ID)
+            setEmbedded(true)
+        }.build()
+    }
+}
diff --git a/tests/spa_unit/src/com/android/settings/network/telephony/NetworkSelectRepositoryTest.kt b/tests/spa_unit/src/com/android/settings/network/telephony/NetworkSelectRepositoryTest.kt
new file mode 100644
index 0000000..4137de4
--- /dev/null
+++ b/tests/spa_unit/src/com/android/settings/network/telephony/NetworkSelectRepositoryTest.kt
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.network.telephony
+
+import android.content.Context
+import android.telephony.AccessNetworkConstants
+import android.telephony.NetworkRegistrationInfo
+import android.telephony.ServiceState
+import android.telephony.TelephonyManager
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.settings.network.telephony.scan.NetworkScanRepositoryTest
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.stub
+
+@RunWith(AndroidJUnit4::class)
+class NetworkSelectRepositoryTest {
+
+    private val mockServiceState = mock<ServiceState> {
+        on {
+            getNetworkRegistrationInfoListForTransportType(
+                AccessNetworkConstants.TRANSPORT_TYPE_WWAN
+            )
+        } doReturn NetworkRegistrationInfos
+    }
+
+    private val mockTelephonyManager = mock<TelephonyManager> {
+        on { createForSubscriptionId(SUB_ID) } doReturn mock
+        on { dataState } doReturn TelephonyManager.DATA_CONNECTED
+        on { serviceState } doReturn mockServiceState
+    }
+
+    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {
+        on { getSystemService(TelephonyManager::class.java) } doReturn mockTelephonyManager
+    }
+
+    private val repository = NetworkSelectRepository(context, SUB_ID)
+
+    @Test
+    fun getNetworkRegistrationInfo_notConnected_returnNull() {
+        mockTelephonyManager.stub {
+            on { dataState } doReturn TelephonyManager.DATA_DISCONNECTED
+        }
+
+        val info = repository.getNetworkRegistrationInfo()
+
+        assertThat(info).isNull()
+    }
+
+    @Test
+    fun getNetworkRegistrationInfo_nullServiceState_returnNull() {
+        mockTelephonyManager.stub {
+            on { serviceState } doReturn null
+        }
+
+        val info = repository.getNetworkRegistrationInfo()
+
+        assertThat(info).isNull()
+    }
+
+    @Test
+    fun getNetworkRegistrationInfo_emptyNetworkList_returnNull() {
+        mockServiceState.stub {
+            on {
+                getNetworkRegistrationInfoListForTransportType(
+                    AccessNetworkConstants.TRANSPORT_TYPE_WWAN
+                )
+            } doReturn emptyList()
+        }
+
+        val info = repository.getNetworkRegistrationInfo()
+
+        assertThat(info).isNull()
+    }
+
+    @Test
+    fun getNetworkRegistrationInfo_hasNetworkList_returnInfo() {
+        mockServiceState.stub {
+            on {
+                getNetworkRegistrationInfoListForTransportType(
+                    AccessNetworkConstants.TRANSPORT_TYPE_WWAN
+                )
+            } doReturn NetworkRegistrationInfos
+        }
+        mockTelephonyManager.stub {
+            on { forbiddenPlmns } doReturn arrayOf(FORBIDDEN_PLMN)
+        }
+
+        val info = repository.getNetworkRegistrationInfo()
+
+        assertThat(info).isEqualTo(
+            NetworkSelectRepository.NetworkRegistrationAndForbiddenInfo(
+                networkList = NetworkRegistrationInfos,
+                forbiddenPlmns = listOf(FORBIDDEN_PLMN),
+            )
+        )
+    }
+
+    private companion object {
+        const val SUB_ID = 1
+        val NetworkRegistrationInfos = listOf(NetworkRegistrationInfo.Builder().build())
+        const val FORBIDDEN_PLMN = "Forbidden PLMN"
+    }
+}
diff --git a/tests/spa_unit/src/com/android/settings/network/telephony/SubscriptionRepositoryTest.kt b/tests/spa_unit/src/com/android/settings/network/telephony/SubscriptionRepositoryTest.kt
index 80b3175..b394eb2 100644
--- a/tests/spa_unit/src/com/android/settings/network/telephony/SubscriptionRepositoryTest.kt
+++ b/tests/spa_unit/src/com/android/settings/network/telephony/SubscriptionRepositoryTest.kt
@@ -141,10 +141,27 @@
         assertThat(subInfos.map { it.subscriptionId }).containsExactly(SUB_ID_1)
     }
 
+    @Test
+    fun phoneNumberFlow() = runBlocking {
+        mockSubscriptionManager.stub {
+            on { getPhoneNumber(SUB_ID_1) } doReturn NUMBER_1
+        }
+        val subInfo = SubscriptionInfo.Builder().apply {
+            setId(SUB_ID_1)
+            setMcc(MCC)
+        }.build()
+
+        val phoneNumber = context.phoneNumberFlow(subInfo).firstWithTimeoutOrNull()
+
+        assertThat(phoneNumber).isEqualTo(NUMBER_1)
+    }
+
     private companion object {
         const val SUB_ID_1 = 1
         const val SUB_ID_2 = 2
         val GROUP_UUID = UUID.randomUUID().toString()
         const val SIM_SLOT_INDEX = 1
+        const val NUMBER_1 = "000000001"
+        const val MCC = "310"
     }
 }
diff --git a/tests/spa_unit/src/com/android/settings/spa/network/SimOnboardingLabelSimTest.kt b/tests/spa_unit/src/com/android/settings/spa/network/SimOnboardingLabelSimTest.kt
index 44a5037..43270c2 100644
--- a/tests/spa_unit/src/com/android/settings/spa/network/SimOnboardingLabelSimTest.kt
+++ b/tests/spa_unit/src/com/android/settings/spa/network/SimOnboardingLabelSimTest.kt
@@ -18,19 +18,29 @@
 
 import android.content.Context
 import android.telephony.SubscriptionInfo
+import android.telephony.SubscriptionManager
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalLifecycleOwner
 import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.hasText
 import androidx.compose.ui.test.junit4.createComposeRule
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
+import androidx.lifecycle.testing.TestLifecycleOwner
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.android.settings.R
 import com.android.settings.network.SimOnboardingService
+import com.android.settingslib.spa.testutils.waitUntilExists
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
 import org.mockito.kotlin.stub
 import org.mockito.kotlin.verify
 
@@ -39,7 +49,20 @@
     @get:Rule
     val composeTestRule = createComposeRule()
 
-    private val context: Context = ApplicationProvider.getApplicationContext()
+    private val mockSubscriptionManager = mock<SubscriptionManager> {
+        on { addOnSubscriptionsChangedListener(any(), any()) } doAnswer {
+            val listener = it.arguments[1] as SubscriptionManager.OnSubscriptionsChangedListener
+            listener.onSubscriptionsChanged()
+        }
+        on { getPhoneNumber(SUB_ID_1) } doReturn NUMBER_1
+        on { getPhoneNumber(SUB_ID_2) } doReturn NUMBER_2
+        on { getPhoneNumber(SUB_ID_3) } doReturn NUMBER_3
+    }
+
+    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {
+        on { getSystemService(SubscriptionManager::class.java) } doReturn mockSubscriptionManager
+    }
+
     private var mockSimOnboardingService = mock<SimOnboardingService> {
         on { targetSubId }.doReturn(-1)
         on { targetSubInfo }.doReturn(null)
@@ -85,7 +108,7 @@
         composeTestRule.onNodeWithText(context.getString(R.string.sim_onboarding_next))
             .performClick()
 
-        verify(nextAction)
+        verify(nextAction)()
     }
 
     @Test
@@ -97,7 +120,7 @@
         composeTestRule.onNodeWithText(context.getString(R.string.cancel))
             .performClick()
 
-        verify(cancelAction)
+        verify(cancelAction)()
     }
 
     @Test
@@ -120,15 +143,20 @@
         }
 
         composeTestRule.setContent {
-            SimOnboardingLabelSimImpl(nextAction, cancelAction, mockSimOnboardingService)
+            CompositionLocalProvider(
+                LocalContext provides context,
+                LocalLifecycleOwner provides TestLifecycleOwner(),
+            ) {
+                SimOnboardingLabelSimImpl(nextAction, cancelAction, mockSimOnboardingService)
+            }
         }
 
         composeTestRule.onNodeWithText(DISPLAY_NAME_1).assertIsDisplayed()
-        composeTestRule.onNodeWithText(NUMBER_1).assertIsDisplayed()
+        composeTestRule.waitUntilExists(hasText(NUMBER_1))
         composeTestRule.onNodeWithText(DISPLAY_NAME_2).assertIsDisplayed()
-        composeTestRule.onNodeWithText(NUMBER_2).assertIsDisplayed()
+        composeTestRule.waitUntilExists(hasText(NUMBER_2))
         composeTestRule.onNodeWithText(DISPLAY_NAME_3).assertIsDisplayed()
-        composeTestRule.onNodeWithText(NUMBER_3).assertIsDisplayed()
+        composeTestRule.waitUntilExists(hasText(NUMBER_3))
     }
 
     @Test
@@ -173,24 +201,25 @@
         const val NUMBER_1 = "000000001"
         const val NUMBER_2 = "000000002"
         const val NUMBER_3 = "000000003"
+        const val MCC = "310"
         const val PRIMARY_SIM_ASK_EVERY_TIME = -1
 
         val SUB_INFO_1: SubscriptionInfo = SubscriptionInfo.Builder().apply {
             setId(SUB_ID_1)
             setDisplayName(DISPLAY_NAME_1)
-            setNumber(NUMBER_1)
+            setMcc(MCC)
         }.build()
 
         val SUB_INFO_2: SubscriptionInfo = SubscriptionInfo.Builder().apply {
             setId(SUB_ID_2)
             setDisplayName(DISPLAY_NAME_2)
-            setNumber(NUMBER_2)
+            setMcc(MCC)
         }.build()
 
         val SUB_INFO_3: SubscriptionInfo = SubscriptionInfo.Builder().apply {
             setId(SUB_ID_3)
             setDisplayName(DISPLAY_NAME_3)
-            setNumber(NUMBER_3)
+            setMcc(MCC)
         }.build()
     }
 }
diff --git a/tests/spa_unit/src/com/android/settings/wifi/details2/CertificateDetailsPreferenceControllerTest.kt b/tests/spa_unit/src/com/android/settings/wifi/details2/CertificateDetailsPreferenceControllerTest.kt
new file mode 100644
index 0000000..1499374
--- /dev/null
+++ b/tests/spa_unit/src/com/android/settings/wifi/details2/CertificateDetailsPreferenceControllerTest.kt
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+package com.android.settings.wifi.details2
+
+import android.content.Context
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import java.security.cert.X509Certificate
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doNothing
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.whenever
+
+@RunWith(AndroidJUnit4::class)
+class CertificateDetailsPreferenceControllerTest {
+    @get:Rule
+    val composeTestRule = createComposeRule()
+
+    private val mockCertX509 = mock<X509Certificate> {}
+
+    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {
+        doNothing().whenever(mock).startActivity(any())
+    }
+
+    private val controller = CertificateDetailsPreferenceController(context, TEST_KEY)
+
+    @Before
+    fun setUp() {
+        controller.certificateAliases = MOCK_CA
+        controller.certX509 = mockCertX509
+    }
+
+    @Test
+    fun title_isDisplayed() {
+        composeTestRule.setContent {
+            CompositionLocalProvider(LocalContext provides context) {
+                controller.Content()
+            }
+        }
+
+        composeTestRule.onNodeWithText(context.getString(com.android.internal.R.string.ssl_certificate))
+            .assertIsDisplayed()
+    }
+
+    private companion object {
+        const val TEST_KEY = "test_key"
+        const val MOCK_CA = "mock_ca"
+    }
+}
\ No newline at end of file
diff --git a/tests/unit/src/com/android/settings/accessibility/PreferredShortcutsTest.java b/tests/unit/src/com/android/settings/accessibility/PreferredShortcutsTest.java
index e3c07ef..4ef63d0 100644
--- a/tests/unit/src/com/android/settings/accessibility/PreferredShortcutsTest.java
+++ b/tests/unit/src/com/android/settings/accessibility/PreferredShortcutsTest.java
@@ -25,16 +25,22 @@
 import android.content.ComponentName;
 import android.content.ContentResolver;
 import android.content.Context;
+import android.platform.test.annotations.DisableFlags;
+import android.platform.test.annotations.EnableFlags;
+import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.Settings;
+import android.view.accessibility.Flags;
 
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 
 import com.android.internal.accessibility.common.ShortcutConstants;
+import com.android.internal.accessibility.common.ShortcutConstants.UserShortcutType;
 import com.android.internal.accessibility.util.ShortcutUtils;
 
 import org.junit.AfterClass;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -54,7 +60,8 @@
             CLASS_NAME_2);
     private static final ContentResolver sContentResolver =
             ApplicationProvider.getApplicationContext().getContentResolver();
-
+    @Rule
+    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
     private final Context mContext = ApplicationProvider.getApplicationContext();
 
     @Before
@@ -166,11 +173,48 @@
                 .isEqualTo(target2ShortcutTypes);
     }
 
+    @Test
+    @EnableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void updatePreferredShortcutFromSettings_colorInversionWithQsAndSoftwareShortcut_preferredShortcutsMatches() {
+        String target = COLOR_INVERSION_COMPONENT_NAME.flattenToString();
+        Settings.Secure.putString(sContentResolver,
+                Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS, target);
+        Settings.Secure.putString(sContentResolver,
+                Settings.Secure.ACCESSIBILITY_QS_TARGETS, target);
+
+        PreferredShortcuts.updatePreferredShortcutsFromSettings(mContext, Set.of(target));
+
+        int savedPreferredShortcut = PreferredShortcuts.retrieveUserShortcutType(
+                mContext, target);
+        assertThat(savedPreferredShortcut).isEqualTo(
+                UserShortcutType.SOFTWARE | UserShortcutType.QUICK_SETTINGS);
+
+    }
+
+    @Test
+    @DisableFlags(Flags.FLAG_A11Y_QS_SHORTCUT)
+    public void updatePreferredShortcutFromSettings_colorInversionWithQsAndHardwareShortcut_qsShortcutNotSaved() {
+        String target = COLOR_INVERSION_COMPONENT_NAME.flattenToString();
+        Settings.Secure.putString(sContentResolver,
+                Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE, target);
+        Settings.Secure.putString(sContentResolver,
+                Settings.Secure.ACCESSIBILITY_QS_TARGETS, target);
+        assertThat(!android.view.accessibility.Flags.a11yQsShortcut()).isTrue();
+
+        PreferredShortcuts.updatePreferredShortcutsFromSettings(mContext, Set.of(target));
+
+        int savedPreferredShortcut = PreferredShortcuts.retrieveUserShortcutType(
+                mContext, target);
+        assertThat(savedPreferredShortcut).isEqualTo(UserShortcutType.HARDWARE);
+    }
+
     private static void clearShortcuts() {
         Settings.Secure.putString(sContentResolver,
                 Settings.Secure.ACCESSIBILITY_BUTTON_TARGETS, "");
         Settings.Secure.putString(sContentResolver,
                 Settings.Secure.ACCESSIBILITY_SHORTCUT_TARGET_SERVICE, "");
+        Settings.Secure.putString(sContentResolver,
+                Settings.Secure.ACCESSIBILITY_QS_TARGETS, "");
         Settings.Secure.putInt(
                 sContentResolver,
                 Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
@@ -179,5 +223,7 @@
                 sContentResolver,
                 Settings.Secure.ACCESSIBILITY_MAGNIFICATION_TWO_FINGER_TRIPLE_TAP_ENABLED,
                 AccessibilityUtil.State.OFF);
+
+        PreferredShortcuts.clearPreferredShortcuts(ApplicationProvider.getApplicationContext());
     }
 }
diff --git a/tests/unit/src/com/android/settings/conecteddevice/threadnetwork/ThreadNetworkPreferenceControllerTest.kt b/tests/unit/src/com/android/settings/conecteddevice/threadnetwork/ThreadNetworkPreferenceControllerTest.kt
index 644095d..976096c 100644
--- a/tests/unit/src/com/android/settings/conecteddevice/threadnetwork/ThreadNetworkPreferenceControllerTest.kt
+++ b/tests/unit/src/com/android/settings/conecteddevice/threadnetwork/ThreadNetworkPreferenceControllerTest.kt
@@ -33,13 +33,13 @@
 import androidx.preference.SwitchPreference
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.android.net.thread.platform.flags.Flags
 import com.android.settings.R
 import com.android.settings.core.BasePreferenceController.AVAILABLE
 import com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE
 import com.android.settings.core.BasePreferenceController.DISABLED_DEPENDENT_SETTING
 import com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE
 import com.android.settings.connecteddevice.threadnetwork.ThreadNetworkPreferenceController.BaseThreadNetworkController
+import com.android.settings.flags.Flags
 import com.google.common.truth.Truth.assertThat
 import org.junit.Before
 import org.junit.Rule
@@ -68,7 +68,7 @@
 
     @Before
     fun setUp() {
-        mSetFlagsRule.enableFlags(Flags.FLAG_THREAD_ENABLED_PLATFORM)
+        mSetFlagsRule.enableFlags(Flags.FLAG_THREAD_SETTINGS_ENABLED)
         context = spy(ApplicationProvider.getApplicationContext<Context>())
         executor = ContextCompat.getMainExecutor(context)
         fakeThreadNetworkController = FakeThreadNetworkController(executor)
@@ -96,7 +96,7 @@
 
     @Test
     fun availabilityStatus_flagDisabled_returnsConditionallyUnavailable() {
-        mSetFlagsRule.disableFlags(Flags.FLAG_THREAD_ENABLED_PLATFORM)
+        mSetFlagsRule.disableFlags(Flags.FLAG_THREAD_SETTINGS_ENABLED)
         assertThat(controller.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE)
     }
 
diff --git a/tests/unit/src/com/android/settings/development/bluetooth/BluetoothStackLogPreferenceControllerTest.java b/tests/unit/src/com/android/settings/development/bluetooth/BluetoothStackLogPreferenceControllerTest.java
new file mode 100644
index 0000000..0811f04
--- /dev/null
+++ b/tests/unit/src/com/android/settings/development/bluetooth/BluetoothStackLogPreferenceControllerTest.java
@@ -0,0 +1,217 @@
+/*
+ * 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.
+ */
+
+package com.android.settings.development.bluetooth;
+
+import static com.android.settings.development.bluetooth.BluetoothStackLogPreferenceController.BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY;
+import static com.android.settings.development.bluetooth.BluetoothStackLogPreferenceController.BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST;
+import static com.android.settings.development.bluetooth.BluetoothStackLogPreferenceController.BTSTACK_LOG_MODE_VERBOSE_INDEX;
+import static com.android.settings.development.bluetooth.BluetoothStackLogPreferenceController.BTSTACK_LOG_MODE_DEBUG_INDEX;
+import static com.android.settings.development.bluetooth.BluetoothStackLogPreferenceController.BTSTACK_LOG_MODE_INFO_INDEX;
+import static com.android.settings.development.bluetooth.BluetoothStackLogPreferenceController.BTSTACK_LOG_MODE_WARN_INDEX;
+import static com.android.settings.development.bluetooth.BluetoothStackLogPreferenceController.BTSTACK_LOG_MODE_ERROR_INDEX;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.os.Looper;
+import android.os.SystemProperties;
+
+import androidx.preference.ListPreference;
+import androidx.preference.PreferenceManager;
+import androidx.preference.PreferenceScreen;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+@RunWith(AndroidJUnit4.class)
+public class BluetoothStackLogPreferenceControllerTest {
+    private static final String TAG = "BluetoothStackLogPreferenceControllerTest";
+
+    @Mock private Context mContext;
+
+    private ListPreference mPreference;
+    private PreferenceManager mPreferenceManager;
+    private PreferenceScreen mPreferenceScreen;
+
+    private BluetoothStackLogPreferenceController mController;
+
+    private CharSequence[] mListValues;
+    private CharSequence[] mListEntries;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        mContext = ApplicationProvider.getApplicationContext();
+
+        if (Looper.myLooper() == null) {
+            Looper.prepare();
+        }
+
+        mPreferenceManager = new PreferenceManager(mContext);
+        mPreferenceScreen = mPreferenceManager.createPreferenceScreen(mContext);
+        mPreference = new ListPreference(mContext);
+
+        mController = new BluetoothStackLogPreferenceController(mContext);
+
+        mPreference.setKey(mController.getPreferenceKey());
+        mPreference.setEntries(com.android.settings.R.array.bt_stack_log_level_entries);
+        mPreference.setEntryValues(com.android.settings.R.array.bt_stack_log_level_values);
+
+        mPreferenceScreen.addPreference(mPreference);
+        mController.displayPreference(mPreferenceScreen);
+
+        mListValues = mPreference.getEntryValues();
+        mListEntries = mPreference.getEntries();
+    }
+
+    /**
+     * Test that default log level is set to INFO
+     */
+    @Test
+    public void verifyDefaultState_enablesDefaultLogLevelEntriesAndValuesSameSize() {
+        mController.onPreferenceChange(mPreference, mController.getDefaultModeIndex());
+        assertThat(mPreference.getValue().toString()).isEqualTo(mListValues
+                        [BTSTACK_LOG_MODE_INFO_INDEX].toString());
+        assertThat(mPreference.getSummary().toString()).isEqualTo(mListEntries
+                        [BTSTACK_LOG_MODE_INFO_INDEX].toString());
+    }
+
+    /**
+     * Test that log level is changed to VERBOSE when VERBOSE is selected
+     */
+    @Test
+    public void onPreferenceChanged_enableBluetoothStackVerboseLogLevel() {
+        mController.onPreferenceChange(mPreference, mListValues[BTSTACK_LOG_MODE_VERBOSE_INDEX]
+                        .toString());
+
+        final String persistedLogLevel = SystemProperties.get(
+                        BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST);
+        final String logLevel = SystemProperties.get(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY);
+        assertThat(persistedLogLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_VERBOSE_INDEX]
+                        .toString());
+        assertThat(logLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_VERBOSE_INDEX].toString());
+
+        assertThat(mPreference.getValue().toString()).isEqualTo(mListValues
+                        [BTSTACK_LOG_MODE_VERBOSE_INDEX].toString());
+        assertThat(mPreference.getSummary().toString()).isEqualTo(mListEntries
+                        [BTSTACK_LOG_MODE_VERBOSE_INDEX].toString());
+    }
+
+    /**
+     * Test that log level is changed to DEBUG when DEBUG is selected
+     */
+    @Test
+    public void onPreferenceChanged_enableBluetoothStackDebugLogLevel() {
+        mController.onPreferenceChange(mPreference, mListValues[BTSTACK_LOG_MODE_DEBUG_INDEX]
+                        .toString());
+
+        final String persistedLogLevel = SystemProperties.get(
+                BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST);
+        final String logLevel = SystemProperties.get(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY);
+        assertThat(persistedLogLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_DEBUG_INDEX]
+                        .toString());
+        assertThat(logLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_DEBUG_INDEX].toString());
+
+        assertThat(mPreference.getValue().toString()).isEqualTo(mListValues
+                        [BTSTACK_LOG_MODE_DEBUG_INDEX].toString());
+        assertThat(mPreference.getSummary().toString()).isEqualTo(mListEntries
+                        [BTSTACK_LOG_MODE_DEBUG_INDEX].toString());
+    }
+
+    /**
+     * Test that log level is changed to INFO when INFO is selected
+     */
+    @Test
+    public void onPreferenceChanged_enableBluetoothStackInfoLogLevel() {
+        mController.onPreferenceChange(mPreference, mListValues[BTSTACK_LOG_MODE_INFO_INDEX]
+                        .toString());
+
+        final String persistedLogLevel = SystemProperties.get(
+                BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST);
+        final String logLevel = SystemProperties.get(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY);
+        assertThat(persistedLogLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_INFO_INDEX]
+                        .toString());
+        assertThat(logLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_INFO_INDEX].toString());
+
+        assertThat(mPreference.getValue().toString()).isEqualTo(mListValues
+                        [BTSTACK_LOG_MODE_INFO_INDEX].toString());
+        assertThat(mPreference.getSummary().toString()).isEqualTo(mListEntries
+                        [BTSTACK_LOG_MODE_INFO_INDEX].toString());
+    }
+
+    /**
+     * Test that log level is changed to WARN when WARN is selected
+     */
+    @Test
+    public void onPreferenceChanged_enableBluetoothStackWarnLogLevel() {
+        mController.onPreferenceChange(mPreference, mListValues[BTSTACK_LOG_MODE_WARN_INDEX]
+                        .toString());
+
+        final String persistedLogLevel = SystemProperties.get(
+                BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST);
+        final String logLevel = SystemProperties.get(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY);
+        assertThat(persistedLogLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_WARN_INDEX]
+                        .toString());
+        assertThat(logLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_WARN_INDEX].toString());
+
+        assertThat(mPreference.getValue().toString()).isEqualTo(mListValues
+
+                        [BTSTACK_LOG_MODE_WARN_INDEX].toString());
+        assertThat(mPreference.getSummary().toString()).isEqualTo(mListEntries
+                        [BTSTACK_LOG_MODE_WARN_INDEX].toString());
+    }
+
+    /**
+     * Test that log level is changed to ERROR when ERROR is selected
+     */
+    @Test
+    public void onPreferenceChanged_enableBluetoothStackErrorLogLevel() {
+        mController.onPreferenceChange(mPreference, mListValues[BTSTACK_LOG_MODE_ERROR_INDEX]
+                        .toString());
+
+        final String persistedLogLevel = SystemProperties.get(
+                BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY_PERSIST);
+        final String logLevel = SystemProperties.get(BLUETOOTH_BTSTACK_LOG_MODE_PROPERTY);
+        assertThat(persistedLogLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_ERROR_INDEX]
+                        .toString());
+        assertThat(logLevel).isEqualTo(mListValues[BTSTACK_LOG_MODE_ERROR_INDEX].toString());
+
+        assertThat(mPreference.getValue().toString()).isEqualTo(mListValues
+                        [BTSTACK_LOG_MODE_ERROR_INDEX].toString());
+        assertThat(mPreference.getSummary().toString()).isEqualTo(mListEntries
+                        [BTSTACK_LOG_MODE_ERROR_INDEX].toString());
+    }
+
+    /**
+     * Test that preference is disabled when developer options is disabled
+     * Log level is also reset to default
+     */
+    @Test
+    public void onDeveloperOptionsDisabled_shouldDisablePreference() {
+        mController.onDeveloperOptionsDisabled();
+        assertThat(mPreference.isEnabled()).isFalse();
+        assertThat(mPreference.getValue().toString()).isEqualTo(mListValues[mController
+                .getDefaultModeIndex()].toString());
+        assertThat(mPreference.getSummary().toString()).isEqualTo(mListEntries[mController
+                .getDefaultModeIndex()].toString());
+    }
+}
diff --git a/tests/unit/src/com/android/settings/development/quarantine/QuarantinedAppStateBridgeTest.java b/tests/unit/src/com/android/settings/development/quarantine/QuarantinedAppStateBridgeTest.java
deleted file mode 100644
index 707d2b9..0000000
--- a/tests/unit/src/com/android/settings/development/quarantine/QuarantinedAppStateBridgeTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.development.quarantine;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import android.content.Context;
-import android.content.pm.PackageManager;
-import android.os.UserHandle;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-
-import com.android.settingslib.applications.ApplicationsState.AppEntry;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-@RunWith(AndroidJUnit4.class)
-public class QuarantinedAppStateBridgeTest {
-    private static final String TEST_PACKAGE = "com.example.test.pkg";
-    private static final int TEST_APP_ID = 1234;
-    private static final int TEST_USER_ID_1 = 0;
-    private static final int TEST_USER_ID_2 = 10;
-
-    @Mock
-    private Context mContext;
-
-    @Before
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void updateExtraInfo_packageQuarantined() throws Exception {
-        setPackageQuarantined(TEST_PACKAGE, TEST_USER_ID_1, false);
-        setPackageQuarantined(TEST_PACKAGE, TEST_USER_ID_2, true);
-
-        final QuarantinedAppStateBridge bridge =
-                new QuarantinedAppStateBridge(mContext, null, null);
-        final AppEntry entry = mock(AppEntry.class);
-
-        bridge.updateExtraInfo(entry, TEST_PACKAGE, UserHandle.getUid(TEST_USER_ID_2, TEST_APP_ID));
-        assertThat(entry.extraInfo).isEqualTo(true);
-    }
-
-    @Test
-    public void updateExtraInfo_packageNotQuarantined() throws Exception {
-        setPackageQuarantined(TEST_PACKAGE, TEST_USER_ID_1, false);
-        setPackageQuarantined(TEST_PACKAGE, TEST_USER_ID_2, false);
-
-        final QuarantinedAppStateBridge bridge =
-                new QuarantinedAppStateBridge(mContext, null, null);
-        final AppEntry entry = mock(AppEntry.class);
-
-        bridge.updateExtraInfo(entry, TEST_PACKAGE, UserHandle.getUid(TEST_USER_ID_2, TEST_APP_ID));
-        assertThat(entry.extraInfo).isEqualTo(false);
-    }
-
-    private void setPackageQuarantined(String packageName, int userId, boolean quarantined)
-            throws Exception {
-        final Context userContext = mock(Context.class);
-        when(mContext.createContextAsUser(eq(UserHandle.of(userId)), anyInt()))
-                .thenReturn(userContext);
-        final PackageManager packageManager = mock(PackageManager.class);
-        when(userContext.getPackageManager()).thenReturn(packageManager);
-        when(packageManager.isPackageQuarantined(packageName)).thenReturn(quarantined);
-    }
-}
diff --git a/tests/unit/src/com/android/settings/development/quarantine/QuarantinedAppsPreferenceControllerTest.java b/tests/unit/src/com/android/settings/development/quarantine/QuarantinedAppsPreferenceControllerTest.java
deleted file mode 100644
index 33e4392..0000000
--- a/tests/unit/src/com/android/settings/development/quarantine/QuarantinedAppsPreferenceControllerTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.development.quarantine;
-
-import static com.android.settings.core.BasePreferenceController.AVAILABLE;
-import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE;
-
-import static org.junit.Assert.assertEquals;
-
-import android.content.Context;
-import android.content.pm.Flags;
-import android.platform.test.annotations.RequiresFlagsDisabled;
-import android.platform.test.annotations.RequiresFlagsEnabled;
-import android.platform.test.flag.junit.CheckFlagsRule;
-import android.platform.test.flag.junit.DeviceFlagsValueProvider;
-
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-@RunWith(AndroidJUnit4.class)
-public class QuarantinedAppsPreferenceControllerTest {
-
-    private static final String PREF_KEY = "quarantined_apps";
-
-    @Rule
-    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
-
-    @Mock
-    private Context mContext;
-    private QuarantinedAppsPreferenceController mController;
-
-    @Before
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-        mController = new QuarantinedAppsPreferenceController(mContext, PREF_KEY);
-    }
-
-    @Test
-    @RequiresFlagsEnabled(Flags.FLAG_QUARANTINED_ENABLED)
-    public void testAvailabilityStatus_flagEnabled() {
-        assertEquals(mController.getAvailabilityStatus(), AVAILABLE);
-    }
-
-    @Test
-    @RequiresFlagsDisabled(Flags.FLAG_QUARANTINED_ENABLED)
-    public void testAvailabilityStatus_flagDisabled() {
-        assertEquals(mController.getAvailabilityStatus(), CONDITIONALLY_UNAVAILABLE);
-    }
-}
diff --git a/tests/unit/src/com/android/settings/network/SubscriptionUtilTest.java b/tests/unit/src/com/android/settings/network/SubscriptionUtilTest.java
index 3b9ac9d..6c946e5 100644
--- a/tests/unit/src/com/android/settings/network/SubscriptionUtilTest.java
+++ b/tests/unit/src/com/android/settings/network/SubscriptionUtilTest.java
@@ -25,6 +25,7 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
@@ -65,6 +66,9 @@
     private static final CharSequence CARRIER_1 = "carrier1";
     private static final CharSequence CARRIER_1_SPACE = " carrier1       ";
     private static final CharSequence CARRIER_2 = "carrier2";
+    private static final int RAC_CARRIER_ID = 1;
+    private static final int NO_RAC_CARRIER_ID = 2;
+    private static final int[] CARRIERS_THAT_USE_RAC = {RAC_CARRIER_ID};
 
     private Context mContext;
     private NetworkCapabilities mNetworkCapabilities;
@@ -81,6 +85,7 @@
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = spy(ApplicationProvider.getApplicationContext());
+        when(mContext.getResources()).thenReturn(mResources);
         when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubMgr);
         when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelMgr);
         when(mContext.getSystemService(ConnectivityManager.class)).thenReturn(mConnectivityManager);
@@ -109,6 +114,40 @@
         assertThat(subs).hasSize(1);
     }
 
+    @Test
+    public void hasSubscriptionWithRacCarrier_containsRac_returnTrue() {
+        when(mResources.getIntArray(anyInt())).thenReturn(CARRIERS_THAT_USE_RAC);
+        final SubscriptionInfo info = mock(SubscriptionInfo.class);
+        when(info.getCarrierId()).thenReturn(RAC_CARRIER_ID);
+        when(mSubMgr.getAvailableSubscriptionInfoList()).thenReturn(Arrays.asList(info));
+
+        assertTrue(SubscriptionUtil.hasSubscriptionWithRacCarrier(mContext));
+    }
+
+    @Test
+    public void hasSubscriptionWithRacCarrier_doesNotContainsRac_returnFalse() {
+        when(mResources.getIntArray(anyInt())).thenReturn(CARRIERS_THAT_USE_RAC);
+        final SubscriptionInfo info = mock(SubscriptionInfo.class);
+        when(info.getCarrierId()).thenReturn(NO_RAC_CARRIER_ID);
+        when(mSubMgr.getAvailableSubscriptionInfoList()).thenReturn(Arrays.asList(info));
+
+        assertFalse(SubscriptionUtil.hasSubscriptionWithRacCarrier(mContext));
+    }
+
+    @Test
+    public void isCarrierRac_returnTrue() {
+        when(mResources.getIntArray(anyInt())).thenReturn(CARRIERS_THAT_USE_RAC);
+
+        assertTrue(SubscriptionUtil.isCarrierRac(mContext, RAC_CARRIER_ID));
+    }
+
+    @Test
+    public void isCarrierRac_returnFalse() {
+        when(mResources.getIntArray(anyInt())).thenReturn(CARRIERS_THAT_USE_RAC);
+
+        assertFalse(SubscriptionUtil.isCarrierRac(mContext, NO_RAC_CARRIER_ID));
+    }
+
     @Ignore
     @Test
     public void getAvailableSubscriptions_twoSubscriptions_twoResults() {
@@ -526,7 +565,6 @@
 
     @Test
     public void isSimHardwareVisible_configAsInvisible_returnFalse() {
-        when(mContext.getResources()).thenReturn(mResources);
         when(mResources.getBoolean(R.bool.config_show_sim_info))
                 .thenReturn(false);
 
@@ -535,7 +573,6 @@
 
     @Test
     public void isSimHardwareVisible_configAsVisible_returnTrue() {
-        when(mContext.getResources()).thenReturn(mResources);
         when(mResources.getBoolean(R.bool.config_show_sim_info))
                 .thenReturn(true);
 
@@ -599,17 +636,17 @@
     }
 
     @Test
-    public void isConnectedToWifiOrDifferentSubId_hasWiFi_returnTrue() {
+    public void isConnectedToWifi_hasWiFi_returnTrue() {
         addNetworkTransportType(NetworkCapabilities.TRANSPORT_WIFI);
 
-        assertTrue(SubscriptionUtil.isConnectedToWifiOrDifferentSubId(mContext, SUBID_1));
+        assertTrue(SubscriptionUtil.isConnectedToWifi(mContext));
     }
 
     @Test
-    public void isConnectedToWifiOrDifferentSubId_noData_and_noWiFi_returnFalse() {
+    public void isConnectedToWifi_noWiFi_returnFalse() {
         addNetworkTransportType(NetworkCapabilities.TRANSPORT_BLUETOOTH);
 
-        assertFalse(SubscriptionUtil.isConnectedToWifiOrDifferentSubId(mContext, SUBID_1));
+        assertFalse(SubscriptionUtil.isConnectedToWifi(mContext));
     }
 
     private void addNetworkTransportType(int networkType) {
diff --git a/tests/unit/src/com/android/settings/network/telephony/MobileNetworkSwitchControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/MobileNetworkSwitchControllerTest.java
deleted file mode 100644
index ae10ca8..0000000
--- a/tests/unit/src/com/android/settings/network/telephony/MobileNetworkSwitchControllerTest.java
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.network.telephony;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import android.content.Context;
-import android.content.Intent;
-import android.os.Bundle;
-import android.os.Looper;
-import android.platform.test.flag.junit.SetFlagsRule;
-import android.telephony.SubscriptionInfo;
-import android.telephony.SubscriptionManager;
-import android.telephony.TelephonyCallback;
-import android.telephony.TelephonyManager;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.widget.LinearLayout;
-
-import androidx.preference.PreferenceManager;
-import androidx.preference.PreferenceScreen;
-import androidx.preference.PreferenceViewHolder;
-import androidx.test.annotation.UiThreadTest;
-import androidx.test.core.app.ApplicationProvider;
-
-import com.android.settings.flags.Flags;
-import com.android.settings.network.SubscriptionUtil;
-import com.android.settings.widget.SettingsMainSwitchPreference;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnit;
-import org.mockito.junit.MockitoRule;
-
-import java.util.Arrays;
-import java.util.concurrent.Executor;
-
-public class MobileNetworkSwitchControllerTest {
-    @Rule
-    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
-    @Rule
-    public final MockitoRule mMockitoRule = MockitoJUnit.rule();
-
-    @Mock
-    private SubscriptionManager mSubscriptionManager;
-    @Mock
-    private SubscriptionInfo mSubscription;
-    @Mock
-    private TelephonyManager mTelephonyManager;
-
-    private PreferenceScreen mScreen;
-    private PreferenceManager mPreferenceManager;
-    private SettingsMainSwitchPreference mSwitchBar;
-    private Context mContext;
-    private MobileNetworkSwitchController mController;
-    private int mSubId = 123;
-
-    @Before
-    public void setUp() {
-        mSetFlagsRule.disableFlags(Flags.FLAG_IS_DUAL_SIM_ONBOARDING_ENABLED);
-
-        if (Looper.myLooper() == null) {
-            Looper.prepare();
-        }
-        mContext = spy(ApplicationProvider.getApplicationContext());
-        when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager);
-        when(mSubscriptionManager.setSubscriptionEnabled(eq(mSubId), anyBoolean()))
-                .thenReturn(true);
-
-        when(mSubscription.isEmbedded()).thenReturn(true);
-        when(mSubscription.getSubscriptionId()).thenReturn(mSubId);
-        // Most tests want to have 2 available subscriptions so that the switch bar will show.
-        final SubscriptionInfo sub2 = mock(SubscriptionInfo.class);
-        when(sub2.getSubscriptionId()).thenReturn(456);
-        SubscriptionUtil.setAvailableSubscriptionsForTesting(Arrays.asList(mSubscription, sub2));
-
-        when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager);
-        when(mTelephonyManager.createForSubscriptionId(mSubId))
-                .thenReturn(mTelephonyManager);
-
-        final String key = "prefKey";
-        mController = new MobileNetworkSwitchController(mContext, key);
-        mController.init(mSubscription.getSubscriptionId());
-
-        mPreferenceManager = new PreferenceManager(mContext);
-        mScreen = mPreferenceManager.createPreferenceScreen(mContext);
-        mSwitchBar = new SettingsMainSwitchPreference(mContext);
-        mSwitchBar.setKey(key);
-        mSwitchBar.setTitle("123");
-        mScreen.addPreference(mSwitchBar);
-
-        final LayoutInflater inflater = LayoutInflater.from(mContext);
-        final View view = inflater.inflate(mSwitchBar.getLayoutResource(),
-                new LinearLayout(mContext), false);
-        final PreferenceViewHolder holder = PreferenceViewHolder.createInstanceForTests(view);
-        mSwitchBar.onBindViewHolder(holder);
-    }
-
-    @After
-    public void cleanUp() {
-        SubscriptionUtil.setAvailableSubscriptionsForTesting(null);
-    }
-
-    @Test
-    @UiThreadTest
-    public void isAvailable_pSIM_isNotAvailable() {
-        when(mSubscription.isEmbedded()).thenReturn(false);
-        mController.displayPreference(mScreen);
-        assertThat(mSwitchBar.isShowing()).isFalse();
-
-        when(mSubscriptionManager.canDisablePhysicalSubscription()).thenReturn(true);
-        mController.displayPreference(mScreen);
-        assertThat(mSwitchBar.isShowing()).isTrue();
-    }
-
-    @Test
-    @UiThreadTest
-    public void displayPreference_oneEnabledSubscription_switchBarNotHidden() {
-        doReturn(true).when(mSubscriptionManager).isActiveSubscriptionId(mSubId);
-        SubscriptionUtil.setAvailableSubscriptionsForTesting(Arrays.asList(mSubscription));
-        mController.displayPreference(mScreen);
-        assertThat(mSwitchBar.isShowing()).isTrue();
-    }
-
-    @Test
-    @UiThreadTest
-    public void displayPreference_oneDisabledSubscription_switchBarNotHidden() {
-        doReturn(false).when(mSubscriptionManager).isActiveSubscriptionId(mSubId);
-        SubscriptionUtil.setAvailableSubscriptionsForTesting(Arrays.asList(mSubscription));
-
-        mController.displayPreference(mScreen);
-
-        assertThat(mSwitchBar.isShowing()).isTrue();
-    }
-
-    @Test
-    @UiThreadTest
-    public void displayPreference_subscriptionEnabled_switchIsOn() {
-        when(mSubscriptionManager.isActiveSubscriptionId(mSubId)).thenReturn(true);
-        mController.displayPreference(mScreen);
-        assertThat(mSwitchBar.isShowing()).isTrue();
-        assertThat(mSwitchBar.isChecked()).isTrue();
-    }
-
-    @Test
-    @UiThreadTest
-    public void displayPreference_subscriptionDisabled_switchIsOff() {
-        when(mSubscriptionManager.isActiveSubscriptionId(mSubId)).thenReturn(false);
-
-        mController.displayPreference(mScreen);
-
-        assertThat(mSwitchBar.isShowing()).isTrue();
-        assertThat(mSwitchBar.isChecked()).isFalse();
-    }
-
-    @Test
-    @UiThreadTest
-    public void switchChangeListener_fromEnabledToDisabled_setSubscriptionEnabledCalledCorrectly() {
-        when(mSubscriptionManager.isActiveSubscriptionId(mSubId)).thenReturn(true);
-        mController.displayPreference(mScreen);
-        assertThat(mSwitchBar.isShowing()).isTrue();
-        assertThat(mSwitchBar.isChecked()).isTrue();
-
-        final ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);
-        doNothing().when(mContext).startActivity(intentCaptor.capture());
-
-        // set switch off then should start a Activity.
-        mSwitchBar.setChecked(false);
-
-        when(mSubscriptionManager.isActiveSubscriptionId(mSubId)).thenReturn(false);
-        // Simulate action of back from previous activity.
-        mController.displayPreference(mScreen);
-        Bundle extra = intentCaptor.getValue().getExtras();
-
-        verify(mContext, times(1)).startActivity(any());
-        assertThat(extra.getInt(ToggleSubscriptionDialogActivity.ARG_SUB_ID)).isEqualTo(mSubId);
-        assertThat(extra.getBoolean(ToggleSubscriptionDialogActivity.ARG_enable))
-                .isEqualTo(false);
-        assertThat(mSwitchBar.isChecked()).isFalse();
-    }
-
-    @Test
-    @UiThreadTest
-    public void switchChangeListener_fromEnabledToDisabled_setSubscriptionEnabledFailed() {
-        when(mSubscriptionManager.setSubscriptionEnabled(eq(mSubId), anyBoolean()))
-                .thenReturn(false);
-        when(mSubscriptionManager.isActiveSubscriptionId(mSubId)).thenReturn(true);
-        mController.displayPreference(mScreen);
-        assertThat(mSwitchBar.isShowing()).isTrue();
-        assertThat(mSwitchBar.isChecked()).isTrue();
-
-        final ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);
-        doNothing().when(mContext).startActivity(intentCaptor.capture());
-
-        // set switch off then should start a Activity.
-        mSwitchBar.setChecked(false);
-
-        // Simulate action of back from previous activity.
-        mController.displayPreference(mScreen);
-        Bundle extra = intentCaptor.getValue().getExtras();
-
-        verify(mContext, times(1)).startActivity(any());
-        assertThat(extra.getInt(ToggleSubscriptionDialogActivity.ARG_SUB_ID)).isEqualTo(mSubId);
-        assertThat(extra.getBoolean(ToggleSubscriptionDialogActivity.ARG_enable))
-                .isEqualTo(false);
-        assertThat(mSwitchBar.isChecked()).isTrue();
-    }
-
-    @Test
-    @UiThreadTest
-    public void switchChangeListener_fromDisabledToEnabled_setSubscriptionEnabledCalledCorrectly() {
-        when(mSubscriptionManager.isActiveSubscriptionId(mSubId)).thenReturn(false);
-        mController.displayPreference(mScreen);
-        assertThat(mSwitchBar.isShowing()).isTrue();
-        assertThat(mSwitchBar.isChecked()).isFalse();
-
-        final ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);
-        doNothing().when(mContext).startActivity(intentCaptor.capture());
-        mSwitchBar.setChecked(true);
-        Bundle extra = intentCaptor.getValue().getExtras();
-
-        verify(mContext, times(1)).startActivity(any());
-        assertThat(extra.getInt(ToggleSubscriptionDialogActivity.ARG_SUB_ID)).isEqualTo(mSubId);
-        assertThat(extra.getBoolean(ToggleSubscriptionDialogActivity.ARG_enable)).isEqualTo(true);
-    }
-    @Test
-    @UiThreadTest
-    public void onResumeAndonPause_registerAndUnregisterTelephonyCallback() {
-        mController.onResume();
-
-        verify(mTelephonyManager)
-                .registerTelephonyCallback(any(Executor.class), any(TelephonyCallback.class));
-
-        mController.onPause();
-        verify(mTelephonyManager)
-                .unregisterTelephonyCallback(any(TelephonyCallback.class));
-    }
-
-    @Test
-    @UiThreadTest
-    public void onPause_doNotRegisterAndUnregisterTelephonyCallback() {
-        mController.onPause();
-        verify(mTelephonyManager, times(0))
-                .unregisterTelephonyCallback(any(TelephonyCallback.class));
-    }
-}
diff --git a/tests/unit/src/com/android/settings/privatespace/HidePrivateSpaceControllerTest.java b/tests/unit/src/com/android/settings/privatespace/HidePrivateSpaceControllerTest.java
deleted file mode 100644
index b71547b..0000000
--- a/tests/unit/src/com/android/settings/privatespace/HidePrivateSpaceControllerTest.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * 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.
- */
-
-package com.android.settings.privatespace;
-
-import static com.android.settings.core.BasePreferenceController.AVAILABLE;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.mockito.Mockito.spy;
-
-import android.content.ContentResolver;
-import android.content.Context;
-import android.os.Flags;
-import android.platform.test.annotations.RequiresFlagsEnabled;
-import android.platform.test.flag.junit.CheckFlagsRule;
-import android.platform.test.flag.junit.DeviceFlagsValueProvider;
-import android.provider.Settings;
-
-import androidx.test.core.app.ApplicationProvider;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-@RunWith(AndroidJUnit4.class)
-@RequiresFlagsEnabled({Flags.FLAG_ALLOW_PRIVATE_PROFILE,
-        android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES})
-public class HidePrivateSpaceControllerTest {
-    @Rule
-    public final CheckFlagsRule mCheckFlagsRule =
-            DeviceFlagsValueProvider.createCheckFlagsRule();
-
-    private static final String KEY = "private_space_hidden";
-    private static final String DETAIL_PAGE_KEY = "private_space_hidden_details";
-    private Context mContext;
-    private HidePrivateSpaceSummaryController mHidePrivateSpaceSummaryController;
-    private HidePrivateSpaceController mHidePrivateSpaceController;
-    private ContentResolver mContentResolver;
-    private int mOriginalHiddenValue;
-
-    /** Required setup before a test. */
-    @Before
-    public void setUp() {
-        mContext = spy(ApplicationProvider.getApplicationContext());
-        mContentResolver = mContext.getContentResolver();
-        mHidePrivateSpaceSummaryController = new HidePrivateSpaceSummaryController(mContext, KEY);
-        mHidePrivateSpaceController =
-                new HidePrivateSpaceController(mContext, DETAIL_PAGE_KEY);
-        mOriginalHiddenValue = Settings.Secure.getInt(mContentResolver,
-                Settings.Secure.HIDE_PRIVATESPACE_ENTRY_POINT, 0);
-    }
-
-    @After
-    public void tearDown() {
-        Settings.Secure.putInt(mContentResolver, Settings.Secure.HIDE_PRIVATESPACE_ENTRY_POINT,
-                mOriginalHiddenValue);
-    }
-
-    /** Tests that the controller is always available. */
-    @Test
-    public void getAvailabilityStatus_returnsAvailable() {
-        assertThat(mHidePrivateSpaceController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
-    }
-
-    /** Tests that hide preference summary displays On when hide toggle is enabled.*/
-    @Test
-    public void setChecked_enable_shouldDisplayOn() {
-        Settings.Secure.putInt(mContentResolver, Settings.Secure.HIDE_PRIVATESPACE_ENTRY_POINT,
-                0);
-        assertThat(mHidePrivateSpaceController.isChecked()).isFalse();
-
-        mHidePrivateSpaceController.setChecked(true);
-
-        assertThat(mHidePrivateSpaceSummaryController.getSummary().toString())
-                .isEqualTo("On");
-        assertThat(mHidePrivateSpaceController.isChecked()).isTrue();
-    }
-
-    /** Tests that hide preference summary displays Off when toggle is disabled.*/
-    @Test
-    public void setChecked_disable_shouldDisplayOff() {
-        Settings.Secure.putInt(mContentResolver, Settings.Secure.HIDE_PRIVATESPACE_ENTRY_POINT,
-                1);
-
-        assertThat(mHidePrivateSpaceController.isChecked()).isTrue();
-
-        mHidePrivateSpaceController.setChecked(false);
-
-        assertThat(mHidePrivateSpaceSummaryController.getSummary().toString())
-                .isEqualTo("Off");
-        assertThat(mHidePrivateSpaceController.isChecked()).isFalse();
-    }
-}
