diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index cbb082a..56637ae 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -57,7 +57,9 @@
     <string name="widget_category_conversations" msgid="8894438636213590446">"Konverzácie"</string>
     <string name="widget_education_header" msgid="4874760613775913787">"Užitočné informácie poruke"</string>
     <string name="widget_education_content" msgid="745542879510751525">"Ak chcete získavať informácie bez otvárania aplikácií, môžete si pridať miniaplikácie na plochu"</string>
+    <string name="reconfigurable_widget_education_tip" msgid="6336962690888067057">"Klepnutím zmeňte nastavenia miniaplikácie"</string>
     <string name="widget_education_close_button" msgid="8676165703104836580">"Dobre"</string>
+    <string name="widget_reconfigure_button_content_description" msgid="8811472721881205250">"Zmena nastavení miniaplikácie"</string>
     <string name="all_apps_search_bar_hint" msgid="1390553134053255246">"Hľadať aplikácie"</string>
     <string name="all_apps_loading_message" msgid="5813968043155271636">"Načítavajú sa aplikácie…"</string>
     <string name="all_apps_no_search_results" msgid="3200346862396363786">"Nenašli sa žiadne aplikácie zodpovedajúce dopytu <xliff:g id="QUERY">%1$s</xliff:g>"</string>
@@ -160,18 +162,16 @@
     <string name="all_apps_personal_tab" msgid="4190252696685155002">"Osobné"</string>
     <string name="all_apps_work_tab" msgid="4884822796154055118">"Pracovné"</string>
     <string name="work_profile_toggle_label" msgid="3081029915775481146">"Pracovný profil"</string>
-    <string name="work_profile_edu_personal_apps" msgid="4155536355149317441">"Osobné údaje sú oddelené a sú pred pracovnými aplikáciami skryté"</string>
-    <string name="work_profile_edu_work_apps" msgid="237051938268703058">"Pracovné aplikácie a údaje môže vidieť váš správca IT"</string>
-    <string name="work_profile_edu_next" msgid="8783418929296503629">"Ďalej"</string>
+    <!-- no translation found for work_profile_edu_work_apps (7895468576497746520) -->
+    <skip />
     <string name="work_profile_edu_accept" msgid="6069788082535149071">"Dobre"</string>
-    <string name="work_apps_paused_title" msgid="2389865654362803723">"Pracovný profil je pozastavený"</string>
-    <string name="work_apps_paused_body" msgid="4209084728264328628">"Pracovné aplikácie vám nemôžu posielať upozornenia, používať vašu batériu ani vašu polohu"</string>
-    <string name="work_apps_paused_content_description" msgid="4473292417145736203">"Pracovný profil je pozastavený. Pracovné aplikácie nemôžu posielať upozornenia, používať batériu ani polohu."</string>
+    <string name="work_apps_paused_title" msgid="3007471013401118920">"Pracovné aplikácie sú vypnuté"</string>
+    <string name="work_apps_paused_body" msgid="261634750995824906">"Pracovné aplikácie nemôžu posielať upozornenia ani používať batériu či polohu."</string>
+    <string name="work_apps_paused_content_description" msgid="5149623040804051095">"Pracovné aplikácie sú vypnuté. Nemôžu posielať upozornenia ani používať batériu či polohu."</string>
     <string name="work_apps_paused_edu_banner" msgid="8872412121608402058">"Pracovné aplikácie majú odznak a zobrazujú sa správcovi IT"</string>
     <string name="work_apps_paused_edu_accept" msgid="6377476824357318532">"Dobre"</string>
-    <string name="work_apps_pause_btn_text" msgid="4669288269140620646">"Pozastaviť pracovné aplikácie"</string>
-    <string name="work_apps_enable_btn_text" msgid="82111102541971856">"Zapnúť"</string>
+    <string name="work_apps_pause_btn_text" msgid="1921059713673767460">"Vypnúť pracovné aplikácie"</string>
+    <string name="work_apps_enable_btn_text" msgid="1156432622148413741">"Zapnúť pracovné aplikácie"</string>
     <string name="developer_options_filter_hint" msgid="5896817443635989056">"Filtrujte"</string>
-    <string name="work_switch_tip" msgid="808075064383839144">"Pozastavte pracovné aplikácie a upozornenia"</string>
     <string name="remote_action_failed" msgid="1383965239183576790">"Zlyhalo: <xliff:g id="WHAT">%1$s</xliff:g>"</string>
 </resources>
