<?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="yes" msgid="1999566976857398962">"Áno"</string>
    <string name="no" msgid="5541738710521607130">"Nie"</string>
    <string name="create" msgid="986997212165228751">"Vytvoriť"</string>
    <string name="allow" msgid="3763244945363657722">"Povoliť"</string>
    <string name="deny" msgid="7326117222944479942">"Zamietnuť"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Zapnúť"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Neznáme"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Klepnutím zobrazíte informácie"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Ešte # krok a bude z vás vývojár.}few{Ešte # kroky a bude z vás vývojár.}many{Ešte # kroka a bude z vás vývojár.}other{Ešte # krokov a bude z vás vývojár.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Teraz ste vývojár!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nie je to potrebné, už ste vývojár."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Najprv povoľte možnosti pre vývojárov"</string>
    <string name="dev_settings_available_to_admin_only_warning" msgid="3408243404879083111">"K nastaveniam vývojára majú prístup iba správcovia."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Systém"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"V prevádzke"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Mimo prevádzky"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Rádio je vypnuté"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Bez roamingu"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Odpojený"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Pripája sa"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Pripojené"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Pozastavená"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Neznáme"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Ukážka"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Zmenšiť"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Zväčšiť"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Vždy"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Predná obrazovka sa pri zložení zariadenia zapne"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Iba hry, videá a ďalší obsah"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Predná obrazovka sa zapne v prípade aplikácií, ktoré bránia spusteniu režimu obrazovky pri nečinnosti"</string>
    <string name="stay_awake_on_lockscreen_title" msgid="8088456642083051068">"Pokračujte potiahnutím nahor"</string>
    <string name="stay_awake_on_lockscreen_summary" msgid="2299351813382522952">"Ak chcete pokračovať v používaní aplikácie, zložte telefón a potiahnite prstom nahor po prednej obrazovke alebo počkajte niekoľko sekúnd, kým sa obrazovka uzamkne"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Nikdy"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Predná obrazovka sa pri zložení zariadenia uzamkne"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Používať automatické otáčanie"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Rozpoznávanie tváre zlepšuje presnosť automatického otáčania pomocou prednej kamery. Obrázky sa nikdy neukladajú ani neodosielajú Googlu."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Viditeľné pre všetky okolité zariadenia Bluetooth (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Viditeľné pre všetky okolité zariadenia Bluetooth"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Neviditeľné pre ostatné zariadenia Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Viditeľné len pre spárované zariadenia"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Zariadenia Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Názov zariadenia"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Premenovať toto zariadenie"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Premenovať"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Odpojiť zariadenie?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Spárovať nové zariadenie"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_screen_auto_on_title" msgid="8496443490064988240">"Automaticky zajtra znova zapnúť"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Spárovať pravé ucho"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Spárovať ľavé ucho"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Spárujte si druhé ucho"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Je pripojené ľavé načúvacie zariadenie.\n\nAk chcete spárovať pravé, skontrolujte, či je zapnuté a pripravené na párovanie."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Je pripojené pravé načúvacie zariadenie.\n\nAk chcete spárovať ľavé, skontrolujte, či je zapnuté a pripravené na párovanie."</string>
    <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>
    <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>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Prehrávajte zvuk v načúvacom zariadení alebo reproduktore telefónu"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Podobné"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Tóny zvonenia a budíky"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Zvuk počas hovorov"</string>
    <string name="bluetooth_media_title" msgid="2878373577382067290">"Médiá a zvuky systému"</string>
    <string name="bluetooth_notification_title" msgid="8708962394926222039">"Upozornenia"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Zvukový výstup predvolene určujú jednotlivé aplikácie"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Nepomenované zariadenie s rozhraním Bluetooth"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Vyhľadávanie"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"V okolí nie sú žiadne zariadenia Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Žiadosť o spárovanie zariadenia Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Žiadosť o spárovanie"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> spárujete klepnutím."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Rozhranie Bluetooth je vypnuté"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Zapnite ho klepnutím"</string>
    <string name="device_picker" msgid="2427027896389445414">"Vybrať zariadenie Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnúť Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce vypnúť Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Aplikácia chce zapnúť Bluetooth."</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Aplikácia chce vypnúť Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Bluetooth sa zapína…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Bluetooth sa vypína…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Žiadosť o pripojenie zariadenia Bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Žiadosť o prístup k telefónnemu zoznamu"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Žiadosť o prístup ku správam"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Viditeľné pre ostatné zariadenia ako <xliff:g id="DEVICE_NAME">^1</xliff:g>"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Ak sa chcete pripojiť k ostatným zariadeniam, zapnite Bluetooth."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Vaše zariadenia"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Párovanie nového zariadenia"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Zakázať hardvérové zníženie záťaže Bluetooth (A2DP)"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Zakázať hardvérové zníženie záťaže Bluetooth LE"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Chcete zariadenie reštartovať?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Ak chcete zmeniť toto nastavenie, musíte reštartovať zariadenie."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Reštartovať"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Zrušiť"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Deaktivovať Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Deaktivovať funkciu Bluetooth LE Audio, keď zariadenie podporuje možnosti hardvéru LE Audio"</string>
    <string name="bluetooth_leaudio_mode" msgid="5206961943393400814">"Režim Bluetooth LE Audio"</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Zobrazovať LE Audio v podr. o zariadení"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Obchádzať zoznam povolených aplikácie Bluetooth LE Audio"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Používať LE Audio predvolene, aj keď nebolo overené, či periféria LE Audio spĺňa kritériá zoznamu povolených"</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Mediálne zariadenia"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Zariadenia na telefonovanie"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Iné zariadenia"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Uložené zariadenia"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Spojené s účtom"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Použité v minulosti s účtom"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Na párovanie sa zapne Bluetooth"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Nastavenia pripojenia"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Predtým pripojené zariadenia"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Rozhranie Bluetooth je zapnuté"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Zobraziť všetky"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Zobraziť všetko"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Dotykové pero"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Stlačenie tlačidla na tele pera"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (pracovný profil)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Písanie v textových poliach"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignorovať všetky stlačenia tlačidla dotykového pera"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Dotykové pero"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"V okolí sa nenašli zvukové streamy."</string>
    <string name="date_and_time" msgid="1788358029823431692">"Dátum a čas"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy server"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Vymazať"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Port proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Nepoužívať proxy server pre"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Obnoviť predvolené nastavenia"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Hotovo"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Názov hostiteľa proxy servera"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Upozornenie"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Zadaný názov hostiteľa nie je platný."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Zoznam vylúčení, ktorý ste vytvorili, má nesprávny formát. Zadajte zoznam vylúčených domén a jednotlivé názvy oddeľte čiarkami."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Musíte vyplniť pole port."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Ak je pole hostiteľ prázdne, musí byť prázdne aj pole port."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Zadaný port nie je platný."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Prehliadač používa proxy server protokolu HTTP, ale ostatné aplikácie ho používať nemusia."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"Webová adresa PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Testovať dostupnosť domény (www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Test klienta HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Spustiť testovanie dostupnosti (ping)"</string>
    <string name="skip_label" msgid="6380034601349015895">"Preskočiť"</string>
    <string name="next_label" msgid="1248293387735652187">"Ďalej"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Jazyky"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Poradie preferovaných jazykov"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Jazyk systému"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Odstrániť"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Pridať jazyk"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Jazyk"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Preferovaný jazyk"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Jazyky aplikácií"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Nastavte jazyk pre každú aplikáciu"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Jazyk aplikácie"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Navrhované jazyky"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Všetky jazyky"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Jazyk systému"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Predvolené systémom"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Výber jazyka pre túto aplikáciu nie je v Nastaveniach k dispozícii."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Jazyk môže byť iný, ako sú tie, ktoré sú k dispozícii v aplikácii. Niektoré aplikácie nemusia toto nastavenie podporovať."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Nastavte jazyk pre každú aplikáciu."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Systém, aplikácie a weby používajú prvý jazyk z vášho poradia preferovaných jazykov, ktorý podporujú."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Ak chcete vybrať jazyk pre konkrétnu aplikáciu, prejdite do nastavení jazyka tejto aplikácie."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Ďalšie informácie o jazykoch aplikácií"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Chcete zmeniť jazyk systému na možnosť %s?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Pridať jazyk %s medzi preferované?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Aplikácie aj weby tým informujete, že preferujete aj tento jazyk."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Nastavenia zariadenia a regionálne nastavenia sa zmenia."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Zmeniť"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s nie je k dispozícii"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Tento jazyk nemôžete používať pre systém, ale môžete informovať aplikácie a weby, že ho preferujete."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Regionálne nastavenia"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Nastavte predvoľby jednotiek a čísiel"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Keď používate regionálne nastavenia, aplikácie vám môžu prispôsobiť svoje prostredie."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Aplikácie budú podľa možností používať vaše regionálne nastavenia."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Teplota"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Prvý deň v týždni"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Predvoľby čísiel"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Použiť predvolené"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celzius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Nedeľa"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Pondelok"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Utorok"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Streda"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Štvrtok"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Piatok"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Sobota"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Ak aplikácia regionálne nastavenia nepodporuje, bude v nej použité predvolené miestne nastavenie."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Ďalšie informácie o jazykových nastaveniach"</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Ďalšie predvoľby"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Oslovenia"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Nastavte si oslovenie"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Aplikácie môžu pomocou vašich oslovení prispôsobiť, ako vás majú oslovovať."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Nezadané"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Ženský rod"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Mužský rod"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutrálne"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Chcete vybraný jazyk odstrániť?}few{Chcete vybrané jazyky odstrániť?}many{Remove selected languages?}other{Chcete vybrané jazyky odstrániť?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Text sa zobrazí v inom jazyku."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Nie je možné odstrániť všetky jazyky"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Ponechajte aspoň jeden preferovaný jazyk"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Nie je k dispozícii ako jazyk systému"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Presunúť nahor"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Presunúť nadol"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Presunúť na začiatok"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Presunúť na koniec"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Odstrániť jazyk"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Zvoliť aktivitu"</string>
    <string name="cancel" msgid="5780102414089664898">"Zrušiť"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Zabudnúť"</string>
    <string name="save" msgid="3125033126936493822">"Uložiť"</string>
    <string name="done" msgid="7497982645646431310">"Hotovo"</string>
    <string name="apply" msgid="7834684883190163536">"Použiť"</string>
    <string name="share" msgid="8502235338607613795">"Zdieľať"</string>
    <string name="add" msgid="8335206931421683426">"Pridať"</string>
    <string name="remove" msgid="1028414219245072102">"Odstrániť"</string>
    <string name="settings_label" msgid="943294133671632976">"Nastavenia"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Nastavenia"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Odkaz na nastavenia"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Režim v lietadle"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Bezdrôtové pripojenia a siete"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Pripájať sa k dátovým službám pri roamingu"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Pripájať sa k dátovým službám pri roamingu"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Môžu sa účtovať poplatky za roaming."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Nastavovať čas automaticky"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Nastavovať automaticky"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Keď bude tento prepínač zapnutý, pomocou polohy sa nastaví časové pásmo"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Používať miestny predvolený formát"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Používať 24-hodinový formát"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Čas"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Formát času"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Časové pásmo"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Časové pásmo"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Dátum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Vyhľadať oblasť"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Oblasť"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Vybrať časový posun"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Použitia <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> sa začína <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Používa <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nepoužíva letný čas."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Letný čas"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Štandardný čas"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Vybrať podľa oblasti"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Vybrať podľa čas. posunu UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Zamykať po časovom limite"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po uplynutí časového limitu"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Okamžite po uplynutí časového limitu, ak odomknutie nie je udržiavané funkciou <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po uplynutí časového limitu, ak odomknutie nie je udržiavané funkciou <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Pridať text na uzamknutej obrazovke"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Žiadne"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Napr. Petrov Android"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Poloha"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Používať polohu"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Vypnuté"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Zapnuté – # aplikácia má prístup k polohe}few{Zapnuté – # aplikácie majú prístup k polohe}many{On / # apps have access to location}other{Zapnuté – # aplikácií má prístup k polohe}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Načítava sa…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Aplikácie s povolením pre zariadenia v okolí môžu rozpoznať relatívnu pozíciu pripojených zariadení."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Prístup aplikácií a služieb k polohe je vypnutý. Poloha zariadenia však stále môže byť odoslaná záchranárom, keď zavoláte na tiesňovú linku alebo na ňu pošlete textovú správu."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Ďalšie informácie o nastaveniach polohy"</string>
    <string name="location_settings_tooltip_text_for_chrome" msgid="3574930966097093550">"Zmena prístupu k polohe: Nastavenia &gt; Zabezp. a ochr. súkromia &gt; Nast. och. súkromia"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Účty"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Zabezpečenie"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifrovanie a prihlasovacie údaje"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Uzamknutá obrazovka"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Čo zobrazovať"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nie je k dispozícii"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Stav zabezpečenia"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Zámka obrazovky, Nájdi moje zariadenie, zabezpečenie aplikácie"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Zabezpečenie a ochrana súkromia"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Zabezpečenie aplikácií, zámka zariadenia, povolenia"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Pridaná tvár"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Vyžaduje sa nastavenie"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Odomknutie tvárou"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Odomknutie tvárou pre prácu"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Ako nastaviť odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Nastavenie odomknutia tvárou"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Overenie totožnosti pomocou tváre"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Začať"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Ak je zjednodušené odomknutie tvárou vypnuté, niektoré kroky nastavenia nemusia v aplikácii TalkBack fungovať správne."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Späť"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Pokračovať v nastavení"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Použiť nastavenie dostupnosti"</string>
    <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">"Zrušiť"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nie, vďaka"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Súhlasím"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Viac"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Odomykanie pomocou tváre"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Povoľte odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Overenie totožnosti pomocou tváre"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Odomykajte telefón a schvaľujte nákupy tvárou.\n\nUpozornenie: Toto zariadenie nemôžete odomykať tvárou. Ďalšie informácie vám poskytne správca organizácie."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Používajte tvár na odomykanie telefónu, schvaľovanie nákupov a prihlasovanie sa do aplikácií"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Umiestnite svoju tvár do kruhu"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Preskočiť"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Pridali ste maximálny počet tvárí"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Nie je možné pridať ďalšie tváre"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registrácia nebola dokončená"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Časový limit registrácie tváre vypršal. Skúste to znova."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Registrácia tváre nefungovala."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Všetko sa podarilo nastaviť."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Hotovo"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Zlepšite výkonnosť odomknutia tvárou"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Znova nastavte odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Znova nastavte odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Zlepšite zabezpečenie a výkonnosť"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Nastavte odomknutie tvárou"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Ak chcete odomknutie tvárou nastaviť znova, odstráňte aktuálny model tváre.\n\nModel tváre sa bezpečným spôsobom natrvalo odstráni.\n\nPo jeho odstránení budete na odomknutie telefónu alebo overovanie v aplikáciách potrebovať PIN, vzor alebo heslo."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Ak chcete odomknutie tvárou nastaviť znova, odstráňte aktuálny model tváre.\n\nModel tváre sa bezpečným spôsobom natrvalo odstráni.\n\nPo jeho odstránení budete na odomknutie telefónu alebo overovanie v aplikáciách potrebovať odtlačok prsta, PIN, vzor alebo heslo."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Odomknutím tvárou:"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Pri používaní odomknutia tvárou"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Vyžadovať otvorené oči"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Pri odomykaní telefónu vyžadovať otvorené oči"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Vždy vyžadovať potvrdenie"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Pri používaní odomknutia tvárou v aplikáciách vždy vyžadovať potvrdenie"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Odstrániť model tváre"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Nastaviť odomknutie tvárou"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Chcete model tváre odstrániť?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Model tváre bude bezpečným spôsobom natrvalo odstránený.\n\nPo odstránení budete pri odomykaní telefónu alebo overovaní v aplikáciách potrebovať PIN, vzor alebo heslo."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Model tváre bude bezpečným spôsobom natrvalo odstránený.\n\nPo odstránení budete pri odomykaní telefónu potrebovať PIN, vzor alebo heslo."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Model tváre bude natrvalo a bezpečne odstránený.\n\nPo odstránení budete pri odomykaní telefónu alebo overovaní v aplikáciách potrebovať odtlačok prsta, PIN, vzor alebo heslo."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Model tváre bude bezpečným spôsobom natrvalo odstránený.\n\nPo odstránení budete pri odomykaní telefónu potrebovať odtlačok prsta, PIN, vzor alebo heslo."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Odomykajte telefón tvárou"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Odtlačok prsta"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Odtlačok prsta"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Pri používaní odomknutia odtlačkom prsta"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Odtlačok pre prácu"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Pridať odtlačok prsta"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Bol pridaný odtlačok prsta}few{Boli pridané # odtlačky prsta}many{# fingerprints added}other{Bolo pridaných # odtlačkov prsta}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Vyžaduje sa nastavenie"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Nastavenie odtlačku prsta"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Povoľte odomk. odtlačk. prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Používanie odtlačku prsta"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Ďalšie informácie o odomknutí odtlačkom prsta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Všetko máte pod kontrolou"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Vy a vaše dieťa máte všetko pod kontrolou"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Upozornenie"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Odomykajte svoj telefón a schvaľujte nákupy pomocou odtlačku prsta.\n\nUpozornenie: Toto zariadenie nemôžete odomykať pomocou odtlačku prsta. Ďalšie informácie vám poskytne správca organizácie."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Zrušiť"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nie, vďaka"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Súhlasím"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Preskočiť odtlačok prsta?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Nastavenie odtlačku prsta trvá približne minútu. Ak tento krok preskočíte, môžete si odtlačok prsta pridať neskôr v nastaveniach."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Keď uvidíte túto ikonu, overte svoju totožnosť odtlačkom prsta (napríklad keď sa prihlasujete do aplikácií alebo schvaľujete nákup)"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Upozornenie"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Ako to funguje"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Odomknutie odtlačkom prsta vytvorí jedinečný model odtlačku vášho prsta, ktorým overíte svoju totožnosť. Počas nastavovania nasnímajte svoj prst z rôznych pozícií, aby bolo možné tento model odtlačku prsta vytvoriť."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Odomknutie odtlačkom prsta vytvorí jedinečný model odtlačku prsta vášho dieťaťa, ktorým overí svoju totožnosť. Počas nastavovania nasnímajte jeho prst z rôznych pozícií, aby bolo možné tento model odtlačku prsta vytvoriť."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Najlepšie výsledky dosiahnete, keď použijete ochranu obrazovky s certifikátom Made for Google. S inými ochranami obrazovky nemusí odtlačok prsta fungovať."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Najlepšie výsledky dosiahnete, keď použijete ochranu obrazovky s certifikátom Made for Google. S inými ochranami obrazovky nemusí odtlačok prsta vášho dieťa fungovať."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Odomknutie hodinkami"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"Keď si nastavíte odomknutie tvárou aj odtlačkom prsta a budete sa nachádzať v tmavom prostredí alebo mať rúško, telefón vás požiada o odtlačok prsta.\n\nOdomknutie hodinkami je ďalší praktický spôsob, ako odomknúť telefón, keď máte napríklad vlhké prsty alebo zariadenie nedokáže rozpoznať vašu tvár."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"Odomknutie hodinkami je ďalší praktický spôsob, ako odomknúť telefón, keď napríklad zariadenie nedokáže rozpoznať váš odtlačok prsta."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"Odomknutie hodinkami je ďalší praktický spôsob, ako odomknúť telefón, keď napríklad zariadenie nedokáže rozpoznať vašu tvár."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Odtlačkom prsta alebo hodinkami môžete"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Tvárou alebo hodinkami môžete"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Tvárou, odtlačkom prsta alebo hodinkami môžete"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Hodinkami môžete"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Tvárou alebo hodinkami"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Odtlačkom prsta alebo hodinkami"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Tvárou, odtlačkom prsta alebo hodinkami"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Hodinkami"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Najprv nastavte odomknutie tvárou alebo odtlačkom prsta"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Hodinkami môžete odomknúť, keď nebude rozpoznaná vaša tvár alebo odtlačok prsta"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Najprv nastavte odomknutie odtlačkom prsta"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Hodinkami môžete odomknúť, keď nebude rozpoznaný váš odtlačok prsta"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Najprv nastavte odomknutie tvárou"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Hodinkami môžete odomknúť, keď nebude rozpoznaná vaša tvár"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Nastaviť"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Odtlačok prsta a hodinky <xliff:g id="WATCH">%s</xliff:g> boli pridané"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Odtlačky prstov a hodinky <xliff:g id="WATCH">%s</xliff:g> boli pridané"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Tvár a hodinky <xliff:g id="WATCH">%s</xliff:g> boli pridané"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Tvár, odtlačok prsta a hodinky <xliff:g id="WATCH">%s</xliff:g> boli pridané"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Tvár, odtlačky prstov a hodinky <xliff:g id="WATCH">%s</xliff:g> boli pridané"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Odomknutie Remote Authenticator"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Hodinky boli pridané"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Nastavte si hodinky"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Odomknutie hodinkami je ďalší praktický spôsob, ako odomknúť tento telefón, napríklad keď máte vlhké prsty alebo keď zariadenie nedokáže rozpoznať vašu tvár.\n\nHodinkami môžete odomykať tento telefón, keď:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Teraz nie"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Pokračovať"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Viac"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Ako to funguje"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Hodinky musíte mať odomknuté na zápästí a v dosahu tohto telefónu. Keď ich budete mať na zápästí, nebudete ich musieť znova odomykať."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Keď sa tento telefón odomkne, dostanete v hodinkách upozornenie. Ak sa odomkol a vy ste to nechceli, klepnutím na upozornenie ho znova uzamknete."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Všetko máte pod kontrolou"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Hodinky môžete z funkcie odomknutia hodinkami kedykoľvek odstrániť v Nastaveniach"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Klepnite na upozornenie"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Potiahnite po uzamknutej obrazovke nahor"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Vyberte svoje hodinky"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Dostupné hodinky"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Zrušiť"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Potvrdiť"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Hotovo!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Hodinkami môžete teraz odomykať tento telefón potiahnutím po uzamknutej obrazovke nahor alebo klepnutím na upozornenie"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Hotovo"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Odomknutie hodinkami"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Hodinkami môžete odomykať tento telefón potiahnutím po uzamknutej obrazovke nahor alebo klepnutím na upozornenie"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Ak chcete používať odomknutie hodinkami, musíte mať hodinky odomknuté na zápästí, pričom musia byť pripojené k tomuto telefónu a v jeho dosahu. Ak sa pripojenie preruší, budete musieť pred použitím odomknutia hodinkami telefón odomknúť.\n\nPamätajte:\nSúčasne môžete mať nastavené iba jedny hodinky. Ak chcete pridať ďalšie, musíte najprv odstrániť aktuálne."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Ďalšie informácie o odomknutí hodinkami"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Pridať hodinky"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Odstrániť hodinky"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Odomknutie odtlačkom prsta a tvárou"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Odomknutie tvárou a odtlačkom prsta pre prácu"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Vyžaduje sa nastavenie"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Bola pridaná tvár a odtlačky prsta"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Bola pridaná tvár a odtlačok prsta"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Keď si nastavíte odomknutie tvárou aj odtlačkom prsta a budete sa nachádzať v tmavom prostredí alebo mať rúško, telefón vás požiada o odtlačok prsta"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Spôsoby odomknutia"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Tvárou alebo odtlačkom prsta"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Odomykať telefón"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Overovať vašu totožnosť v aplikáciách"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Pomocou tváre"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Pomocou odtlačku prsta"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Tvárou alebo odtlačkom prsta"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Nemôžete nastaviť odomknutie tvárou?"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Zavrite rozdelenú obrazovku a nastavte odomknutie tvárou"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Odtlačok prsta sa nedá nastaviť"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Zavrite rozdelenú obrazovku a nastavte odomknutie odtlačkom prsta"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Preskočiť zámku obrazovky?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Preskočiť"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Späť"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Preskočiť"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Zrušiť"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Dotknite sa senzora"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Dotknite sa vypínača, ale nestláčajte ho"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Ako si nastaviť odtlačok prsta"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Nachádza sa na zadnej strane telefónu. Použite ukazovák."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Senzor odtlačkov prstov je na obrazovke. Odtlačok prsta nasnímate na ďalšej obrazovke."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Začať"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Senzor nájdete posúvaním prsta po obrazovke. Pridržte senzor odtlačkov prstov."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustrácia zariadenia a umiestnenia senzora odtlačku prsta"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Názov"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Skúsiť znova"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Odstrániť"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Dotknite sa senzora"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Priložte prst k senzoru a zdvihnite ho, keď zacítite vibráciu"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Držte prst na senzore, kým nezacítite vibrovanie"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Tlačidlo nestláčajte, ale prst majte priložený k senzoru, dokým nezacítite vibráciu.\n\nPrstom zakaždým mierne pohýbte. Takto sa nasníma väčšia časť odtlačku vášho prsta."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Pridržte senzor odtlačkov prstov"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Zdvihnite a opäť priložte"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Ešte raz"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Sledujte ikonu odtlačku prsta"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Zdvíhajte prst, aby ste pridali všetky odlišné časti odtlačku prsta"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Pridržte pri každom presune ikony odtlačku prsta. Takto sa nasníma väčšia časť odtlačku vášho prsta."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Priložte špičku prsta na senzor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Priložte ľavú stranu prsta"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Priložte pravú stranu prsta"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Priložte strednú časť prsta na senzor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Priložte špičku prsta na senzor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Priložte ľavú stranu prsta na senzor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Nakoniec priložte pravú stranu prsta na senzor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Umiestnite bočnú stranu odtlačku prsta na senzor, chvíľu ho tam podržte a potom priložte opačnú stranu"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Takto sa nasníma väčšia časť odtlačku vášho prsta"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Priebeh registrácie odtlačku prsta: <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Zaregistrovaný na <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Priebeh registrácie odtlačku prsta: <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Odtlačok prsta bol pridaný"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Odomknúť dotykom kedykoľvek"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Keď sa dotknete senzora, zariadenie sa odomkne, aj keď bude obrazovka vypnutá. Táto možnosť zvyšuje pravdepodobnosť náhodného odomknutia."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Obrazovka, odomknutie"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Neskôr"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Zdvihnite a opäť priložte"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Umiestnite bočnú stranu odtlačku prsta na senzor, chvíľu ho tam podržte a potom priložte opačnú stranu"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Preskočiť nastavenie odtlačkov prstov?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Vybrali ste, že chcete používať odtlačok prsta ako jeden zo spôsobov odomknutia telefónu. Ak tento krok preskočíte, budete musieť odtlačok prsta nastaviť neskôr. Trvá to približne minútu."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Preskočiť nastavenie možnosti <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Chcete preskočiť nastavenie kódu PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Chcete preskočiť nastavenie kódu PIN a tváre?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Chcete preskočiť nastavenie kódu PIN a odtlačku prsta?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Chcete preskočiť nastavenie kódu PIN, tváre a odtlačku prsta?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Chcete preskočiť nastavenie hesla?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Chcete preskočiť nastavenie hesla a tváre?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Preskočiť nastavenie hesla a odtlačku prsta?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Preskočiť nastav. hesla, tváre a odtlačku prsta?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Chcete preskočiť nastavenie vzoru?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Chcete preskočiť nastavenie vzoru a tváre?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Preskočiť nastavenie vzoru a odtlačku prsta?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Preskočiť nastav. vzoru, tváre a odtlačku prsta?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Nastaviť zámku obrazovky"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Hotovo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ojoj, to nie je senzor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Dotknite sa senzora na zadnej strane telefónu. Použite ukazovák."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Nastavenie odtlačku prsta sa nedá dokončiť"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Môžete to skúsiť znova alebo nastavte odtlačok prsta neskôr v Nastaveniach."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Môžete to skúsiť znova alebo nastavte odtlačok prsta neskôr."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Nastavenie odtlačku prsta vypršalo"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Odtlačok prsta môžete nastaviť neskôr v Nastaveniach."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Niečo sa pokazilo. Odtlačok prsta môžete nastaviť neskôr v Nastaveniach."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Odtlačok prsta môžete nastaviť neskôr."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Niečo sa pokazilo. Odtlačok prsta môžete nastaviť neskôr."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Pridať ďalší"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Ďalej"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Možnosť zámky obrazovky je zakázaná. VIac sa dozviete od správcu svojej organizácie."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Naďalej môžete pomocou odtlačku prsta schvaľovať nákupy a prístup do aplikácií."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Zdvihnite prst, potom sa opäť dotknite senzora"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Senzor odtlačkov prstov nie je možné používať"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Navštívte poskytovateľa opráv."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Ďalšie nastavenia zabezpečenia"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Zámka pracovného profilu, šifrovanie a ďalšie"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Šifrovanie, prihlasovacie údaje a ďalšie"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"zabezpečenie, ďalšie nastavenia zabezpečenia, ďalšie nastavenia, rozšírené nastavenia zabezpečenia"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Ďalšie nastavenia ochrany súkromia"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Ďalšie zabezpečenie a ochrana súkromia"</string>
    <string name="security_header" msgid="961514795852103424">"Zabezpečenie"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Ochrana súkromia"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Pracovný profil"</string>
    <string name="private_space_title" msgid="1752064212078238723">"Súkromný priestor"</string>
    <string name="private_space_summary" msgid="2274405892301976238">"Ponechajte súkromné aplikácie uzamknuté a skryté"</string>
    <string name="private_space_description" msgid="4059594203775816136">"Uchovávajte súkromné aplikácie v samostatnom priestore, ktorý môžete skryť alebo uzamknúť"</string>
    <string name="private_space_lock_title" msgid="7230836881433350526">"Zámka súkromného priestoru"</string>
    <string name="private_space_one_lock_summary" msgid="2106513606571219068">"Súkromný priestor môžete odomknúť rovnakým spôsobom ako svoje zariadenie, prípadne môžete vybrať inú zámku"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Používať zámku obrazovky zariadenia"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Odomknutie tvárou a odtlačkom prsta"</string>
    <string name="private_space_fingerprint_title" msgid="5989254643211889931">"Odomknutie odtlačkom prsta"</string>
    <string name="private_space_face_title" msgid="3290402865367663079">"Odomknutie tvárou"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Nastavíte klepnutím"</string>
    <string name="private_space_fingerprint_unlock_title" msgid="3614016453395789051">"Odomknutie súkromného priestoru odtlačkom prsta"</string>
    <string name="private_space_face_unlock_title" msgid="462248384776453613">"Odomknutie súkromného priestoru tvárou"</string>
    <string name="private_space_category_ways_to_unlock" msgid="4356631225316950046">"Spôsoby odomknutia"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Rovnaké ako zámka obrazovky zariadenia"</string>
    <string name="private_space_new_lock_title" msgid="9056139964133004094">"Chcete pre súkromný priestor vybrať novú zámku?"</string>
    <string name="private_space_auto_lock_title" msgid="8663409382910601261">"Automatické uzamykanie súkromného priestoru"</string>
    <string name="private_space_auto_lock_page_summary" msgid="8679844515655838654">"Ak ste zariadenie istý čas nepoužili, môžete si automaticky uzamknúť súkromný priestor"</string>
    <string name="private_space_auto_lock_every_time" msgid="1215061855836002830">"Vždy, keď sa zariadenie uzamkne"</string>
    <string name="private_space_auto_lock_after_inactivity" msgid="1748673030841528649">"Po piatich minútach nečinnosti"</string>
    <string name="private_space_auto_lock_never" msgid="595014527119778873">"Nikdy"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Skryť pri uzamknutí"</string>
    <string name="privatespace_hide_page_title" msgid="8417507414027827566">"Skrytie súkromného priestoru pri uzamknutí"</string>
    <string name="privatespace_hide_page_summary" msgid="5525422595477989312">"Ak nechcete, aby ostatní ľudia vedeli, že máte v zariadení súkromný priestor, môžete ho skryť v zozname aplikácií"</string>
    <string name="privatespace_access_header" msgid="6066826215718835041">"Prístup do súkromného priestoru, keď je skrytý"</string>
    <string name="privatespace_search_description" msgid="3121043205513022357">"V zozname aplikácií zadajte do vyhľadávacieho panela „súkromný priestor“"</string>
    <string name="privatespace_tap_tile_description" msgid="8346440188590931635">"Klepnite na kartu súkromného priestoru"</string>
    <string name="privatespace_unlock_description" msgid="3177710543121916413">"Odomknúť súkromný priestor"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Vypnuté"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Zapnuté"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Systém"</string>
    <string name="private_space_delete_title" msgid="636873505724100006">"Odstránenie súkromného priestoru"</string>
    <string name="private_space_delete_header" msgid="4594429153176776184">"Chcete odstrániť súkromný priestor?"</string>
    <string name="private_space_delete_summary" msgid="3344372988408565545">"Váš súkromný priestor bude odstránený z vášho zariadenia. Všetky súkromné aplikácie a dáta budú odstránené. Túto akciu nemôžete vrátiť späť."</string>
    <string name="private_space_accounts" msgid="1078277762792056395">"Nasledujúce účty budú odstránené z tohto súkromného priestoru:"</string>
    <string name="private_space_delete_button_label" msgid="1256981385318225002">"Odstrániť"</string>
    <string name="private_space_confirm_deletion_header" msgid="3468651585498942977">"Odstraňuje sa súkromný priestor…"</string>
    <string name="private_space_confirm_deletion_summary" msgid="342544588554284686">"Bude to chvíľu trvať"</string>
    <string name="private_space_deleted" msgid="7692240901492540053">"Súkromný priestor bol odstránený"</string>
    <string name="private_space_delete_failed" msgid="7705795653796174741">"Súkromný priestor sa nepodarilo odstrániť"</string>
    <string name="private_space_unlocked" msgid="9091600948712932046">"Súkromný priestor je odomknutý"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Nastavte zámku obrazovky"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"Ak chcete používať súkromný priestor, nastavte v tomto zariadení zámku obrazovky"</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Nastaviť zámku obrazovky"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Zrušiť"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Zrušiť"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Nastaviť"</string>
    <string name="private_space_setup_title" msgid="2272968244329821450">"Súkromný priestor"</string>
    <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Skryte alebo uzamknite súkromné aplikácie v samostatnom priestore. Zlepšite zabezpečenie použitím vyhradeného účtu Google."</string>
    <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Nastavenie súkromného priestoru"</string>
    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Výber účtu Googlu pre priestor"</b>\n"Používanie vyhradeného účtu pomáha zastaviť zobrazovanie synchronizovaných súborov, fotiek a správ mimo vášho priestoru."</string>
    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Nastavenie zámky"</b>\n"Uzamknite svoj priestor, aby ho iní ľudia nemohli otvoriť."</string>
    <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Inštalácia aplikácií"</b>\n"Súkromný priestor má vlastný Obchod Play, aby ste si mohli ľahko nainštalovať aplikácie."</string>
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Aplikácie vo vašom súkromnom priestore sa nebudú zobrazovať v sekcii Správca povolení, paneli ochrany súkromia ani iných nastaveniach, keď je tento priestor uzamknutý.\n\nSúkromný priestor si nemôžete preniesť do iného zariadenia. Ak ho chcete používať v inom zariadení, musíte si nastaviť iný súkromný priestor.\n\nK vášmu súkromnému priestoru môže získať prístup ktokoľvek, kto pripojí vaše zariadenie k počítaču alebo v ňom nainštaluje škodlivé aplikácie."</string>
    <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>
    <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">"Chcete odomykať súkromný priestor zámkou obrazovky?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"Súkromný priestor môžete odomknúť rovnakým spôsobom ako svoje zariadenie, prípadne môžete vybrať inú zámku"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Používať zámku obrazovky"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Vybrať novú zámku"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"Hotovo!"</string>
    <string name="private_space_access_text" msgid="4433988836344567888">"Súkromný priestor nájdete tak, že prejdete na zoznam aplikácií a potom sa posuniete nadol"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Hotovo"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Súkromný priestor nájdete posunutím nadol"</string>
    <string name="private_space_retry_signin_title" msgid="8090276618867918844">"Prihláste sa"</string>
    <string name="private_space_retry_summary" msgid="1920444015972648774">"Prihláste sa do účtu, ktorý chcete používať so svojím súkromným priestorom"</string>
    <string name="private_space_skip_login_label" msgid="7078019409056628192">"Teraz nie"</string>
    <string name="private_space_continue_login_label" msgid="7779965766333065391">"Pokračovať"</string>
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Vyberte zámku pre súkromný priestor"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"Súkromný priestor môžete odomknúť odtlačkom prsta. Táto možnosť vyžaduje z bezpečnostných dôvodov záložnú zámku."</string>
    <string name="private_space_choose_your_pin_header" msgid="4560802934975898265">"Nastavte PIN pre súkromný priestor"</string>
    <string name="private_space_choose_your_password_header" msgid="7660259341095044434">"Nastavte heslo pre súkromný priestor"</string>
    <string name="private_space_choose_your_pattern_header" msgid="2165607102459936724">"Nastavte vzor pre súkromný priestor"</string>
    <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>
    <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, ktorý chcete používať so súkromným priestorom"</string>
    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Vytvorte si vyhradený účet a pomôžte tak zaistiť, aby sa mimo súkromného priestoru nezobrazovali vaše údaje, 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>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Odstránenie odtlačku <xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Nebudete môcť odomykať pracovný profil, schvaľovať nákupy ani sa prihlasovať do pracovných aplikácií odtlačkom prsta."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Šifrovanie"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Šifrované"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Nastavte zámku obrazovky"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Zvýšte si zabezpečenie tak, že pre toto zariadenie nastavíte PIN, vzor alebo heslo."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Nastaviť zámku obrazovky"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Nastavte zámku obrazovky"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Zvýšte si zabezpečenie tak, že pre toto zariadenie nastavíte PIN, vzor alebo heslo."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Zabezpečenie telefónu"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Odomknutie vyžaduje pridanie odtlačku prsta"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Výber zámky obrazovky"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Výber zámky obrazovky"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Vyberte novú zámku obrazovky"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Vyberte zámku pre pracovné aplikácie"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Vyberte novú pracovnú zámku"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Zlepšite svoje zabezpečenie nastavením dodatočnej zámky obrazovky"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Zvoľte záložnú metódu zámky obrazovky"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Ak zabudnete zámku obrazovky, váš správca IT ju nemôže resetovať."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Nastavte samostatnú pracovnú zámku"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Ak túto zámku zabudnete, požiadajte správcu IT, aby ju resetoval"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Možnosti zámky obrazovky"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Možnosti zámky obrazovky"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Odomykať automatickým potvrdením"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Ak zadáte správny kód PIN s minimálne šiestimi číslicami, odomkne sa automaticky. Je to o niečo menej bezpečné než potvrdenie klepnutím na Enter."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Automatické potvrdenie správneho kódu PIN"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Potvrdzovanie kódu PIN klepnutím na Enter je bezpečnejšie než používanie automatického potvrdenia"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Ak chcete zapnúť automatické potvrdenie, zadajte PIN zariadenia"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Ak chcete vypnúť automatické potvrdenie, zadajte PIN zariadenia"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Zámka obrazovky"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Zámka pracovného profilu"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Žiadna"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Potiahnutie"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Vzor"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Heslo"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Teraz nie"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Aktuálna zámka obrazovky"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Vzor • Odtlačok prsta"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Odtlačok prsta"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Heslo • Odtlačok prsta"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Pokračovať bez odtlačku prsta"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Vzor • Tvár"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Tvár"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Heslo • Tvár"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Pokračovať bez odomknutia tvárou"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Pokračovať bez odtlačku prsta či tváre"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Bez zabezpečenia"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Potiahnutie"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Vzor"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Heslo"</string>
    <string name="unlock_disable_frp_warning_title" msgid="2545569051372893686">"Chcete odstrániť všetky typy odomknutia zariadenia?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Odstrániť ochranu profilu?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Vzor chráni váš telefón v prípade straty alebo krádeže"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Vzor chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Táto akcia tiež odstráni model odtlačku prsta uložený v zariadení. Pomocou odtlačku prsta nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Vzor chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Váš model tváre bude tiež trvale a bezpečne odstránený. Pomocou tváre nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Vzor chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Táto akcia odstráni model odtlačku prsta uložený v zariadení. Váš model tváre bude tiež trvale a bezpečne odstránený. Pomocou tváre ani odtlačku prsta nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"PIN chráni váš telefón v prípade straty alebo krádeže"</string>
    <string name="unlock_disable_frp_warning_content_pin_authbound_keys" msgid="6497861740382402784">"Prídete o uložené údaje, napríklad PIN.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Karty nastavené na bezkontaktné platby budú odstránené.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Peňaženky a ďalšie aplikácie, ktoré vyžadujú odomknutie zariadenia, nemusia správne fungovať."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Táto akcia tiež odstráni model odtlačku prsta uložený v zariadení. Pomocou odtlačku prsta nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_authbound_keys" msgid="8930057076658360799">"Prídete o uložené údaje, ako sú PIN a model odtlačku prsta.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Karty nastavené na bezkontaktné platby budú odstránené.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Peňaženky a ďalšie aplikácie, ktoré vyžadujú odomknutie zariadenia, nemusia správne fungovať."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Váš model tváre bude tiež trvale a bezpečne odstránený. Pomocou tváre nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_authbound_keys" msgid="979399855891561038">"Prídete o uložené údaje, ako sú PIN a model tváre.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Karty nastavené na bezkontaktné platby budú odstránené.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Peňaženky a ďalšie aplikácie, ktoré vyžadujú odomknutie zariadenia, nemusia správne fungovať."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Táto akcia odstráni model odtlačku prsta uložený v zariadení. Váš model tváre bude tiež trvale a bezpečne odstránený. Pomocou tváre ani odtlačku prsta nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint_authbound_keys" msgid="7019955731206729909">"Prídete o uložené údaje, ako sú PIN a modely tváre a odtlačku prsta.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Karty nastavené na bezkontaktné platby budú odstránené.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Peňaženky a ďalšie aplikácie, ktoré vyžadujú odomknutie zariadenia, nemusia správne fungovať."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Heslo chráni váš telefón v prípade straty alebo krádeže"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Heslo chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Táto akcia tiež odstráni model odtlačku prsta uložený v zariadení. Pomocou odtlačku prsta nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Heslo chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Váš model tváre bude tiež trvale a bezpečne odstránený. Pomocou tváre nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Heslo chráni váš telefón v prípade straty alebo krádeže.<xliff:g id="EMPTY_LINE">

</xliff:g>Táto akcia odstráni model odtlačku prsta uložený v zariadení. Váš model tváre bude tiež trvale a bezpečne odstránený. Pomocou tváre ani odtlačku prsta nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Funkcie ochrany zariadenia nebudú fungovať bez vašej zámky obrazovky."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Funkcie ochrany zariadenia nebudú fungovať bez zámky obrazovky.<xliff:g id="EMPTY_LINE">

</xliff:g>Táto akcia tiež odstráni model odtlačku prsta uložený v zariadení. Pomocou odtlačku prsta nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Funkcie ochrany zariadenia nebudú fungovať bez zámky obrazovky.<xliff:g id="EMPTY_LINE">

</xliff:g>Váš model tváre bude tiež trvale a bezpečne odstránený. Pomocou tváre nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Funkcie ochrany zariadenia nebudú fungovať bez zámky obrazovky.<xliff:g id="EMPTY_LINE">

</xliff:g>Táto akcia odstráni model odtlačku prsta uložený v zariadení. Váš model tváre bude tiež trvale a bezpečne odstránený. Pomocou tváre ani odtlačku prsta nebudete môcť overovať v aplikáciách."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Odstrániť"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> odporúča silný kód PIN alebo heslo, bez ktorého nemusí fungovať podľa očakávaní"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> odporúča nový kód PIN alebo heslo, bez ktorého nemusí fungovať podľa očakávaní"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> odporúča nový vzor, PIN alebo heslo, bez ktorého nemusí fungovať podľa očakávaní"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> odporúča novú zámku obrazovky"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Skúste to znova. <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>. z <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g> pokusov."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Vaše dáta budú odstránené"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Ak pri ďalšom pokuse zadáte nesprávny vzor, dáta tohto zariadenia budú odstránené"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Ak pri ďalšom pokuse zadáte nesprávny kód PIN, dáta tohto zariadenia budú odstránené"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Ak pri ďalšom pokuse zadáte nesprávne heslo, dáta tohto zariadenia budú odstránené"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Ak pri ďalšom pokuse zadáte nesprávny vzor, tento používateľ bude odstránený"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Ak pri ďalšom pokuse zadáte nesprávny kód PIN, tento používateľ bude odstránený"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Ak pri ďalšom pokuse zadáte nesprávne heslo, tento používateľ bude odstránený"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Ak pri ďalšom pokuse zadáte nesprávny vzor, váš pracovný profil a jeho dáta budú odstránené"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Ak pri ďalšom pokuse zadáte nesprávny PIN, váš pracovný profil a jeho dáta budú odstránené"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Ak pri ďalšom pokuse zadáte nesprávne heslo, váš pracovný profil a jeho dáta budú odstránené"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Musí mať aspoň # znak}few{Musí mať aspoň # znaky}many{Must be at least # characters}other{Musí mať aspoň # znakov}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Ak používate iba čísla, heslo musí mať aspoň jednu číslicu}few{Ak používate iba čísla, heslo musí mať aspoň # číslice}many{If using only numbers, must be at least # digits}other{Ak používate iba čísla, heslo musí mať aspoň # číslic}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN musí mať aspoň # číslicu}few{PIN musí mať aspoň # číslice}many{PIN must be at least # digits}other{PIN musí mať aspoň # číslic}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN musí obsahovať aspoň # číslicu, pre lepšie zabezpečenie sa však odporúča {minAutoConfirmLen}‑ciferný kód PIN}few{PIN musí obsahovať aspoň # číslice, pre lepšie zabezpečenie sa však odporúča {minAutoConfirmLen}‑ciferný kód PIN}many{PIN must be at least # digits, but a {minAutoConfirmLen}-digit PIN is recommended for added security}other{PIN musí obsahovať aspoň # číslic, pre lepšie zabezpečenie sa však odporúča {minAutoConfirmLen}‑ciferný kód PIN}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Musí mať menej ako # znak}few{Musí mať menej ako # znaky}many{Must be fewer than # characters}other{Musí mať menej ako # znakov}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Musí mať menej ako # číslicu}few{Musí mať menej ako # číslice}many{Must be fewer than # digits}other{Musí mať menej ako # číslic}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Správca zariadenia neumožňuje používať nedávny kód PIN"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Musí obsahovať iba platné znaky"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Musí obsahovať aspoň 1 písmeno}few{Musí obsahovať aspoň # písmená}many{Must contain at least # letters}other{Musí obsahovať aspoň # písmen}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Musí obsahovať aspoň 1 malé písmeno}few{Musí obsahovať aspoň # malé písmená}many{Must contain at least # lowercase letters}other{Musí obsahovať aspoň # malých písmen}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Musí obsahovať aspoň 1 veľké písmeno}few{Musí obsahovať aspoň # veľké písmená}many{Must contain at least # uppercase letters}other{Musí obsahovať aspoň # veľkých písmen}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Musí obsahovať aspoň 1 číslicu}few{Musí obsahovať aspoň # číslice}many{Must contain at least # numerical digits}other{Musí obsahovať aspoň # číslic}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Musí obsahovať aspoň 1 špeciálny symbol}few{Musí obsahovať aspoň # špeciálne symboly}many{Must contain at least # special symbols}other{Musí obsahovať aspoň # špeciálnych symbolov}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Musí obsahovať aspoň 1 znak, ktorý nie je písmeno}few{Musí obsahovať aspoň # znaky, ktoré nie sú písmená}many{Must contain at least # non-letter characters}other{Musí obsahovať aspoň # znakov, ktoré nie sú písmená}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Musí obsahovať aspoň 1 znak, ktorý nie je číslica}few{Musí obsahovať aspoň # znaky, ktoré nie sú číslice}many{Must contain at least # non-numerical characters}other{Musí obsahovať aspoň # znakov, ktoré nie sú číslice}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Správca zariadenia neumožňuje používať nedávne heslo"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Vzostupná, zostupná alebo opakovaná sekvencia čísiel nie je povolená"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Potvrdiť"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Vymazať"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Zámka obrazovky už bola zmenená. Skúste to znova s novou zámkou obrazovky."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Zrušiť"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Ďalej"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Aplikácie na správu zariadenia"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Žiadne aktívne aplikácie"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktívna aplikácia}few{# aktívne aplikácie}many{# active apps}other{# aktívnych aplikácií}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agenty dôvery"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Pred použitím treba nastaviť zámku obrazovky"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Žiadne"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktívny agent dôvery}few{# aktívne agenty dôvery}many{# active trust agents}other{# aktívnych agentov dôvery}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Chcete spárovať so zariadením <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="3047893658902159692">"Potvrďte, že chcete pridať druhú časť audio zariadenia"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Párovací kód Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Zadajte párovací kód a potom stlačte tlačidlo Return alebo Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN obsahuje písmená či symboly"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Obvykle 0000 alebo 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Musí obsahovať 16 číslic"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Tento kód PIN bude možno treba zadať aj na druhom zariadení."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Tento prístupový kľúč možno bude potrebné zadať aj v druhom zariadení."</string>
    <string name="bluetooth_paring_group_msg" msgid="2455293929036668131">"Potvrďte párovanie s audio zariadením"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Povoliť prístup ku kontaktom a histórii hovorov"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Povoliť aj prístup ku kontaktom a histórii hovorov"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Informácie budú použité na účely oznámení hovorov a ďalších funkcií"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nepodarilo sa pripojiť k zariadeniu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dostupné zariadenia"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Pripojiť"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Odpojiť"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Spárovať a pripojiť"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Keď je zapnuté rozhranie Bluetooth, zariadenie môže komunikovať s ostatnými zariadeniami s rozhraním Bluetooth v okolí"</string>
    <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"Keď je zapnuté rozhranie Bluetooth, zariadenie môže komunikovať s ostatnými zariadeniami s rozhraním Bluetooth v okolí. Funkcie, ako sú Quick Share, Nájdi moje zariadenie a poloha zariadenia, využívajú Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Keď je zapnuté rozhranie Bluetooth, zariadenie môže komunikovať s ostatnými zariadeniami s rozhraním Bluetooth v okolí.\n\nNa zlepšenie prostredia zariadenia môžu aplikácie a služby kedykoľvek vyhľadávať zariadenia v okolí, a to aj vtedy, keď je rozhranie Bluetooth vypnuté. Vďaka tomu je napríklad možné zlepšiť funkcie a služby podmienené polohou. Môžete to zmeniť v nastaveniach vyhľadávania rozhraním Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"Keď je zapnuté rozhranie Bluetooth, zariadenie môže komunikovať s ostatnými zariadeniami s rozhraním Bluetooth v okolí. Funkcie, ako sú Quick Share, Nájdi moje zariadenie a poloha zariadenia, využívajú Bluetooth.\n\nAplikácie a služby môžu kedykoľvek vyhľadávať zariadenia v okolí, a to aj vtedy, keď je rozhranie Bluetooth vypnuté. Môžete to napríklad využiť, keď chcete zlepšiť funkcie a služby založené na polohe. Môžete to zmeniť v nastaveniach vyhľadávania zariadení Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Zmeniť"</string>
    <string name="device_details_title" msgid="1155622417516195481">"O zariadení"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Nastavenia klávesnice"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Adresa Bluetooth zariadenia: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Adresa zariadenia Bluetooth:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Zabudnúť zariadenie?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Odstrániť spojenie"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Chcete aplikáciu odpojiť?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"<xliff:g id="APP_NAME">%1$s</xliff:g> sa už nebude pripájať k zariadeniu <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Experimentálne. Zlepší kvalitu zvuku."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Zabudnúť zariadenie"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Odpojiť aplikáciu"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maximálny počet pripojených zvukových zariadení Bluetooth"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Výber maximálneho počtu pripojených zvukových zariadení Bluetooth"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Denník ladenia zásobníka NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Zvýšiť úroveň zapisovania zásobníka NFC"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Podrobný denník dodávateľa pre ladenie NFC"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Zahrnúť ďalšie denníky dodávateľov špecifické pre zariadenia do hlásení chýb, ktoré môžu obsahovať súkromné informácie"</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Nefiltrovaný denník NCI NFC"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Zaznamenávať podrobné pakety NFC, ktoré môžu obsahovať súkromné informácie"</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Chcete zariadenie reštartovať?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Podrobné zaznamenávanie údajov NFC je určené iba na účely vývoja. Ďalšie údaje NFC sú zahrnuté v hláseniach chýb, ktoré môžu obsahovať súkromné informácie. Ak chcete toto nastavenie zmeniť, reštartujte zariadenie."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Reštartovať"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Prenos"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"zrkadlenie"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Povoliť bezdrôtové zobrazenie"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"V okolí sa nenašli žiadne zariadenia."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Prepája sa"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Pripojené"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Používa sa"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nie je k dispozícii"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Možnosti bezdrôtového zobrazenia"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Odstrániť"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Hotovo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Názov"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Prihlásiť sa"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Otvoriť web"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Zostáva <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Platí do <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> chce zapnúť Wi‑Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> chce vypnúť Wi‑Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Overovať bajtkód laditeľných aplikácií"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Povoliť nástroju ART overovať bajtkód laditeľných aplikácií"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Zobrazovať frekvenciu obnovenia"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Zobrazovať aktuálnu frekvenciu obnovenia obrazovky"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Zobrazovať pomer HDR a SDR"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Zobrazovať aktuálny pomer HDR a SDR"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Vyžadovať odomknutie zariadenia pre NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Pripravené na prenos obsahu aplikácie prostredníctvom NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Vypnuté"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nedostupné, pretože technológia NFC je vypnutá"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Keď je táto funkcia zapnutá a podržíte zariadenia blízko pri sebe, môžete odosielať obsah aplikácií do iného zariadenia s technológiou NFC. Môžete napríklad odosielať webové stránky, videá YouTube, kontakty a ďalší obsah.\n\nStačí priložiť zariadenia k sebe (obyčajne zadnými stranami) a potom klepnúť na obrazovku. Aplikácia určí, aký obsah sa prenesie."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi‑Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Používať Wi‑Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Nastavenia Wi‑Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Vybrať sieť Wi‑Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Prebieha zapínanie siete Wi‑Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Prebieha vypínanie Wi‑Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Chyba"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"V tejto krajine nie je pásmo 5 GHz k dispozícii"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Režim v lietadle"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Upozorňovať na verejné siete"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Upozorniť na dostupnosť kvalitnej verejnej siete"</string>
    <string name="wifi_allow_wep_networks" msgid="8772342993235292010">"Povoliť siete WEP"</string>
    <string name="wifi_allow_wep_networks_summary" msgid="3033397893296724615">"WEP je starší bezpečnostný protokol s nižšou úrovňou zabezpečenia"</string>
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow" msgid="6298103289728210026">"Váš operátor nepovoľuje siete WEP, pretože sú menej zabezpečené"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Zapínať Wi‑Fi automaticky"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Zapnúť Wi-Fi v dosahu kvalitných uložených sietí, napríklad vašej domácej siete"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nedostupné, pretože funkcia polohy je vypnutá. Zapnúť funkciu "<annotation id="link">"polohy"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Inštalovať certifikáty"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Aplikácie a služby môžu kedykoľvek vyhľadávať siete Wi-Fi aj vtedy, keď je pripojenie Wi-Fi vypnuté, aby tak zlepšovali presnosť pri určovaní polohy. Môžete to využiť napríklad pri zlepšovaní funkcií a služieb podmienených polohou. Môžete to zmeniť v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastaveniach vyhľadávania sietí Wi‑Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Ak chcete spresniť určovanie polohy, zapnite vyhľadávanie sietí Wi‑Fi v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastaveniach vyhľadávania sietí Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automaticky prepnúť na mobilné dáta"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Používať mobilné dáta, keď Wi‑Fi nemá prístup k internetu. Za využité dáta vám môžu byť účtované poplatky."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Pridanie siete"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Nastavenia Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi sa automaticky znova zapne"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi sa automaticky znova nezapne"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Ak chcete zobraziť dostupné siete, zapnite Wi‑Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Vyhľadávajú sa siete…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nemáte povolenie na zmenu siete Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Zapnúť vyhľadávanie sietí Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Ak chcete automaticky zapínať Wi-Fi, najprv zapnite vyhľadávanie sietí Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Vyhľadávanie sietí Wi-Fi umožňuje aplikáciám a službám kedykoľvek vyhľadávať siete Wi‑Fi, a to aj vtedy, keď je funkcia Wi-Fi vypnutá. Dajú sa tak napríklad zlepšiť funkcie a služby podmienené polohou."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Zapnúť"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Vyhľadávanie sietí Wi‑Fi je zapnuté"</string>
    <string name="wifi_settings_warning_wep_network" msgid="2655077013800385646">"Táto sieť používa starší bezpečnostný protokol s nižšou úrovňou zabezpečenia"</string>
    <string name="wifi_settings_wep_networks_blocked_title" msgid="8337700496544833669">"Sieť <xliff:g id="NAME">%1$s</xliff:g> je blokovaná"</string>
    <string name="wifi_settings_wep_networks_summary_toggle_off" msgid="1113138364046142949">"Táto sieť používa starší bezpečnostný protokol WEP s nižšou úrovňou zabezpečenia. Ak sa chcete aj napriek tomu pripojiť, môžete povoliť siete WEP."</string>
    <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>
    <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>
    <string name="wifi_ssid" msgid="2713062130735103151">"Názov siete"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Zadajte SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Zabezpečenie"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skrytá sieť"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Ak váš smerovač nevysiela ID určitej siete, ale chcete sa k nej pripojiť v budúcnosti, môžete ju nastaviť ako skrytú.\n\nMôže tým vzniknúť bezpečnostné riziko, pretože váš telefón bude pravidelne vysielať signál siete, aby ju našiel.\n\nNastavením danej siete ako skrytej nezmeníte nastavenia smerovača."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Sila signálu"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Stav"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Rýchlosť posielania dát"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Rýchlosť prijímania dát"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Rýchlosť pripojenia"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekvencia"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Adresa IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Uložené prostredníctvom siete"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Poverenia: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Metóda EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Druhá fáza overenia"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certifikát CA"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimálna verzia protokolu TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Stav online certifikátu"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Doména"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certifikát používateľa"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identita"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonymná identita"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Heslo"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Zobrazovať heslo"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Pásmo 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Preferuje sa pásmo 5 GHz"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Nastavenia adresy IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Ochrana súkromia"</string>
    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"MAC"</string>
    <string name="wifi_privacy_device_name_settings" msgid="3699130177041345275">"Názov zariadenia"</string>
    <string name="wifi_privacy_send_device_name_toggle_title" msgid="1228107313152880073">"Odoslať názov zariadenia"</string>
    <string name="wifi_privacy_send_device_name_toggle_summary" msgid="5995365836332817655">"Zdieľať názov tohto zariadenia so sieťou"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Odber"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Zobrazenie alebo zmena odberu"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Náhodná adresa MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Pridať zariadenie"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Ak chcete pridať zariadenie do siete <xliff:g id="SSID">%1$s</xliff:g>, vycentrujte QR kód nižšie"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Naskenovanie QR kódu"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Ak sa chcete pripojiť k sieti <xliff:g id="SSID">%1$s</xliff:g>, vycentrujte QR kód nižšie"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Pripojte sa k sieti Wi‑Fi naskenovaním QR kódu"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Zdieľanie Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Ak sa chcete pripojiť k sieti <xliff:g id="SSID">%1$s</xliff:g>, naskenujte tento QR kód iným zariadením"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Ak sa chcete pripojiť k sieti <xliff:g id="SSID">%1$s</xliff:g>, naskenujte tento QR kód"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Skúste to znova. Ak problém pretrváva, kontaktujte výrobcu zariadenia."</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Vyskytol sa problém"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Skontrolujte, či je zariadenie zapojené, nabité a zapnuté"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Skontrolujte, či je zariadenie zapojené, nabité a zapnuté. Ak problém pretrváva, kontaktujte výrobcu zariadenia."</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Toto zariadenie nepodporuje pridanie siete <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Skúste presunúť zariadenie bližšie k prístupovému bodu Wi-Fi alebo smerovaču"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Skontrolujte heslo a skúste to znova"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontaktujte výrobcu zariadenia"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Skontrolujte pripojenie a skúste to znova"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Výber siete"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Ak chcete pripojiť svoje zariadenie, vyberte sieť"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Chcete pridať toto zariadenie do siete <xliff:g id="SSID">%1$s</xliff:g>?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi sa zdieľa so zariadením"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Pridať ďalšie zariadenie"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Vybrať inú sieť"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Zariadenie sa nepodarilo pridať"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Našlo sa zariadenie"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"S týmto zariadením sa zdieľa pripojenie Wi‑Fi…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Pripája sa…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Zdieľanie hotspotu"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Ste to vy?"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Heslo siete Wi‑Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Heslo hotspotu: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automaticky pripájať"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Povoliť pripojenie k tejto sieti, keď je v dosahu"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Pridať zariadenie"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Pridajte zariadenie do tejto siete pomocou QR kódu"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR kód nie je platný formát"</string>
    <string name="retry" msgid="7542103800274026915">"Skúsiť znova"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Zdieľať s ostatnými používateľmi zariadenia"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nezmenené)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Vyberte"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Bolo pridaných viacero certifikátov)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Použiť certifikáty systému"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Neposkytovať"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Dôverovať od prvého použitia"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Názov siete je príliš dlhý."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Je potrebné zadať doménu."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Vyžaduje sa certifikát."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> chce zapnúť vyhľadávanie sietí (z dôvodu dosiahnutia vyššej presnosti určovania polohy aj z iných dôvodov) a hľadať siete aj v prípade, že je vypnutý modul Wi‑Fi.\n\nChcete túto možnosť povoliť všetkým aplikáciám, ktoré chcú vyhľadávať siete?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Neznáma aplikácia chce na zlepšenie presnosti určovania polohy a ďalšie účely zapnúť vyhľadávanie sietí, aj keď je vypnutá funkcia Wi‑Fi.\n\nChcete to povoliť všetkým aplikáciám, ktoré chcú vyhľadávať siete?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Povoliť"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Zamietnuť"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Táto sieť nemá prístup k internetu. Zachovať pripojenie?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Niektoré aplikácie a služby nemusia fungovať z dôvodu obmedzeného pripojenia. Chcete sieť napriek tomu použiť?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Nabudúce sa na túto sieť nepýtať"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi‑Fi nie je pripojené k internetu"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Ak máte slabé pripojenie Wi‑Fi, môžete prepnúť na mobilnú sieť. Za využité dáta vám však môžu byť účtované poplatky."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Prepnúť na mobilné dáta"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Ďalej používať Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Viac už nezobrazovať"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Pripojiť"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Pripojené k sieti <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Pripája sa…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Nepodarilo sa pripojiť k sieti"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Sieť nie je v dosahu"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Odstrániť"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Upraviť"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Uložiť"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Nepodarilo sa uložiť sieť"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Zrušiť"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Odstrániť sieť?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 sieť}few{# siete}many{# networks}other{# sietí}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 odber}few{# odbery}many{# subscriptions}other{# odberov}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 sieť a odber}few{# siete a odbery}many{# networks &amp; subscriptions}other{# sietí a odberov}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Adresa MAC zariadenia"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Náhodná adresa MAC"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Náhodná adresa MAC (naposledy použitá)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Podrobnosti siete"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska podsiete"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Typ"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Adresy IPv6"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Podrobnosti o zariadení s hotspotom"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Zdroj internetu"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi‑Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Mobilné dáta"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> – nabíja sa"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Pripojenie cez hotspot"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Sila pripojenia"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Uložené siete"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Odbery"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Ostatné siete"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Zadajte platnú adresu IP."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Zadajte platnú adresu brány."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Zadajte platnú adresu DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Zadajte dĺžku sieťovej predpony v rozsahu 0 až 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"1. systém DNS (pokiaľ nie je prepísaný súkromným)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"2. systém DNS (pokiaľ nie je prepísaný súkromným)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Brána"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Dĺžka sieťovej predpony"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Vyhľadávanie zariadení"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Hľadá sa…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Premenovať zariadenie"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Partnerské zariadenia"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Zapamätané skupiny"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Nepodarilo sa pripojiť."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Premenovanie zariadenia zlyhalo."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Odpojiť?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Ak sa odpojíte, ukončíte spojenie so zariadením <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Ak sa odpojíte, ukončíte spojenie so zariadením <xliff:g id="PEER_NAME">%1$s</xliff:g> a ďalšími zariadeniami (<xliff:g id="PEER_COUNT">%2$s</xliff:g>)."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Zrušiť pozvánku?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Chcete zrušiť pozvánku na spojenie s klientom <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Odstrániť túto skupinu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Hotspot Wi‑Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"S inými zariadeniami sa nezdieľa internet ani obsah"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Nie je nastavené žiadne heslo"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Názov hotspotu"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Heslo hotspotu"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Hotspot automaticky vypínať"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Keď nie sú pripojené žiadne zariadenia"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Rozšíriť kompatibilitu"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Pomáha ostatným zariadeniam nájsť tento hotspot. Znižuje rýchlosť pripojenia hotspotu."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Pomáha ostatným zariadeniam nájsť tento hotspot. Zvýši sa spotreba batérie."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Rýchlosť a kompatibilita"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz / Kompatibilné s väčšinou zariadení"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz – kompatibilný s mnohými zariadeniami"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz – kompatibilný s niektorými zariadeniami"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 a 5 GHz / Kompatibilné s väčšinou zariadení"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Vyberte frekvenciu hotspotu. Frekvencia ovplyvňuje rýchlosť pripojenia a typy zariadení, ktoré hotspot dokážu nájsť."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Preferovaná frekvencia"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Nižšie rýchlosti. Je kompatibilný s väčšinou zariadení."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Vysoké rýchlosti. Je kompatibilný s mnohými zariadeniami."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 a 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Vysoké rýchlosti. Tento dvojpásmový hotspot je kompatibilný s väčšinou zariadení."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Najvyššie rýchlosti. Je kompatibilný s niekoľkými zariadeniami."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Nie je k dispozícii vo vašej krajine alebo regióne"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Ak vaša preferovaná frekvencia nie je k dispozícii, hotspot môže použiť inú. Keď zmeníte frekvenciu, môžu sa zmeniť aj nastavenia zabezpečenia hotspotu."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Nie je k dispozícii v pásme 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Keď zmeníte frekvenciu hotspotu, môžu sa zmeniť aj nastavenia zabezpečenia"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Okamžitý hotspot"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Zapnuté"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Vypnuté"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Prebieha zapínanie hotspotu..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Prebieha vypínanie hotspotu..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Zdieľanie dátového pripojenia nie je k dispozícii"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Podrobnosti vám poskytne operátor"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"Sieť <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktívna"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Chcete túto sieť uložiť?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Ukladá sa…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Uložené"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Nie je možné uložiť. Skúste to znova."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Chcete siete uložiť?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Ukladajú sa siete (<xliff:g id="NUMBER">%d</xliff:g>)…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Siete boli uložené"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Volanie cez Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Rozšírte hovory pomocou volania cez Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Zapnutie volania cez Wi‑Fi na rozšírenie dostupnosti"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Predvoľba volania"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Predvoľba volania"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Predvoľby roamingu"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Predvoľby roamingu"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi‑Fi"</item>
    <item msgid="8622872038388687383">"Mobilné dáta"</item>
    <item msgid="3027927219952052398">"Len Wi‑Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi‑Fi"</item>
    <item msgid="7566603075659706590">"Mobilné dáta"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"V prípade nedostupnosti siete Wi‑Fi použiť mobilnú sieť"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"V prípade nedostupnosti mobilnej siete použiť Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Volanie cez Wi‑Fi. Keď sa Wi‑Fi preruší, hovor sa ukončí."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Ak je zapnuté volanie cez Wi‑Fi, váš telefón môže smerovať volania cez siete Wi‑Fi alebo cez sieť vášho operátora. Závisí to od vašich preferencií a od toho, ktorý signál je silnejší. Pred zapnutím tejto funkcie kontaktujte svojho operátora a informujte sa o poplatkoch a ďalších podrobnostiach.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Tiesňová adresa"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Používa sa ako vaša poloha pri tiesňových volaniach cez Wi‑Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Ďalšie informácie"</annotation>" o funkciách súkromného DNS"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Zapnuté"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivujte volanie cez Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Zapnite volanie cez Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Odpojené od siete <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Zvuk a vibrácie"</string>
    <string name="account_settings" msgid="255404935489127404">"Účty"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Účty pracovných profilov – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Účty osobných profilov"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Klonovanie účtov profilov"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Pracovný účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Osobný účet – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Hľadať"</string>
    <string name="display_settings" msgid="7197750639709493852">"Obrazovka"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automaticky otáčať obrazovku"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Vypnuté"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Zapnuté"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Zapnuté – podľa tváre"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Rozpoznávanie tváre"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Ďalšie informácie o automatickom otáčaní"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Rozlíšenie obrazovky"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Vysoké rozlíšenie"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Plné rozlíšenie"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Plné rozlíšenie využíva vo väčšej miere batériu. Ak rozlíšenie prepnete, niektoré aplikácie sa môžu reštartovať."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Vybrané"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Farby"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Prirodzené"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Zosilnené"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Sýte"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptívne"</string>
    <string name="brightness" msgid="6216871641021779698">"Úroveň jasu"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Adaptácia jasu"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Jas obrazovky sa automaticky prispôsobí prostrediu a aktivitám. Ručným posúvaním posúvača učíte adaptáciu jasu svoje preferované nastavenia."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Zapnuté"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Vypnuté"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Zobrazenie vyváženia bielej"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Pokračovať v používaní aplikácií po zložení"</string>
    <string name="disable_game_default_frame_rate_title" msgid="3712908601744143753">"Zakázať predvolenú snímkovú frekvenciu hier"</string>
    <string name="disable_game_default_frame_rate_summary" msgid="4436762704707434225">"Zakážte obmedzenie maximálnej snímkovej frekvencie hier na úrovni <xliff:g id="FRAME_RATE">%1$d</xliff:g> Hz."</string>
    <string name="peak_refresh_rate_title" msgid="2056355754210341011">"Plynulý obraz"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Automaticky zvýši frekvenciu obnovenia v prípade určitého obsahu až na <xliff:g id="ID_1">%1$d</xliff:g> Hz. Zvýši sa spotreba batérie."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Vynútiť vrcholovú frekvenciu obnovenia"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Najvyššia frekvencia obnovenia zlepšujúca dotykovú odozvu a kvalitu animácií. Zvýši sa spotreba batérie."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Vnímavá obrazovka"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Vyžaduje sa prístup k fotoaparátu"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Vnímavá obrazovka vyžaduje prístup k fotoaparátu. Klepnutím spravujte povolenia služieb prispôsobenia zariadenia."</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Spravovať povolenia"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Zabrániť vypnutiu obrazovky, keď sa na ňu pozeráte"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Vnímavá obrazovka pomocou prednej kamery zistí, či sa používateľ pozerá na obrazovku. Spúšťa sa v zariadení a snímky sa nikdy neukladajú ani neodosielajú Googlu."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Zapnúť vnímavú obrazovku"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Nechať obrazovku zapnutú, keď ju pozeráte"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Dlhší časový limit obrazovky viac spotrebúva batériu."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera je uzamknutá"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Ak chcete používať rozpoznávanie tváre, kamera musí byť odomknutá"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Vnímavá obrazovka vyžaduje odomknutý fotoaparát"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Rozpoznávanie tváre vyžaduje prístup k fotoaparátu. Klepnutím spravujte povolenia služieb prispôsobenia zariadenia."</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Spravovať povolenia"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nočný režim"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Nočný režim zafarbí obrazovku do žltohneda. Obrazovka bude pri tlmenom osvetlení menej rušivá, bude sa vám lepšie čítať a budete lepšie zaspávať."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Plán"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Nikdy"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Zapnuté vo vybranom čase"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Od západu do východu slnka"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Čas začatia"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Čas ukončenia"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intenzita"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nikdy sa automaticky nezapne"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Zapne sa automaticky o <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Zapnúť automaticky pri západe slnka"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nikdy sa automaticky nevypne"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Vypne sa automaticky o <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Vypne sa automaticky pri východe slnka"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nočný režim nie je zapnutý"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Na určenie časov západu a východu slnka je potrebná poloha zariadenia."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Nastavenia polohy"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Zapnúť"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Vypnúť"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Zapnúť do východu slnka"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Vypnúť do západu slnka"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Tmavý režim"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Plán"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nikdy"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Od západu do východu slnka"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Vo vybranom čase"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Zapne sa pri večierke"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Stav"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nikdy sa automaticky nezapne"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Zapnúť automaticky pri západe slnka"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Zapne sa automaticky o <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Zapne sa automaticky pri večierke"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nikdy sa automaticky nevypne"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Vypne sa automaticky pri východe slnka"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Vypne sa automaticky o <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Vypne sa automaticky po večierke"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tmavý motív na niektorých obrazovkách používa čierne pozadie a predlžuje tak výdrž batérie. Plány tmavého motívu sa zapnú až po vypnutí obrazovky."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tmavý motív sa momentálne riadi plánom režimu večierky"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Nastavenia režimu večierky"</string>
    <string name="even_dimmer_display_title" msgid="8589063452814896327">"Ešte tmavšie"</string>
    <string name="even_dimmer_display_summary" msgid="120301078873242172">"Umožnite zariadeniu stmaviť sa viac ako zvyčajne"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Časový limit obrazovky"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"<xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> nečinnosti"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nenastavené"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Tapeta"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Tapeta a štýl"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Domov, uzamknutá obrazovka"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Zmeniť tapetu"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Prispôsobte si obrazovku"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Vybrať tapetu"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Prispôsobenie telefónu"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Vyskúšajte rôzne štýly, tapety atď."</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Šetrič obrazovky"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"šetrič obrazovky"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nedostupné, pretože je zapnutý režim večierky"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Používať šetrič obrazovky"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Pri nabíjaní alebo v doku"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"V doku alebo pri nabíjaní"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Pri nabíjaní"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Pri vložení do doku"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nikdy"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Zapnuté / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Vypnuté"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Čas spustenia"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Prebudiť zdvihnutím"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Ambientné zobrazenie"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kedy zobrazovať"</string>
    <string name="doze_title" msgid="1523090408230862316">"Prebudiť obrazovku pri upozorneniach"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Zapnúť tmavú obrazovku pri nových upozorneniach"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Vždy zobrazovať čas a údaje"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Zvýšená spotreba batérie"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Tučný text"</string>
    <string name="title_font_size" msgid="570613010306330622">"Veľkosť písma"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Zväčšite alebo zmenšite text"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Nastavenia zámky SIM karty"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Zámka SIM karty"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Uzamknúť SIM kartu"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Zmeniť PIN SIM karty"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"Kód PIN SIM karty"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Uzamknite SIM kartu"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Odomknite SIM kartu"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Starý kód PIN SIM karty"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nový kód PIN SIM karty"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Potvrďte nový kód PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"Kód PIN SIM karty"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Zadajte PIN so 4 až 8 číslicami"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Kódy PIN sa nezhodujú"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"Kód PIN SIM karty bol zmenený."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Kód PIN sa nedá deaktivovať."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Kód PIN sa nedá aktivovať."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Zrušiť"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Používať <xliff:g id="CARRIER">%1$s</xliff:g> na mobilné dáta?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Používate mobilné dáta od operátora <xliff:g id="CARRIER2_0">%2$s</xliff:g>. Ak prepnete na <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> sa už nebude používať na mobilné dáta."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Používať <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Aktualizovať pref. SIM kartu?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je jediná SIM karta v zariadení. Chcete ju použiť na mobilné dáta, hovory a správy SMS?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Zlepšiť pokrytie mob. dátami?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Povoľte svojmu zariadeniu automaticky prepínať na mobilné dáta operátora <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g>, keď má lepšiu dostupnosť."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Vaša organizácia môže vidieť hovory, správy a sieťovú premávku."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Nesprávny kód PIN SIM karty. Teraz musíte kontaktovať svojho operátora, aby vám odomkol zariadenie."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Nesprávny kód PIN SIM karty. Zostáva vám # pokus, potom budete musieť požiadať svojho operátora o odomknutie zariadenia.}few{Nesprávny kód PIN SIM karty. Zostávajú vám # pokusy.}many{Incorrect SIM PIN code, you have # remaining attempts.}other{Nesprávny kód PIN SIM karty. Zostáva vám # pokusov.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Nesprávny kód PIN SIM karty. Zostáva vám jeden pokus, inak budete musieť kontaktovať operátora, aby vám odomkol zariadenie."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Operácia kódu PIN SIM karty zlyhala!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Aktualizácie systému"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Verzia Androidu"</string>
    <string name="security_patch" msgid="4071756145347865382">"Aktualizácia zabezpečenia Androidu"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Hardvérová verzia"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Rok výroby"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID zariadenia"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Verzia základného pásma"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Verzia jadra"</string>
    <string name="build_number" msgid="9009733242117579826">"Číslo zostavy"</string>
    <string name="module_version" msgid="1787518340082046658">"Aktualizácia systému Google Play"</string>
    <string name="battery_info" msgid="7873528123969546728">"Informácie o batérii"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nie je k dispozícii"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Priestor"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Ukladací priestor a vyrovnávacia pamäť"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Nastavenia úložiska"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (slot na sim kartu <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (<xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>. slot na SIM kartu)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (<xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>. slot na SIM kartu) (hlavný)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Zobrazte výberom uloženej siete"</string>
    <string name="status_imei" msgid="5719752369250485007">"IMEI"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"IMEI SV"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Verzia PRL"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (slot na SIM kartu <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (slot na SIM kartu <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (hlavný)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Zapnuté"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Vypnuté"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Typ mobilnej dátovej siete"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Typ mobilnej hlasovej siete"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informácie o operátorovi"</string>
    <string name="status_data_state" msgid="525196229491743487">"Stav mobilnej siete"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Stav služby"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Sila signálu"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Sieť"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Adresa MAC siete Wi‑Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Adresa MAC siete Wi‑Fi zariadenia"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Adresa Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Sériové číslo"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Dĺžka prevádzky"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Dátum výroby"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Dátum prvého použitia"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Počet cyklov"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Nedostupné"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Prebieha výpočet..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Premenovať"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Pripojiť"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Odpojiť"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formátovať SD kartu ako prenosné úložisko"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formátovať kartu"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Naformátovať ako prenosné"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formátovať"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrovať dáta"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Odstrániť záznam"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Nastaviť"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Uvoľniť miesto"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Spravovať úložisko"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Uvoľnite priestor"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Spravujte a uvoľnite priestor v aplikácii Files"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Ďalší používatelia"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"Úložisko (<xliff:g id="NAME">%1$s</xliff:g>) je pripojené"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Úložisko (<xliff:g id="NAME">%1$s</xliff:g>) sa nepodarilo pripojiť"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Úložisko (<xliff:g id="NAME">%1$s</xliff:g>) bolo bezpečne odpojené"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Úložisko (<xliff:g id="NAME">%1$s</xliff:g>) sa nepodarilo bezpečne odpojiť"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Premenujte úložisko"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Toto úložisko <xliff:g id="NAME_0">^1</xliff:g> je poškodené. \n\nAk chcete používať toto úložisko (<xliff:g id="NAME_1">^1</xliff:g>), musíte ho najprv nastaviť."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Túto SD kartu môžete naformátovať a potom do nej ukladať fotky, videá, hudbu aj ďalší obsah a získavať k nim prístup v iných zariadeniach. \n\n"<b>"Všetky údaje na tejto SD karte budú vymazané."</b>" \n\n"<b>"Pred formátovaním"</b>" \n\n"<b>"Zálohujte si fotky aj ostatné médiá."</b>" \nPresuňte svoje mediálne súbory do alternatívneho úložiska v tomto zariadení alebo ich preneste do počítača pomocou kábla USB. \n\n"<b>"Zálohujte aplikácie"</b>" \nVšetky aplikácie na tomto úložisku <xliff:g id="NAME">^1</xliff:g> budú odinštalované a ich údaje budú vymazané. Ak si chcete tieto aplikácie ponechať, presuňte ich do iného úložiska v zariadení."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Keď toto úložisko <xliff:g id="NAME_0">^1</xliff:g> odpojíte, prestanú fungovať aplikácie, ktoré sú v ňom uložené. Mediálne súbory nebudú dostupné, kým ho opäť nepripojíte."</b>" \n\nToto úložisko <xliff:g id="NAME_1">^1</xliff:g> je naformátované tak, aby fungovalo iba v tomto zariadení."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Ak chcete použiť aplikácie, fotky a údaje, ktoré obsahuje úložisko <xliff:g id="NAME">^1</xliff:g>, opätovne ho vložte. \n\nAk zariadenie nemáte k dispozícii, môžete vybrať možnosť odstránenia záznamu tohto úložiska. \n\nAk vyberiete možnosť odstránenia záznamu, všetky údaje na danom zariadení sa navždy stratia. \n\nAplikácie môžete neskôr opätovne nainštalovať, no ich údaje uložené na tomto zariadení budú stratené."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Odstrániť úložisko <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Všetky aplikácie, fotky a údaje uložené v tomto úložisku (<xliff:g id="NAME">^1</xliff:g>) budú navždy odstránené."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Systém obsahuje súbory používané na fungovanie Androidu verzie <xliff:g id="VERSION">%s</xliff:g>."</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"V režime pre hostí nemôžete formátovať SD karty"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formátuje sa úložisko <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Počas formátovania úložisko <xliff:g id="NAME">^1</xliff:g> neodoberajte."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"Úložisko <xliff:g id="NAME">^1</xliff:g> bolo naformátované"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Presuňte aplikáciu <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Presun aplikácie <xliff:g id="APP">^1</xliff:g> a jej údajov do úložiska <xliff:g id="NAME_0">^2</xliff:g> bude trvať iba chvíľu. Aplikáciu budete môcť použiť až po jej presune. \n\nÚložisko <xliff:g id="NAME_1">^2</xliff:g> počas presunu neodoberajte."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Ak chcete preniesť dáta, musíte odomknúť používateľa <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Presúva sa aplikácia <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Úložisko <xliff:g id="NAME">^1</xliff:g> počas presunu neodoberajte. \n\nAplikácia <xliff:g id="APP">^2</xliff:g> bude v tomto zariadení k dispozícii až po dokončení presunu."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Ako budete používať zariadenie <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Alebo"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formátovať SD kartu ako prenosné úložisko"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Ukladajte fotky, videá, hudbu aj ďalší obsah a získavajte k nim prístup v iných zariadeniach. &lt;a href=https://support.google.com/android/answer/12153449&gt;Ďalšie informácie o nastavení SD karty&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formátovať"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Nastaviť neskôr"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formátovať úložisko <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Ak chcete ukladať aplikácie, súbory a médiá, musíte úložisko <xliff:g id="NAME_0">^1</xliff:g> naformátovať. \n\nFormátovaním vymažete existujúci obsah v úložisku <xliff:g id="NAME_1">^2</xliff:g>. Ak nechcete prísť o obsah, zálohujte ho na iné úložisko <xliff:g id="NAME_2">^3</xliff:g> alebo zariadenie."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Toto úložisko <xliff:g id="NAME_0">^1</xliff:g> musíte naformátovať, aby ste na doň mohli ukladať fotky, videá, hudbu a ďalší obsah. \n\nFormátovaním vymažete existujúci obsah úložiska <xliff:g id="NAME_1">^2</xliff:g>. Ak oň nechcete prísť, zálohujte ho do iného úložiska <xliff:g id="NAME_2">^3</xliff:g> alebo zariadenia."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formátovať: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Presunúť obsah do úložiska <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"V priebehu prenosu:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Neodoberajte zariadenie <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Niektoré aplikácie nebudú fungovať"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Presunúť obsah"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Presunúť obsah neskôr"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Presúva sa obsah…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Úložisko <xliff:g id="NAME">^1</xliff:g> je pomalé"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Úložisko <xliff:g id="NAME_0">^1</xliff:g> môžete používať aj naďalej, môže však byť pomalé. \n\nAplikácie uložené v úložisku <xliff:g id="NAME_1">^2</xliff:g> nemusia fungovať správne a prenos obsahu môže trvať dlho. \n\nZvážte použitie rýchlejšieho úložiska <xliff:g id="NAME_2">^3</xliff:g> alebo využite namiesto toho jednotku <xliff:g id="NAME_3">^4</xliff:g> ako prenosné úložisko."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Začať odznova"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Ďalej"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"<xliff:g id="NAME">^1</xliff:g> môžete začať používať"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"<xliff:g id="NAME">^1</xliff:g> môžete začať používať"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"<xliff:g id="NAME">^1</xliff:g> môžete začať používať"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Stav batérie"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Nabitie batérie"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Spoločné"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Spoločné nastavenia"</string>
    <string name="satellite_setting" msgid="706846910912477125">"Správy cez satelit"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Prístupové body"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Upraviť prístupový bod"</string>
    <string name="apn_add" msgid="9069613192201630934">"Pridanie prístupového bodu"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nenastavené"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Nenastavené"</string>
    <string name="apn_name" msgid="6677695784108157953">"Názov"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Názov prístupového bodu"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy server"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Používateľské meno"</string>
    <string name="apn_password" msgid="7435086635953953029">"Heslo"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy server systému MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Port systému MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Typ overenia"</string>
    <string name="apn_type" msgid="1835573305077788773">"Typ názvu prístupového bodu"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokol APN pre roaming"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Zapnúť / vypnúť APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"Prístupový bod zapnutý"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"Prístupový bod vypnutý"</string>
    <string name="bearer" msgid="3231443241639159358">"Nositeľ"</string>
    <string name="network_type" msgid="748590707422733595">"Typ siete"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Neurčený"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Typ MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Hodnota MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Odstrániť názov prístupového bodu (APN)"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nový prístupový bod"</string>
    <string name="menu_save" msgid="6611465355127483100">"Uložiť"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Zrušiť"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_duplicate_apn_entry" msgid="7792928408935276618">"Duplicitný vstup názvu prístupového bodu."</string>
    <string name="error_name_empty" msgid="1258275899283079142">"Pole Meno nemôže byť prázdne."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Názov prístupového bodu (APN) nemôže byť prázdny."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Pole MCC musí obsahovať 3 číslice."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Pole MNC musí obsahovať 2 alebo 3 číslice."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operátor zakázal pridávanie názvov prístupového bodu typu %s."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"Pole MMSC musí byť platné."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Prebieha obnovovanie predvolených nastavení názvu prístupového bodu (APN)."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Resetovať na predvolené"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Predvolené nastavenia APN boli obnovené."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Možnosti resetovania"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Resetovať nastavenia mobilnej siete"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Týmto resetujete všetky nastavenia mobilnej siete"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Resetovať nastavenia mobilnej siete?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Resetovať rozhranie Bluetooth a pripojenie Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Týmto sa resetujú všetky nastavenia rozhrania Bluetooth a pripojenia Wi‑Fi. Túto akciu nemôžete vrátiť späť."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Resetovať"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth a Wi‑Fi boli resetované"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Vymazať eSIM karty"</string>
    <string name="reset_esim_desc" msgid="6125192435907740751">"Týmto sa nezruší vaša mobilná tarifa. Ak chcete náhradnú SIM kartu, kontaktujte operátora."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Resetovať nastavenia"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Chcete resetovať všetky nastavenia sietí? Túto akciu nie je možné vrátiť späť."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Chcete resetovať všetky nastavenia sietí a vymazať eSIM karty? Túto akciu nemôžete vrátiť späť."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Resetovať nastavenia"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Resetovať?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Tento používateľ nemôže resetovať nastavenia siete"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Sieťové nastavenia boli obnovené"</string>
    <string name="reset_esim_error_title" msgid="6516110227665862295">"eSIM karty sa nedajú vymazať"</string>
    <string name="reset_esim_error_msg" msgid="8459527827897797168">"Niečo sa pokazilo a tieto eSIM karty sa nevymazali.\n\nReštartujte zariadenie a skúste to znova."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Vymazať údaje (obnoviť výrobné nastavenia)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Vymazať údaje (obnoviť výrobné nastavenia)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Hudba"</li>\n<li>"Fotky"</li>\n<li>"Iné údaje používateľa"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM karty"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Nezruší sa tým vaša tarifa mobilných služieb."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Všetky vaše osobné údaje a stiahnuté aplikácie budú odstránené. Túto akciu nie je možné vrátiť späť."</string>
    <string name="main_clear_final_desc_esim" msgid="6592404057237813989">"Všetky vaše osobné údaje vrátane stiahnutých aplikácií a eSIM kariet budú odstránené. Táto akcia sa nedá vrátiť späť."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Chcete vymazať všetky údaje?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Obnovenie výrobných nastavení nie je pre tohto používateľa k dispozícii"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Maže sa"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Čakajte…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Nastavenia hovorov"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Nastavenie hlasovej schránky, presmerovania hovorov, čakajúcich hovorov a identifikácie volajúceho"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Tethering cez USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Prenosný prístupový bod"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Tethering cez Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Zdieľané pripojenie"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot a tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot je zapnutý, dátové pripojenie sa zdieľa"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot je zapnutý"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Dátové pripojenie sa zdieľa"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Keď je šetrič dát zapnutý, nie je možné zdieľať dátové pripojenie ani používať prenosné hotspoty"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Iba hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Iba USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Iba Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Iba Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internet sa nezdieľa s inými zariadeniami"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Vypnuté"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Tethering cez USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Tethering cez Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Tethering cez ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Hotspot a tethering umožňujú poskytovať internet iným zariadeniam prostredníctvom vášho mobilného dátového pripojenia. Aplikácie tiež môžu vytvárať hostpot na zdieľanie obsahu so zariadeniami v okolí."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Hotspot a tethering umožňujú poskytovať internet iným zariadeniam prostredníctvom vášho pripojenia Wi‑Fi alebo mobilného dátového pripojenia. Aplikácie tiež môžu vytvárať hostpot na zdieľanie obsahu so zariadeniami v okolí."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Pomocník"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilná sieť"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikácia na SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Zmeniť aplikáciu na SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Použiť aplikáciu <xliff:g id="NEW_APP">%1$s</xliff:g> namiesto <xliff:g id="CURRENT_APP">%2$s</xliff:g> ako aplikáciu na SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Použiť aplikáciu <xliff:g id="NEW_APP">%s</xliff:g> ako aplikáciu pre SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Zmeniť aplikáciu asistent pripojenia Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Chcete spravovať sieťové pripojenia pomocou aplikácie <xliff:g id="NEW_APP">%1$s</xliff:g> namiesto aplikácie <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <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>
    <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>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Nedávny prístup"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Zobraziť všetko"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Zobraziť podrobnosti"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"V poslednom čase nepožiadali o polohu žiadne aplikácie"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Polohu v poslednom čase nepoužili žiadne aplikácie"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Vysoká spotreba batérie"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Nízka spotreba batérie"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Vyhľadávanie sietí Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Povoľte aplikáciám a službám kedykoľvek vyhľadávať siete Wi‑Fi, a to aj vtedy, keď je pripojenie k sieťam Wi-Fi vypnuté. Môžete to využiť napríklad na zlepšenie funkcií a služieb podmienených polohou."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Vyhľadávanie zariadení Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Povoľte aplikáciám a službám kedykoľvek vyhľadávať zariadenia v okolí, a to aj vtedy, keď je rozhranie Bluetooth vypnuté. Môžete to využiť napríklad na zlepšenie funkcií a služieb podmienených polohou."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Služby určovania polohy"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Služby určovania polohy"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Používať polohu"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Časové pásmo sa nedá nastaviť automaticky"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"Poloha alebo služby určovania polohy sú vypnuté"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Vyžaduje sa poloha zariadenia"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Ak chcete pomocou polohy nastaviť časové pásmo, zapnite polohu a aktualizujte nastavenia časového pásma"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Nastavenia polohy"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Opraviť"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Zrušiť"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatické zisťovanie časového pásma je vypnuté"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Zisťovanie časového pásma podľa polohy je deaktivované"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Zisťovanie časového pásma podľa polohy nie je podporované"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Zmeny zisťovania časového pásma podľa polohy nie sú povolené"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Poloha sa môže použiť na nastavenie časového pásma"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Zobrazuje právne informácie, stav a verziu softvéru"</string>
    <string name="legal_information" msgid="7509900979811934843">"Právne informácie"</string>
    <string name="manual" msgid="3651593989906084868">"Príručka"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulačné štítky"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Bezpečnostná a regulačná príručka"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autorské práva"</string>
    <string name="license_title" msgid="8745742085916617540">"Licencia"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licencie aktualizácie systému Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Zmluvné podmienky"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licencia systému WebView"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Autorstvo tapety"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Poskytovatelia satelitných snímok:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Príručka"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Pri načítavaní príručky sa vyskytla chyba."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licencie tretích strán"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Pri načítavaní licencií sa vyskytla chyba."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Načítava sa…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Načítava sa…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Nastavte si heslo"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Nastavenie pracovného hesla"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Nastavte si PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Nastavenie pracovného kódu PIN"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Nastavte vzor"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Zlepšite svoje zabezpečenie nastavením vzoru na odomknutie zariadenia"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Nastavenie pracovného vzoru"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Ak chcete použiť odtlačok prsta, nastavte heslo"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Ak chcete použiť odtlačok prsta, nastavte vzor"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Nastavte si kód PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Ak chcete použiť odtlačok prsta, nastavte PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Znova zadajte heslo"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Opätovné zadanie pracovného hesla"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Zadajte pracovné heslo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Potvrďte svoj vzor"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Zadajte pracovný vzor"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Znova zadajte kód PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Opätovné zadanie pracovného kódu PIN"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Zadajte pracovný PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Heslá sa nezhodujú"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Kódy PIN sa nezhodujú"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Znova nakreslite vzor"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Spôsob odomknutia"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Heslo bolo nastavené"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Bol nastavený kód PIN"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Vzor bol nastavený"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Odomkn. tvárou vyžaduje nastavenie hesla"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Odomkn. tvárou vyžaduje nastavenie vzoru"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Odomkn. tvárou vyžaduje nastavenie PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Nast. heslo, aby ste mohli používať tvár alebo odtl. prsta"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Nast. vzor, aby ste mohli používať tvár alebo odtl. prsta"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Nastavte PIN, aby ste mohli používať tvár alebo odtl. prsta"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Zabudli ste heslo?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Zabudli ste vzor?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Zabudli ste PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Pokračujte nakreslením vzoru"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Pokračujte zadaním kódu PIN"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Pokračujte zadaním hesla"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Pokračujte nakreslením vzoru pre pracovný účet"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Pre pokračovanie zadajte svoj pracovný PIN"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Ak chcete pokračovať, zadajte pracovné heslo"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Zadajte bezpečnostný vzor zariadenia a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Zadajte kód PIN zariadenia a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Zadajte heslo zariadenia a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Zadajte bezpečnostný pracovný vzor a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Zadajte pracovný kód PIN a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Zadajte pracovné heslo a získajte vyššiu mieru zabezpečenia"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Overenie vzoru"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Overenie kódu PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Overenie hesla"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Overte totožnosť"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Ak chcete preniesť účty Google, nastavenia a ďalšie údaje, zadajte vzor druhého zariadenia. Vzor je šifrovaný."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Ak chcete preniesť účty Google, nastavenia a ďalšie údaje, zadajte PIN druhého zariadenia. Kód PIN je šifrovaný."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Ak chcete preniesť účty Google, nastavenia a ďalšie údaje, zadajte heslo druhého zariadenia. Heslo je šifrované."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Toto zariadenie odomykať aj vzorom"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Toto zariadenie odomykať aj kódom PIN"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Toto zariadenie odomykať aj heslom"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Overenie vzoru"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Overenie kódu PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Overenie hesla"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Ak chcete pokračovať, použite bezpečnostný vzor zariadenia"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Ak chcete pokračovať, zadajte PIN zariadenia"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Ak chcete pokračovať, zadajte heslo zariadenia"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Nesprávny kód PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Nesprávne heslo"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Nesprávny vzor"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Tiesňová linka"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Zabezpečenie zariadenia"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Zmena bezpečnostného vzoru"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Zmena bezpečnostného kódu PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Nakreslite bezpečnostný vzor"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Pomocníka zobrazíte stlačením klávesy Menu."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Na záver zdvihnite prst z obrazovky"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Spojte aspoň <xliff:g id="NUMBER">%d</xliff:g> body. Skúste to znova."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Vzor bol zaznamenaný"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Znova nakreslite vzor pre potvrdenie"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Váš nový bezpečnostný vzor"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Potvrdiť"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Nakresliť znova"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Vymazať"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Pokračovať"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Bezpečnostný vzor"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Vyžadovať vzor"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Obrazovku musíte odomknúť nakreslením bezpečnostného vzoru."</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Zobrazovať vzor"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Zlepšená ochrana súkromia pri zadávaní kódu PIN"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Vypnúť animácie pri zadávaní kódu PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Zobrazovať vzor profilu"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrovať pri klepnutí"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Zamykať vypínačom"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Ak odomknutie nie je udržiavané funkciou <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Nastaviť bezpečnostný vzor"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Zmena bezpečnostného vzoru"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Bezpečnostný vzor obrazovky nakreslite takto"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Príliš veľa nesprávnych pokusov. Skúste to znova o <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikácia nie je v telefóne nainštalovaná."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Zabezpečenie pracovného profilu"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Zámka obrazovky pre pracovný profil"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Použiť jednu zámku"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Používať jednu zámku pre pracovný profil aj obrazovku zariadenia"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Použiť jednu zámku?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Zariadenie bude používať zámku obrazovky vášho pracovného profilu. Pracovné pravidlá sa použijú v prípade oboch zámok."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Zámka pracovného profilu nespĺňa požiadavky zabezpečenia vašej organizácie. Môžete používať rovnakú zámku pre obrazovku zariadenia aj pracovný profil, ale budú sa na ňu vzťahovať všetky pravidlá pracovnej zámky."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Použiť jednu zámku"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Použiť jednu zámku"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Rovnaká ako zámka obrazovky zariadenia"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Spravovať aplikácie"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informácie o aplikáciách"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Nastavenia aplikácie"</string>
    <string name="install_applications" msgid="3921609656584369901">"Neznáme zdroje"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Povoliť všet. zdroje aplikácií"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Nedávno spustené aplikácie"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Zobraziť všetky aplikácie}few{Zobraziť všetky # aplikácie}many{See all # apps}other{Zobraziť všetkých # aplikácií}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontaktujte správcu IT"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Môže vám pomôcť resetovať PIN, vzor alebo heslo"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Rozšírené nastavenia"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Povoliť ďalšie možnosti nastavení"</string>
    <string name="application_info_label" msgid="1015706497694165866">"O aplikácii"</string>
    <string name="storage_label" msgid="2522307545547515733">"Priestor"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Predvolené otváranie"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Predvolené"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Kompatibilita obrazovky"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Povolenia"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Vyrovnávacia pamäť"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Vymazať vyrovnávaciu pamäť"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Vyrovnávacia pamäť"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 položka}few{# položky}many{# items}other{# položiek}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Zrušiť prístup"</string>
    <string name="controls_label" msgid="8671492254263626383">"Ovládacie prvky"</string>
    <string name="force_stop" msgid="2681771622136916280">"Vynútiť zastavenie"</string>
    <string name="archive" msgid="9074663845068632127">"Archivovať"</string>
    <string name="restore" msgid="7622486640713967157">"Obnoviť"</string>
    <string name="restoring_step_one" msgid="3465050101254272874">"Obnovuje sa"</string>
    <string name="restoring_step_two" msgid="140484846432595108">"Obnovuje sa."</string>
    <string name="restoring_step_three" msgid="3712883580876329811">"Obnovuje sa.."</string>
    <string name="restoring_step_four" msgid="8966846882470446209">"Obnovuje sa…"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Celkove"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Veľkosť aplikácie"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplikácia, úložisko USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Údaje používateľa"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Odinštalovať"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Odinštalovať pre všetkých používateľov"</string>
    <string name="install_text" msgid="4558333621516996473">"Inštalovať"</string>
    <string name="disable_text" msgid="5146002260857428005">"Deaktivovať"</string>
    <string name="enable_text" msgid="8570798764647110430">"Aktivovať"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Vymazať obsah úložiska"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Odinštalovať aktualizácie"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Povoliť obmedzené nastavenia"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Niektoré aktivity, ktoré ste vybrali, sa predvolene otvoria v tejto aplikácii."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Tejto aplikácii ste povolili vytváranie miniaplikácií a pristupovanie k ich údajom."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nie sú nastavené žiadne predvolené"</string>
    <string name="clear_activities" msgid="488089228657585700">"Vymazať predvolené predvoľby"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Táto aplikácia pravdepodobne nie je určená pre vašu obrazovku. Tu môžete nastaviť, ako sa aplikácia obrazovke prispôsobí."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Opýtať sa pri spustení"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Prispôsobiť veľkosť aplikácie"</string>
    <string name="unknown" msgid="8192160131923461175">"Neznáme"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Zoradiť podľa názvu"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Zoradiť podľa veľkosti"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Najnovšie"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Najčastejšie"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Spustené služby"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Vyrovnávacia pamäť"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikácia pre tiesňové volania"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Resetovať nastavenia aplikácií"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Chcete resetovať nastavenia aplikácií?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Touto akciou resetujete nasledujúce nastavenia:\n\n"<li>"deaktivované aplikácie,"</li>\n<li>"deaktivované upozornenia aplikácií,"</li>\n<li>"predvolené aplikácie pre rôzne akcie,"</li>\n<li>"obmedzenia dát na pozadí pre aplikácie,"</li>\n<li>"všetky obmedzenia povolení,"</li>\n<li>"nastavenia spotreby batérie."</li>\n\n"Neprídete o žiadne dáta aplikácií."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Resetovať aplikácie"</string>
    <string name="filter" msgid="9039576690686251462">"Filtrovať"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Zvoľte možnosti filtra"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Všetky aplikácie"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Deaktivované aplikácie"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Stiahnuté"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Spustené"</string>
    <string name="not_installed" msgid="5074606858798519449">"Pre tohto používateľa nenainš."</string>
    <string name="installed" msgid="2837449358488825884">"Nainštalované"</string>
    <string name="no_applications" msgid="985069304755391640">"Žiadne aplikácie"</string>
    <string name="internal_storage" msgid="999496851424448809">"Interný ukl. priestor"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Prebieha prepočítanie veľkosti..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Odstrániť dáta aplikácie?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Dáta tejto aplikácie (vrátane súborov a nastavení) budú zo zariadenia natrvalo odstránené"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Zrušiť"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Odstrániť"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikáciu sa nepodarilo nájsť v zozname nainštalovaných aplikácií."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Nepodarilo sa vymazať úložisko aplikácie"</string>
    <string name="computing_size" msgid="4915310659841174866">"Prebieha výpočet…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nepodarilo sa vypočítať veľkosť balíčka."</string>
    <string name="version_text" msgid="7628938665256107608">"verzia <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Presunúť"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Nepodarilo sa archivovať"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"Aplikácia <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> bola archivovaná"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Nepodarilo sa obnoviť"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"Obnovuje sa aplikácia <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Už prebieha iná migrácia."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"V úložisku nie je dostatok miesta."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplikácia neexistuje."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Umiestnenie inštalácie nie je platné."</string>
    <string name="system_package" msgid="7559476279008519360">"Aktualizácie systému sa nepodarilo nainštalovať na externé médiá."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplikáciu na správu zariadenia nie je možné inštalovať na externé médiá"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Vynútiť zastavenie?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Ak vynútite zastavenie aplikácie, môže sa správať zvláštne."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Deaktivovať aplikáciu"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Ak aplikáciu deaktivujete, systém a ďalšie aplikácie už nemusia fungovať podľa očakávaní. Upozorňujeme, že túto aplikáciu nemôžete odstrániť, pretože bola vo vašom zariadení vopred nainštalovaná. Deaktiváciou ju vypnete a skryjete v zariadení."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Obchod"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Podrobnosti o aplikácii"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikácia bola nainštalovaná z obchodu <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Ďalšie informácie: <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Spustené"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nikdy nepoužité)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Využitie ukl. priestoru"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Prebieha reštartovanie"</string>
    <string name="cached" msgid="5379485147573438201">"Proces na pozadí vo vyrovnávacej pamäti"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nič nie je spustené."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Spustené aplikáciou."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Voľné <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"Využité: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Používateľ: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Odstránený používateľ"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"procesy: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, služby: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Pamäť zariadenia"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Využitie pamäte RAM aplikáciami"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Systém"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikácie"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Voľné"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Využité"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Vo vyr. pamäti"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Spustená aplikácia"</string>
    <string name="no_services" msgid="3898812785511572899">"Neaktívne"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Služby"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesy"</string>
    <string name="service_stop" msgid="5712522600201308795">"Zastaviť"</string>
    <string name="service_manage" msgid="3896322986828332075">"Nastavenia"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Táto služba bola spustená svojou aplikáciou. Ak ju zastavíte, môže dojsť k zlyhaniu aplikácie."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Túto aplikáciu nie je možné bezpečne zastaviť. Ak ju zastavíte, môže dôjsť k strate časti vašej práce."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Toto je starý proces aplikácie, ktorý stále beží pre prípad, že by ste ho znova potrebovali. Na jeho zastavenie nie je väčšinou dôvod."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: práve sa používa. Môžete ovládať po klepnutí na Nastavenia."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Hlavný proces, ktorý sa používa."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Služba <xliff:g id="COMP_NAME">%1$s</xliff:g> sa používa."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Poskytovateľ <xliff:g id="COMP_NAME">%1$s</xliff:g> sa používa."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Zastaviť systémovú službu?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Jazyky, vstup a gestá"</string>
    <string name="language_settings" msgid="8700174277543875046">"Jazyky a vstup"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Jazyky"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Klávesnica"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nemáte povolenie na zmenu jazyka zariadenia."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Jazyky a vstup"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Nástroje"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Klávesnica a metódy vstupu"</string>
    <string name="system_language" msgid="1146762166579643257">"Jazyky systému"</string>
    <string name="phone_language" msgid="5986939176239963826">"Jazyky"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatické nahradenie"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Opravovať pravopisné chyby"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Veľké písmená automaticky"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Prvé písmeno vo vete je automaticky veľké"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatická interpunkcia"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Nastavenia fyzickej klávesnice"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Znak „.“ môžete vložiť dvojitým stlačením klávesu Medzerník."</string>
    <string name="show_password" msgid="7101900779571040117">"Zobrazovať heslá"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Pri písaní sa budú krátko zobrazovať zadávané znaky"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Táto kontrola pravopisu môže zhromažďovať zadávaný text vrátane osobných údajov, ako sú napríklad heslá alebo čísla kreditných kariet. Je používaná aplikáciou <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Chcete povoliť túto kontrolu pravopisu?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Nastavenia"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Jazyk"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Klávesnice"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Klávesnica na obrazovke"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Dostupná klávesnica na obrazovke"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Spravovať klávesnice na obrazovke"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Možnosti"</string>
    <string name="keyboard_a11y_category" msgid="8230758278046841469">"Dostupnosť"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fyzická klávesnica"</string>
    <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>
    <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>
    <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>
    <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">"Zobraziť zoznam skratiek"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Klávesnice a nástroje pracovného profilu"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Klávesnica na obrazovke na prácu"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Predvolené"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchpad"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchpad a myš"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Rýchlosť kurzora, gestá"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Kliknutie klepnutím"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Gestá touchpadu"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Prispôsobte si jednotlivé navigačné gestá touchpadu"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Obrátené posúvanie"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Pri posúvaní nadol sa obsah pohybuje nahor"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Klepnutie vpravo dole"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Viac zobrazíte klepnutím do pravého dolného rohu touchpadu"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Rýchlosť kurzora"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Naučiť sa gestá touchpadu"</string>
    <string name="keywords_touchpad" msgid="8159846254066666032">"trackpad, myš, kurzor, posúvať, potiahnuť, kliknúť pravým tlačidlom, kliknúť, ukazovateľ"</string>
    <string name="keywords_trackpad_bottom_right_tap" msgid="1285062446073929305">"kliknúť pravým tlačidlom, klepnúť"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Prechod na plochu"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Kdekoľvek na touchpade potiahnite troma prstami nahor"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Prejdenie späť"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Potiahnite troma prstami zľava alebo sprava"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Zobrazenie nedávnych aplikácií"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Potiahnite troma prstami nahor, pridržte ich a uvoľnite"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Zobrazenie upoz. a rýchlych nastav."</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Na ploche potiahnite troma prstami nadol"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Prepínanie aplikácií"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Potiahnite štyrmi prstami doľava alebo doprava"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Preskočiť"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Ďalej"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Reštart."</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Hotovo"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Prejdenie späť"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Potiahnite troma prstami doľava alebo doprava"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Prechod na plochu"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Potiahnite troma prstami"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Nedávne aplikácie"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Potiahnite troma prstami a pridržte ich"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Upozornenia"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Potiahnite troma prstami nadol"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Prepínanie aplikácií"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Potiahnite štyrmi prstami doľava alebo doprava"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Klávesy modifikátora"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Zmeniť správanie klávesov"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Resetovať všetky"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Predvolené"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Naozaj chcete resetovať všetky klávesy modifikátora na predvolené?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Hotovo"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Zrušiť"</string>
    <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>
    <string name="ime_label_title" msgid="8994569521516807168">"Rozloženie <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Predvolené"</string>
    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automaticky: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Vybrané používateľom: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
    <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>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Presmerovať vibrácie"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Posielať vibrácie do herného ovládača, keď je pripojený"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Zvoľte rozloženie klávesnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Nastaviť rozloženia klávesnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Prepnite klávesmi ctrl-space"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Predvolené"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Rozloženia klávesnice"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Rozloženia fyzickej klávesnice"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Osobný slovník"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Osobný slovník pre prácu"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Pridajte slová, ktoré sa majú použiť v aplikáciách, ako je Kontrola pravopisu"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Pridať"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Pridať do slovníka"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fráza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Viac možností"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Menej možností"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Slovo:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Skratka:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Jazyk:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Zadajte slovo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Nepovinná skratka"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Upraviť slovo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Upraviť"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Odstrániť"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"V používateľskom slovníku nie sú žiadne slová. Klepnutím na tlačidlo + môžete pridať slovo."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Pre všetky jazyky"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Ďalšie jazyky..."</string>
    <string name="testing" msgid="6294172343766732037">"Testovanie"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Klávesnica na obrazovke, nástroje"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Klávesnica na obrazovke, fyzická klávesnica, nástroje"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fyzická klávesnica"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Rozloženie"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Vyberte modul gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Vyberte miniaplikáciu"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Vytvoriť miniaplikáciu a povoliť prístup?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Po vytvorení miniaplikácie získa aplikácia prístup k všetkému zobrazenému obsahu.\n\nAplikácia: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nMiniaplikácia: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Vždy povoliť aplikácii <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> vytvárať miniaplikácie a pristupovať k ich údajom"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Štatistiky používania"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Zoradiť podľa času používania"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Zoradiť podľa posledného použitia"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Zoradiť podľa názvu aplikácie"</string>
    <string name="last_time_used_label" msgid="7589377271406011659">"Naposledy použité"</string>
    <string name="last_time_used_never" msgid="2936073559267990034">"nikdy"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Doba použitia"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Dostupnosť"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Nastavenia dostupnosti"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Zobrazenie, interakcia, zvuk"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Pre zrakovo postihnutých"</string>
    <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>
    <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>
    <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>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Ovládanie systému"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Stiahnuté aplikácie"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimentálne"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Experimentálne funkcie"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtrovanie denníka Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Nastaviť filtre"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Ak chcete uplatniť zmeny, vypnite a zapnite Bluetooth"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Filtrovanie denníka Bluetooth HCI PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Filtrovanie denníka Bluetooth HCI MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Nastavte režim filtrovania. (Ak chcete uplatniť zmeny, vypnite a zapnite Bluetooth.)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Ak chcete zmeniť túto možnosť, nastave režim denníka Bluetooth HCI na Povolené, filtrované"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Čítačka obrazovky určená hlavne pre nevidiacich a slabozrakých"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Položky na obrazovke si môžete vypočuť nahlas klepnutím"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Nastavenia titulkov"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Predvoľby titulkov"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Ďalšie informácie o predvoľbách titulkov"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Zväčšenie"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Skratka zväčšenia"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Zväčšovať zadávaný text"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Lupa sleduje zadávaný text"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Nechať zapnuté pri prepínaní aplikácií"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Lupa zostáva zapnutá a pri prepínaní aplikácií sa oddiali"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Joystickom na obrazovke aktivujte a presuňte lupu. Lupu ovládajte pridržaním a presúvaním joysticka. Joystickom pohnete klepnutím naň a presunutím."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Zväčšenie"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Ďalšie informácie o zväčšení"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Typ zväčšenia"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Zväčšite celú obrazovku, jej konkrétnu časť alebo prepínajte medzi oboma možnosťami"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Celá obrazovka"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Časť obrazovky"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Prepínanie medzi celou obrazovkou a jej časťou"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Výber spôsobu zväčšenia"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Zväčšenie celej obrazovky"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Zväčšenie časti obrazovky"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Prepínanie medzi celou obrazovkou a jej časťou"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Klepnutím na prepínač môžete prechádzať medzi oboma možnosťami"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Chcete prepnúť na tlačidlo dostupnosti?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Zväčšovanie častí obrazovky trojitým klepnutím môže spôsobiť rôzne oneskorenia, napríklad pri zadávaní textu.\n\nTlačidlo dostupnosti pláva na obrazovke nad ostatnými aplikáciami. Klepnite naň a obrazovka sa zväčší."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Prepnúť na tlačidlo dostupnosti"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Použiť trojité klepnutie"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Môže to spomaliť klávesnicu"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Pri používaní zväčšenia časti obrazovky trojitým klepnutím si možno všimnete problémy s klávesnicou.\n\nAk im chcete predísť, môžete skratku zväčšenia zmeniť z trojitého klepnutia na inú možnosť.\n"<annotation id="link">"Zmeniť nastavenie"</annotation></string>
    <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>
    <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>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Veľkosť zobrazenia a text"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Zmeniť, ako sa text zobrazuje"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Predmet: Návrhy teplovzdušných balónov"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Od: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Dobré ráno,\n\nchcem sa spýtať, ako ste pokročili s požadovanými návrhmi. Budú k dispozícii, než začneme konštruovať nové balóny?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Resetovať nastavenia"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Nastavenia veľkosti obrazovky a textu boli resetované"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Chcete resetovať veľkosť zobrazenia a textu?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Resetovať"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Máš nejaké plány na víkend?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Chystám sa na pláž. Chceš sa pridať?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Možnosti"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Priblížte si obrazovku"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Na priblíženie trikrát klepnite"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Na priblíženie klepnite na tlačidlo"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Obrazovku si môžete rýchlo priblížiť, aby bol obsah väčší"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Priblíženie:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Skratkou spustite zväčšenie.&lt;br/&gt; {1,number,integer}. Klepnite na obrazovku.&lt;br/&gt; {2,number,integer}. Pohybujte sa po obrazovke presúvaním dvoch prstov.&lt;br/&gt; {3,number,integer}. Priblíženie upravte stiahnutím či roztiahnutím dvoch prstov.&lt;br/&gt; {4,number,integer}. Zväčšenie ukončíte skratkou.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Dočasné priblíženie:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Skontrolujte, či je typ zväčšenia nastavený na celú obrazovku.&lt;br/&gt; {1,number,integer}. Skratkou spustite zväčšenie.&lt;br/&gt; {2,number,integer}. Pridržte ľubovoľné miesto na obrazovke.&lt;br/&gt; {3,number,integer}. Pohybujte sa po obrazovke presúvaním prsta.&lt;br/&gt; {4,number,integer}. Zväčšenie ukončíte zdvihnutím prsta."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Keď je priblíženie zapnuté, môžete si zväčšiť obsah obrazovky.\n\n"<b>"Urobíte to tak"</b>", že spustíte priblíženie a klepnete kamkoľvek na obrazovku.\n"<ul><li>"Zobrazenie posuniete presunutím dvoch alebo viacerých prstov."</li>\n<li>"Priblíženie upravíte stiahnutím dvoch alebo viacerých prstov."</li></ul>\n\n<b>"Ak chcete obsah priblížiť krátkodobo"</b>", spustite priblíženie a pridržte ľubovoľné miesto na obrazovke.\n"<ul><li>"Po obrazovke prechádzate presunutím."</li>\n<li>"Oddialite zdvihnutím prsta."</li></ul>\n\n"Nemôžete priblížiť klávesnicu ani navigačný panel."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"<xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. stránka z <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Otváranie tlačidlom dostupnosti"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Otvorte pridržaním tlačidiel hlasitosti"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Otvorenie troma klepnutiami na obrazovku"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Otvorte dvojitým klepnutím dvoma prstami na obrazovku"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Otváranie gestom"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Použitie gesta dostupnosti"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Ak chcete použiť túto funkciu, klepnite na tlačidlo dostupnosti <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> v dolnej časti obrazovky.\n\nFunkcie prepnete pridržaním tlačidla dostupnosti."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Ak chcete túto funkciu použiť, klepnite na tlačidlo dostupnosti na obrazovke."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Túto funkciu použijete tak, že pridržíte obe tlačidlá hlasitosti."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Ak chcete spustiť alebo zastaviť zväčšenie, klepnite trikrát na ľubovoľné miesto na obrazovke."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"Ak chcete spustiť či zastaviť zväčšenie, klepnite dvakrát dvoma prstami kdekoľvek na obrazovku."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Ak chcete použiť túto funkciu, potiahnite dvoma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím dvoma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Ak chcete použiť túto funkciu, potiahnite troma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím troma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Ak chcete použiť funkciu dostupnosti, potiahnite dvoma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím dvoma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Ak chcete použiť funkciu dostupnosti, potiahnite troma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím troma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Dobre"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Nastavenia tlačidla"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"<xliff:g id="SERVICE">%1$s</xliff:g> – skratka"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Tlačidlo dostupnosti"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Gesto dostupnosti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Potiahnutie dvoma prstami nahor"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Potiahnite troma prstami nahor"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Klepnutie na tlačidlo dostupnosti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Použitie gesta dostupnosti"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Klepnite na tlačidlo dostupnosti <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> v dolnej časti obrazovky.\n\nFunkcie prepnete pridržaním tlačidla dostupnosti."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Potiahnite dvoma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím dvoma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Potiahnite troma prstami z dolnej časti obrazovky nahor.\n\nFunkcie prepnete potiahnutím troma prstami smerom nahor a pridržaním."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Ďalšie možnosti"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Ďalšie informácie o funkcii <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Pridržanie tlačidiel hlasitosti"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"podržanie tlačidiel hlasitosti"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Pridržte obe tlačidlá hlasitosti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Dvojité klepnutie dvoma prstami na obrazovku"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"dvojité klepnutie dvoma prstami na obrazovku"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Rýchlo {0,number,integer}-krát klepnite dvoma prstami na obrazovku"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Tri klepnutia na obrazovku"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"tri klepnutia na obrazovku"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"{0,number,integer}‑krát rýchlo klepnite na obrazovku. Táto skratka môže zariadenie spomaliť."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Rozšírené"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Tlačidlo dostupnosti je nastavené na službu <xliff:g id="SERVICE">%1$s</xliff:g>. Ak chcete použiť priblíženie, klepnite na tlačidlo dostupnosti, podržte ho a potom vyberte priblíženie."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Gesto dostupnosti je nastavené na službu <xliff:g id="SERVICE">%1$s</xliff:g>. Ak chcete použiť priblíženie, potiahnite dvoma prstami nahor zo spodnej časti obrazovky a pridržte ich. Potom vyberte priblíženie."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Skratka klávesa hlasitosti"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Nastavenia skratiek"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Odkaz z uzamknutej obrazovky"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Povoliť, aby odkaz fungoval aj na uzamknutej obrazovke, podržaním oboch tlačidiel hlasitosti na niekoľko sekúnd"</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Tlačidlo dostupnosti"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Tlačidlo a gesto dostupnosti"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Rýchly prístup k funkciám dostupnosti na ľubovoľnej obrazovke."</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Tlačidlo dostupnosti"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Tlačidlo dostupnosti a gesto"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Ďalšie informácie o tlačidle dostupnosti a geste"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Používa sa tlačidlo dostupnosti. Pri trojtlačidlovej navigácii nie je gesto k dispozícii."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Rýchly prístup k funkciám dostupnosti"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Ak chcete začať:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Prejdite do nastavení dostupnosti.&lt;br/&gt; {1,number,integer}. Vyberte funkciu a klepnite na odkaz.&lt;br/&gt; {2,number,integer}. Vyberte, či chcete na prístup k funkcii použiť tlačidlo alebo gesto.&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Ak chcete začať:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Prejdite do nastavení dostupnosti.&lt;br/&gt; {1,number,integer}. Vyberte funkciu a klepnite na odkaz.&lt;br/&gt; {2,number,integer}. Vyberte tlačidlo na prístup k danej funkcii.&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Používať tlačidlo alebo gesto"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Poloha"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Veľkosť"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Nechať zmiznúť, keď sa nepoužíva"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Po niekoľkých sekundách zmizne, takže ľahšie uvidíte obrazovku"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Priehľadnosť, keď sa nepoužíva"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Priehľadné"</string>
    <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>
    <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>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Veľký kurzor myši"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Zlepšiť viditeľnosť kurzora myši"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Nastavenie aplikácií ako tmavých"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Vzťahuje sa iba na aplikácie bez vlastného tmavého motívu. Niektoré aplikácie majú problémy so zobrazením, napríklad invertované farby."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Odstrániť animácie"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Zredukovať pohyb na obrazovke"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Zvuk mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Pri prehrávaní zvuku skombinovať kanály"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Vyváženie zvuku"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Ľavé"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Pravé"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Predvolené"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekúnd"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekúnd"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minúta"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minúty"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Čas na reakciu (časový limit dostupnosti)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Čas na reakciu (časový limit dostupnosti)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Ďalšie informácie o čase na reakciu (časovom limite Dostupnosti)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Čas na reakciu"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Táto predvoľba času nie je podporovaná všetkými aplikáciami."</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Vyberte, ako dlho sa majú zobrazovať dočasné správy s výzvami na akciu."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Oneskorenie pridržania"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inverzia farieb"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Používať inverziu farieb"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Skratka inverzie farieb"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Inverzia farieb stmaví svetlé obrazovky. Tiež zmení tmavé obrazovky na svetlé."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Dôležité&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Farby sa budú meniť v médiách a obrázkoch.&lt;/li&gt; &lt;li&gt; Inverzia farieb funguje vo všetkých aplikáciách.&lt;/li&gt; &lt;li&gt; Ak si chcete zobraziť tmavé pozadie, môžete namiesto toho použiť tmavý motív.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"prejdite do nastavení"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automatické kliknutie (čas zotrvania)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Automat. kliknutie (čas zotrvania)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Ďalšie informácie o automatickom kliknutí (čase zotrvania)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Môžete nastaviť pripojenú myš, aby klikala automaticky, keď sa kurzor nebude určitý čas hýbať"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Automatické kliknutie môže byť užitočné, keď je náročné klikať na myš."</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automatické kliknutie je vypnuté"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Krátke"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekundy"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Stredné"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundy"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Dlhé"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekunda"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Vlastné"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Kratší"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Dlhší"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Čas automatického kliknutia"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibrácie a hmatová spätná väzba"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Ovládajte silu vibrácií pre rôzne spôsoby použitia"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Zapnuté"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Vypnuté"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Nastavenie je vypnuté, pretože v zariadení je zapnutý tichý režim"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Hovory"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Upozornenia a budíky"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktívna hmatová spätná väzba"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Používať vibrácie a hmatovú spätnú väzbu"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibrovanie pri budíku"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibrovanie pri médiách"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Vibrovanie klávesnice"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibrovanie pri zvonení"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibrovanie pri upozornení"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Odozva pri klepnutí"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Používať aplikáciu <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Otvoriť <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"Do rýchlych nastavení bola pridaná aplikácia <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>. Potiahnutím nadol ju môžete kedykoľvek zapnúť alebo vypnúť."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Aplikáciu <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> môžete do rýchlych nastavení pridať aj v hornej časti obrazovky"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Do rýchlych nastavení bola pridaná úprava farieb. Potiahnutím nadol ju môžete kedykoľvek zapnúť alebo vypnúť."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Úpravu farieb môžete do rýchlych nastavení pridať aj v hornej časti obrazovky"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Do rýchlych nastavení bola pridaná inverzia farieb. Potiahnutím nadol ju môžete kedykoľvek zapnúť alebo vypnúť."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Inverziu farieb môžete do rýchlych nastavení pridať aj v hornej časti obrazovky"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Do rýchlych nastavení bolo pridané mimoriadne stmavenie. Potiahnutím nadol ho môžete kedykoľvek zapnúť alebo vypnúť."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Mimoriadne stmavenie môžete do rýchlych nastavení pridať aj v hornej časti obrazovky"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Do rýchlych nastavení bol pridaný režim jednej ruky. Potiahnutím nadol ho môžete kedykoľvek zapnúť alebo vypnúť."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Režim jednej ruky môžete do rýchlych nastavení pridať aj v hornej časti obrazovky"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Do rýchlych nastavení bola pridaná veľkosť písma. Potiahnutím nadol môžete veľkosť písma kedykoľvek zmeniť."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Zavrieť"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Používať úpravu farieb"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Skratka úpravy farieb"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Úprava farieb"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Ďalšie informácie o úprave farieb"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Inverzia farieb"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Ďalšie informácie o inverzii farieb"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Zobrazovať titulky"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Iba pre podporovanú aplikáciu"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Veľkosť a štýl titulkov"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Veľkosť textu: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Ďalšie možnosti"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Prispôsobte si veľkosť a štýl titulkov, aby sa ľahšie čítali."</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Tieto predvoľby titulkov nie sú podporované všetkými prehrávačmi."</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Tlačidlo dostupnosti"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"potiahnutie dvoma prstami z dolnej časti nahor"</string>
    <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>
    <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>
    <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>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Na ďalšej obrazovke klepnite na svoje načúvadlá. Ľavé a pravé ucho môže byť potrebné spárovať zvlášť.\n\nSkontrolujte, či sú načúvadlá zapnuté a pripravené na párovanie."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je aktívne"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, iba ľavá strana"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, iba pravá strana"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, ľavá aj pravá strana"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"Zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g> a jedno ďalšie"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Pár. nového zariad."</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Načúvacie zariadenia"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Uložené zariadenia"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Ovládanie načúvacích zariadení"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Skratka načúvacieho zariadenia"</string>
    <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>
    <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>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Nevidíte svoje načúvacie zariadenie?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Zobraziť ďalšie zariadenia"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Úprava zvuku"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Zvukový opis"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Púšťať opis deja na obrazovke v podporovaných filmoch a reláciách"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"zvukový opis, zvuk, opis, slabozrakosť"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Skratka je zapnutá"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Vypnuté"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Zapnuté"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Vypnuté"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Nefunguje. Informácie zobrazíte klepnutím."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Táto služba nepracuje správne."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Skratky dostupnosti"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Zobraziť v rýchlych nastaveniach"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Červená a zelená"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Červená a zelená"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Modrá a žltá"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Odfarbenie"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Porucha vnímania zelenej, deuteranomália"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Porucha vnímania červenej, protanomália"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomália"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Mimoriadne stmavenie"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Mimoriadne stmaviť obrazovku"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Skratka mimoriadneho stmavenia"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Mimoriadne stmavenie"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Stmavte si obrazovku, aby sa vám ľahšie čítalo"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intenzita"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Tmavšie"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Jasnejšie"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Po reštartovaní zariadenia ponechať zapnuté"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Krátke ({time} sekunda)}few{Krátke ({time} sekundy)}many{Krátke ({time} sekundy)}other{Krátke ({time} sekúnd)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Stredné ({time} sekunda)}few{Stredné ({time} sekundy)}many{Stredné ({time} sekundy)}other{Stredné ({time} sekúnd)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Dlhé ({time} sekunda)}few{Dlhé ({time} sekundy)}many{Dlhé ({time} sekundy)}other{Dlhé ({time} sekúnd)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekunda}few{{time} sekundy}many{{time} sekundy}other{{time} sekúnd}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Nastavenia"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Zapnuté"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Vypnuté"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Ukážka"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Štandardné možnosti"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Jazyk"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Veľkosť textu"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Štýl titulkov"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Vlastné možnosti"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Farba pozadia"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Nepriehľadnosť pozadia"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Farba okna titulkov"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Nepriehľadnosť okna titulkov"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Farba textu"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Nepriehľadnosť textu"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Farba okraja"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Druh okraja"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Skupina písiem"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Titulky budú vyzerať takto."</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Predvolený"</string>
    <string name="color_title" msgid="2511586788643787427">"Farba"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Predvolené"</string>
    <string name="color_none" msgid="3703632796520710651">"Žiadna"</string>
    <string name="color_white" msgid="1896703263492828323">"Biela"</string>
    <string name="color_gray" msgid="8554077329905747877">"Sivá"</string>
    <string name="color_black" msgid="9006830401670410387">"Čierna"</string>
    <string name="color_red" msgid="5210756997426500693">"Červená"</string>
    <string name="color_green" msgid="4400462091250882271">"Zelená"</string>
    <string name="color_blue" msgid="4997784644979140261">"Modrá"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Azúrová"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Žltá"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Purpurová"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Chcete povoliť službe <xliff:g id="SERVICE">%1$s</xliff:g> úplnú kontrolu nad zariadením?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> potrebuje:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Nastavenia nemôžu overiť vašu odpoveď, pretože určitá aplikácia blokuje žiadosť o povolenie."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"Služba <xliff:g id="SERVICE">%1$s</xliff:g> vyžaduje úplnú kontrolu nad týmto zariadením. Táto služba môže čítať obrazovku a konať v mene používateľov, ktorí vyžadujú funkcie dostupnosti. Pre väčšinu aplikácií nie je táto úroveň kontroly primeraná."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Úplná kontrola je vhodná pre aplikácie, ktoré vám pomáhajú s dostupnosťou, ale nie pre väčšinu aplikácií."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Zobrazenie a ovládanie obrazovky"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Môže čítať všetok obsah na obrazovke a zobrazovať obsah cez ďalšie aplikácie."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Zobrazenie a vykonávanie akcií"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Môže sledovať vaše interakcie s aplikáciou alebo hardvérovým senzorom a interagovať s aplikáciami za vás."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Povoliť"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Zamietnuť"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Vypnúť"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Nevypínať"</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Chcete službu <xliff:g id="SERVICE">%1$s</xliff:g> vypnúť?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nie sú nainštalované žiadne služby"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nie je vybratá žiadna služba"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"K dispozícii nie je žiadny popis."</string>
    <string name="settings_button" msgid="2195468788019730377">"Nastavenia"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"svetloplachosť, fotofóbia, tmavý motív, migréna, bolesť hlavy, režim čítania, nočný režim, znížiť jas, biely bod"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"zrak, sluch, nevidiaci, nepočujúci, motorický, zručnosť, pomocný, asistencia, jednoduchosť používania, jednoduchý prístup, ruka, pomoc"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Lupa okna, lupa, zväčšenie, slabozrakosť, zväčšiť"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Titulky, skryté titulky, Okamžitý prepis, slabo počujúci, hluchota, CART, prevod reči na text, titulok"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"veľkosť obrazovky, veľká obrazovka"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Vysoký kontrast, slabozrakosť, tučné písmo, tučné, tvár"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"upraviť farbu"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"stmaviť obrazovku, zjasniť obrazovku"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"kontrast farieb"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"motorický, myš, externá myš, myš ovládaná hlavou, adaptívna myš, invalidný vozík, joystick"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"načúvadlá, slabo počujúci, strata sluchu, kochleárne implantáty, zosilňovacie zariadenia, zvukové procesory, tiesňová linka"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"slabo počujúci, hluchota, titulky, ďalekopisný stroj, textový telefón"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"tri tlačidlá"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"zručnosť, motorický, senior, artritída, rsi, porážka, chvenie, roztrúsená skleróza, mozgová obrna, trasenie, zranenie z opakovaného namáhania, ruka"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"oneskorenie, zručnosť, senior"</string>
    <string name="print_settings" msgid="8519810615863882491">"Tlač"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Vypnutá"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{Je zapnutá 1 tlačová služba}few{Sú zapnuté # tlačové služby}many{# print services on}other{Je zapnutých # tlačových služieb}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 tlačová úloha}few{# tlačové úlohy}many{# print jobs}other{# tlačových úloh}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Tlačové služby"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nie sú nainštalované žiadne služby"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nenašli sa žiadne tlačiarne"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Nastavenia"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Pridať tlačiarne"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Zapnuté"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Vypnuté"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Pridať službu"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Pridať tlačiareň"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Hľadať"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Hľadajú sa tlačiarne"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Služba je vypnutá"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Tlačové úlohy"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Tlačová úloha"</string>
    <string name="print_restart" msgid="4424096106141083945">"Spustiť znova"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Zrušiť"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Konfiguruje sa úloha <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Prebieha tlač úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Prebieha zrušenie úlohy <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Chyba tlačiarne – úloha <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Tlačiareň zablok. úlohu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Vyhľadávacie pole je zobrazené"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Vyhľadávacie pole je skryté"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Ďalšie informácie o tejto tlačiarni"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Batéria"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Čo využíva batériu"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Zostáva <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do nabitia"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Čas používania"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Čas na pozadí"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Nízky stav batérie"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Povoliť aplikácii spúšťať sa na pozadí"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Obmedziť aktivitu na pozadí?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Ak obmedzíte aktivitu aplikácie na pozadí, nemusí fungovať správne"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Aplikácia nemá nastavenú optimalizáciu batérie, preto ju nemôžete obmedziť.\n\nAk ju chcete obmedziť, zapnite optimalizáciu."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Správa spotreby batérie"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Povoliť používanie na pozadí"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Zapnite pre aktualizácie v reálnom čase, vypnite na úsporu batérie"</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Bez obmedzení"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimalizované"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Obmedzené"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Povoliť spotrebu batérie na pozadí bez obmedzení. Môže sa spotrebúvať viac batérie."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimalizovať na základe vášho používania. Odporúča sa pre väčšinu aplikácií."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Obmedziť spotrebu batérie na pozadí. Aplikácia nemusí fungovať podľa očakávaní. Upozornenia môžu byť oneskorené."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Zmena spôsobu využívania batérie môže ovplyvniť jej výkonnosť."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Táto aplikácia vyžaduje spotrebu batérie v režime <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"bez obmedzení"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimalizované"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Ďalšie informácie o možnostiach spotreby batérie"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Využitie obrazovky od úplného nabitia"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Spotreba batérie"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Podrobnosti histórie"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Spotreba batérie"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Zobraziť spotrebu za posledných 24 h"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Zobraziť využitie od posledného úplného dobitia"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Spotreba batérie aplikáciou"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Využitie"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Upraviť spotrebu energie"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Zahrnuté balíčky"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikácie fungujú normálne"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Úroveň batérie je nízka"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Ak chcete predĺžiť výdrž batérie, zapnite šetrič batérie"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Zlepšite výdrž batérie"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Zapnúť správcu batérie"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Zapnúť šetrič batérie"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Batéria sa môže minúť skôr ako obvykle"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Šetrič batérie je zapnutý"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Ďalšie informácie o šetriči batérie"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Niektoré funkcie môžu byť obmedzené"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Vysoká spotreba batérie"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Prezrite si aplikácie s najvyššou spotrebou"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Nabíjanie je optimalizované, aby sa chránila batéria"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Nabíjanie je optimalizované, aby sa predĺžila životnosť batérie"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Ďalšie informácie o pozastavenom nabíjaní"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Pokračovať v nabíjaní"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Zahrnuje energeticky náročnú aktivitu na pozadí"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Obmedzenie # aplikácie}few{Obmedzenie # aplikácií}many{Restrict # apps}other{Obmedzenie # aplikácií}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{Aplikácia {label} bola nedávno obmedzená}few{# aplikácie boli nedávno obmedzené}many{# apps recently restricted}other{# aplikácií bolo nedávno obmedzených}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} má vysokú spotrebu batérie na pozadí}few{# aplikácie majú vysokú spotrebu batérie na pozadí}many{# apps have high background battery usage}other{# aplikácií má vysokú spotrebu batérie na pozadí}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Táto aplikácia sa nedá spustiť na pozadí}few{Tieto aplikácie sa nedajú spustiť na pozadí}many{Tieto aplikácie sa nedajú spustiť na pozadí}other{Tieto aplikácie sa nedajú spustiť na pozadí}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Chcete obmedziť aplikáciu?}few{Chcete obmedziť # aplikácie?}many{Restrict # apps?}other{Chcete obmedziť # aplikácií?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Ak chcete ušetriť batériu, zakážte aplikácii <xliff:g id="APP">%1$s</xliff:g> využívať ju na pozadí. Táto aplikácia nemusí fungovať správne a upozornenia môžu byť oneskorené."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Ak chcete ušetriť batériu, zakážte týmto aplikáciám využívať ju na pozadí. Obmedzené aplikácie nemusia správne fungovať a upozornenia môžu byť oneskorené.\n\nAplikácie:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Ak chcete ušetriť batériu, zakážte týmto aplikáciám využívať ju na pozadí. Obmedzené aplikácie nemusia správne fungovať a upozornenia môžu byť oneskorené.\n\nAplikácie:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Obmedziť"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Odstrániť obmedzenie?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Aplikácia bude môcť využívať batériu na pozadí. Batéria sa môže minúť skôr, ako sa očakávalo."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Odstrániť"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Zrušiť"</string>
    <string name="battery_tip_charge_to_full_button" msgid="9172893341338732733">"Prepísať"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="1567827436103364999">"Skontrolujte nabíjacie príslušenstvo"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Ďalšie informácie o nekompatibilnom nabíjaní"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Správca batérie"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Spravovať aplikácie automaticky"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Keď správca batérie zistí, že aplikácie nadmerne vybíjajú batériu, zobrazí sa možnosť ich obmedziť. Obmedzené aplikácie nemusia správne fungovať a upozornenia môžu byť oneskorené."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Obmedzené aplikácie"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Obmedzovanie spotreby batérie pre # aplikáciu}few{Obmedzovanie spotreby batérie pre # aplikácie}many{Limiting battery usage for # apps}other{Obmedzovanie spotreby batérie pre # aplikácií}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Obmedzené <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Tieto aplikácie majú obmedzenú spotrebu batérie na pozadí. Nemusia fungovať podľa očakávaní a upozornenia môžu byť oneskorené."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Použiť správcu batérie"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Zistite, keď aplikácie nadmerne vybíjajú batériu"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Rozpoznáva sa, kedy aplikácie nadmerne spotrebúvajú batériu"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Rozpoznáva sa, kedy aplikácie nadmerne spotrebúvajú batériu"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{Bola obmedzená # aplikácia}few{Boli obmedzené # aplikácie}many{# apps restricted}other{Bolo obmedzených # aplikácií}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Pri čítaní merača batérie sa vyskytol problém."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Klepnutím získate ďalšie informácie o tejto chybe"</string>
    <string name="power_screen" msgid="4596900105850963806">"Obrazovka"</string>
    <string name="power_cpu" msgid="1820472721627148746">"Procesor"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Baterka"</string>
    <string name="power_camera" msgid="4778315081581293923">"Fotoaparát"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobilná sieť"</string>
    <string name="power_phone" msgid="2768396619208561670">"Hlasové hovory"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Využitie obrazovky <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> využila aplikácia <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> celkovej výdrže batérie"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Prehľad od posledného úplného nabitia"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Posledné úplné nabitie"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Úplné nabitie vydrží približne"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Zostávajúca výdrž batérie je približná a môže sa meniť podľa používania"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Spotreba batérie"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Bez použitia od posledného úplného dobitia"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Žiadne použitie za posledných 24 hodín"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"od posledného úplného nabitia"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Systémové aplikácie"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Odinštalované aplikácie"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Iné"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Odhadovaný zostávajúci čas:"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Do úplného dobitia"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Odhad sa môže líšiť v závislosti od intenzity využitia"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimalizácia aplikácií"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Zdieľanie dátového pripojenia"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Odstránené aplikácie"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Šetrič batérie"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Zapnúť automaticky"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Žiadny plán"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Podľa vášho bežného správania"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Zapne sa podľa vášho správania"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Podľa percent"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Ak je pravdepodobné, že sa batéria pred opätovným pripojením do siete vybije, zapne sa šetrič batérie."</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Zapne sa na úrovni <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Nastavenie plánu"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Predĺženie výdrže batérie"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Vypnúť po nabití"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Vypnúť pri <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Vypnúť šetrič batérie, keď úroven nabitia dosiahne <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Zapnúť"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Používať šetrič batérie"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Zapínať automaticky"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nikdy"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"pri <xliff:g id="PERCENT">%1$s</xliff:g> batérie"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Percentá batérie"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Zobrazovať percentá v stavovom riadku"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Stav batérie od posledného úplného nabitia"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Úroveň batérie za posledných 24 hodín"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Používanie aplikácie od posledného úplného nabitia"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Spotreba batérie aplikáciami za posledných 24 h"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Využitie systému od posledného úplného dobitia"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Spotreba batérie systémom za posledných 24 h"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Spotreba batérie systémom: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Spotreba batérie aplikáciou: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Využitie systému od posledného úplného nabitia do <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Využitie aplikácie od posledného úplného nabitia do <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Celkove: menej ako minúta"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Na pozadí: menej ako minúta"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Čas používania: menej ako minúta"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Menej ako minúta"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Celkove: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Na pozadí: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Čas používania: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Údaje o spotrebe batérie budú k dispozícii o niekoľko hodín, keď bude úplne nabitá"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"teraz"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> – <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>"</string>
    <string name="battery_usage_time_info_and_battery_level" msgid="6732629268310936155">"<xliff:g id="TIME_INFO">%1$s</xliff:g> <xliff:g id="BATTERY_LEVEL">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Graf spotreby batérie"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Graf spotreby batérie za deň"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Graf spotreby batérie za hodinu"</string>
    <string name="battery_level_percentage" msgid="1433178290838842146">"Percento stavu batérie: od <xliff:g id="START_PERCENTAGE">%1$s</xliff:g> do <xliff:g id="END_PERCENTAGE">%2$s</xliff:g>"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Spotreba batérie od posledného úplného nabitia"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Spotreba batérie: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Čas používania od posledného úplného nabitia"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Čas používania: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Zobraziť podľa aplikácií"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Zobraziť podľa systémov"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"Pred odoslaním sa vykonáva kontrola kvality, preto nemusí byť pri prvom použití počet cyklov nulový"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Štatistiky procesov"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Podrobné štatistiky spustených procesov"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Využitie pamäte"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Využité miesto za posled. <xliff:g id="TIMEDURATION">%3$s</xliff:g>: <xliff:g id="USEDRAM">%1$s</xliff:g> z <xliff:g id="TOTALRAM">%2$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"Počas <xliff:g id="TIMEDURATION">%2$s</xliff:g> sa použilo <xliff:g id="PERCENT">%1$s</xliff:g> RAM"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Na pozadí"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Na popredí"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Vo vyr. pamäti"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"OS Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Natívne"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Jadro"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Vyrovnávacie pamäte"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Využitie RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Využitie RAM (pozadie)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Spustené"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesy"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Služby"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Trvanie"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Podrobnosti o pamäti"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 hodiny"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 hodín"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 hodín"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 deň"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Zobraziť systémové"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Skryť systémové"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Zobraziť percentá"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Použiť Uss (jedinečnú veľkosť súpravy)"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Typ štatistík"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Na pozadí"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Na popredí"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Vo vyr. pamäti"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Hlasový vstup a výstup"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Nastavenia hlasového vstupu a výstupu"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Hlasové vyhľadávanie"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Klávesnica Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Nastavenia hlasového vstupu"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Hlasový vstup"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Služby hlasového vstupu"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Úplná aktivácia kľúčových slov a interakcia"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Jednoduchý prevod reči na text"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Táto služba hlasového vstupu bude môcť neustále monitorovať hlas a ovládať za vás aplikácie so zapnutým hlasovým vstupom. Pochádza z aplikácie <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Chcete povoliť používanie tejto služby?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Nastavenia rozpoznávania v zariadení"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Rozpoznávanie v zariadení"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Rozpoznávanie reči v zariadení"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Preferovaný nástroj"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Nastavenia nástroja"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Rýchlosť reči a výška hlasu"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Nástroj"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Hlasy"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Hovorený jazyk"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Inštalácia hlasov"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Ak chcete nainštalovať hlasy, otvorte aplikáciu <xliff:g id="TTS_APP_NAME">%s</xliff:g>"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Otvoriť aplikáciu"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Zrušiť"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Resetovať"</string>
    <string name="tts_play" msgid="2945513377250757221">"Prehrať"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Nezabezpečené"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"Nezabezpečené: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"Nezabezpečené: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Adaptívne pripojenie"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Predĺži výdrž batérie a zvýši výkonnosť zariadenia automatickým spravovaním pripojení k sieti"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Zapnuté"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Vypnúť"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Používať adaptívne pripojenie"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Úložisko prihlasovacích údajov"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Inštalovať certifikát"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Vymazať prihlasovacie údaje"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Odstrániť všetky certifikáty"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Dôveryhodné prihlasovacie údaje"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Zobraziť dôveryhodné certifikáty CA"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Prihlasovacie údaje používateľa"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Zobraziť a zmeniť uložené prihlasovacie údaje"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Rozšírené"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Poverenia nie sú pre tohto používateľa k dispozícii"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Nainštalované pre sieť VPN a aplikácie"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Nainštalované pre Wi‑Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Nainštalované pre Wi‑Fi (používa sa)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Chcete odstrániť všetok obsah?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Úložisko poverení bolo vymazané"</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Úlož. poverení nemožno vymazať"</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Prístup k údajom o používaní"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certifikát CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Certifikát použív. VPN a apl."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certifikát Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Vaše údaje nebudú súkromné"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Certifikáty CA využívajú weby, aplikácie a siete VPN na šifrovanie. Inštalujte iba certifikáty CA od organizácií, ktorým dôverujete. \n\nAk si nainštalujete certifikát CA, vlastník certifikátu by mohol získať prístup k vašim údajom, napríklad k heslám, či podrobnostiam kreditnej karty z webov alebo aplikácií, ktoré používate, a to aj vtedy, ak sú vaše údaje šifrované."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Neinštalovať"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Inštalovať aj tak"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certifikát nie je nainštalovaný"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Chcete aplikácii "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" povoliť nainštalovať certifikáty v tomto zariadení?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Tieto certifikáty vás overia zdieľaním jedinečného identifikátora vášho zariadenia s aplikáciami a webovými adresami nižšie"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Nepovoliť"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Povoliť"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Zobraziť viac"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Aplik. na správu certifikátov"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Žiadne"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Certifikáty vás overia pri používaní aplikácií a webových adries nižšie"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Odinštalovať certifikáty"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Odstrániť aplikáciu"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Odstrániť túto aplikáciu?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Táto aplikácia nebude spravovať certifikáty, ale zostane vo vašom zariadení. Všetky certifikáty nainštalované touto aplikáciou budú odinštalované."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# webová adresa}few{# webové adresy}many{# URLs}other{# webových adries}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Signál núdzového vytáčania"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Nastaviť správanie pri tiesňovom volaní"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Zálohovanie"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Zálohovať a obnoviť"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Osobné údaje"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Zálohovať moje dáta"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Zálohovať dáta aplikácií, heslá Wi‑Fi a ďalšie nastavenia na serveroch Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Zálohovací účet"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Správa záložného účtu"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Zahrnúť dáta aplikácií"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automaticky obnovovať"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Pri preinštalovaní aplikácie obnoviť zálohované nastavenia a dáta"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Služba zálohovania nie je aktívna"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Momentálne nie sú záložné údaje ukladané do žiadneho účtu"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Chcete zastaviť zálohovanie hesiel Wi‑Fi, záložiek, ďalších nastavení a dát aplikácií? Chcete vymazať všetky kópie na serveroch Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Chcete zastaviť zálohovanie dát zariadenia (ako sú heslá Wi‑Fi a história hovorov) a dát aplikácií (ako sú nastavenia a súbory uložené aplikáciami)? Chcete vymazať všetky kópie na vzdialených serveroch?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Automaticky vzdialene zálohujte údaje zariadenia (napr. heslá do sietí Wi‑Fi a históriu hovorov) a údaje aplikácií (napr. nastavenia a súbory uložené aplikáciami). \n\nKeď zapnete automatické zálohovanie, údaje zariadenia a aplikácií sa budú pravidelne vzdialene ukladať. Údaje aplikácie môžu byť ľubovoľné informácie uložené aplikáciou (na základe nastavení vývojára) aj potenciálne citlivé údaje, ako sú kontakty, správy a fotky."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Nastavenia správcu zariadenia"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Aplikácia na správu zariadenia"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktivovať túto aplikáciu na správu zariadenia"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Odinštalovať aplikáciu"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktivovať a odinštalovať"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Aplikácie na správu zariadenia"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"K dispozícii nie sú žiadne aplikácie na správu zariadenia"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nie sú k dispozícii žiadne agenty dôvery"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktivovať aplikáciu na správu zariadenia?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktivovať túto aplikáciu na správu zariadenia"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Správca zariadenia"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Aktiváciou tejto aplikácie na správu zariadenia umožníte aplikácii <xliff:g id="APP_NAME">%1$s</xliff:g> vykonávať nasledujúce operácie:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Toto zariadenie bude spravovať a monitorovať aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Aplikácia na správu zariadenia je aktívna a umožňuje aplikácii <xliff:g id="APP_NAME">%1$s</xliff:g> vykonávať nasledujúce operácie:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Aktivovať aplikáciu Správca profilu?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Chcete povoliť dohľad?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ak budete pokračovať, vášho používateľa bude spravovať správca, ktorý bude môcť okrem vašich osobných údajov ukladať tiež združené údaje.\n\nSprávca môže sledovať a spravovať nastavenia, prístup, aplikácie a údaje priradené k tomuto používateľovi (vrátane aktivity siete a informácií o polohe vášho zariadenia)."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Ďalšie možnosti zakázal váš správca."</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Ďalšie informácie"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Denník upozornení"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"História upozornení"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Posledné hodiny (%d)"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Odložené"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nedávno zavreté"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# upozornenie}few{# upozornenia}many{# notifications}other{# upozornení}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Tón zvonenia a vibrovanie"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Podrobnosti siete"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Synchronizácia je povolená"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Synchronizácia bola zakázaná"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Synchronizuje sa…"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Chyba synchronizácie"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Synchronizácia zlyhala"</string>
    <string name="sync_active" msgid="5787407579281739975">"Synchronizácia je aktívna"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Synchronizácia"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Vyskytli sa problémy so synchronizáciou. Služba bude čoskoro obnovená."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Pridať účet"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Pracovný profil zatiaľ nie je k dispozícii"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Pracovné aplikácie"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Odstrániť pracovný profil"</string>
    <string name="background_data" msgid="321903213000101158">"Dátové prenosy na pozadí"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikácie môžu kedykoľvek synchronizovať, odosielať a prijímať údaje"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Vypnúť prenosy na pozadí?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Vypnutie dátových prenosov na pozadí šetrí batériu a znižuje spotrebu dát. Niektoré aplikácie môžu používať dátové prenosy na pozadí aj napriek tomuto nastaveniu."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Synchronizácia zapnutá"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Synchronizácia vypnutá"</string>
    <string name="sync_error" msgid="846923369794727644">"Chyba synchronizácie"</string>
    <string name="last_synced" msgid="1527008461298110443">"Posledná synchronizácia <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Synchronizuje sa…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Zálohovať nastavenia"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Zálohovať moje nastavenia"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Synchronizovať"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Zrušiť synchronizáciu"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Klepnutím synchronizujete (<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>)"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalendár"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontakty"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Nastavenia synchronizácie aplikácie"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Údaje a synchronizácia"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Zmeniť heslo"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Nastavenia účtu"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Odstrániť účet"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Pridať účet"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Chcete účet odstrániť?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Správca túto zmenu zakázal"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Nie je možné ručne synchronizovať"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Synchronizácia tejto položky je momentálne zakázaná. Ak chcete toto nastavenie zmeniť, dočasne zapnite dátové prenosy na pozadí a automatickú synchronizáciu."</string>
    <string name="delete" msgid="8330605554706263775">"Odstrániť"</string>
    <string name="select_all" msgid="7898929601615536401">"Vybrať všetko"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Spotreba dát"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobilné dáta a Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Autom. synchr. osobné údaje"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Autom. synchr. pracovné údaje"</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Aut. synchrizovať súkr. údaje"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Zmeniť cyklus..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Deň v mesiaci, kedy sa má resetovať cyklus spotreby:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"V tomto období nevyužili dátové pripojenie žiadne aplikácie."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Na popredí"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Na pozadí"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"obmedzené"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Chcete vypnúť mobilné dáta?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Nastaviť dát. limit mobil. sietí"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Nastaviť dátový limit siete 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Nastaviť dát. limit sietí 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Nastaviť dát. limit Wi‑Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobilné"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobilné"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Žiadne"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobilné dáta"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Dátové prenosy 2G a 3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Dátové prenosy 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Na popredí:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Na pozadí:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Nastavenia aplikácie"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Dáta na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Povoliť používanie mobilných dát na pozadí"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Nastav. dát. limitu mob. siete obmedzíte údaje na poz. pre apl."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Obmedziť prenosy na pozadí?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Ak budú k dispozícii len mobilné siete, môže táto funkcia spôsobiť, že aplikácie, ktoré údaje na pozadí vyžadujú, nebudú fungovať.\n\nVhodnejšie spôsoby ovládania využívania údajov nájdete v nastaveniach aplikácie."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Obmedzenie dátových prenosov na pozadí je možné len v prípade, že ste nastavili dátový limit pre mobilnú sieť."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Zapnúť automatickú synch. údajov?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Vypnúť automatickú synch. údajov?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Toto nastavenie šetrí spotrebu dát a batérie. Na získanie najnovších informácií však budete musieť každý účet synchronizovať ručne. Nebudete tiež dostávať upozornenia o aktualizáciách."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Dátum resetovania cyklu spotreby"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Dátum v každom mesiaci:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Nastaviť"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Upozornenie na spotrebu dát"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Limit spotreby dát"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Obmedzenie spotreby dát"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"upozorn."</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"limit"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Odstránené aplikácie"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Odstránené aplikácie a používatelia"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Využitie siete"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Merané"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Názov"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Typ"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresa servera"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identifikátor protokolu IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Predzdieľaný kľúč protokolu IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Používateľský certifikát protokolu IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certifikát CA protokolu IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certifikát servera IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Zobraziť rozšírené možnosti"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Používateľské meno"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Heslo"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Uložiť informácie o účte"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(nepoužité)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(neoverovať server)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(prijatý zo servera)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Zadané informácie nepodporujú vždy zapnuté siete VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Zrušiť"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Zavrieť"</string>
    <string name="vpn_save" msgid="683868204634860888">"Uložiť"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Pripojiť"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Nahradiť"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Upraviť profil VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Zabudnúť"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Pripojiť k profilu <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Odpojiť tento profil VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Odpojiť"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Verzia"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Zabudnúť profil VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Nahradiť existujúcu sieť VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Nastaviť sieť VPN, ktorá je vždy zapnutá?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Keď je toto nastavenie zapnuté, nebudete mať internetové pripojenie, dokým sa úspešne nenadviaže pripojenie VPN"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Súčasná sieť VPN bude nahradená a nebudete mať internetové pripojenie, dokým sa úspešne nenadviaže pripojenie VPN"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"K sieti VPN, ktorá je vždy zapnutá, ste sa už pripojili. Ak sa pripojíte k inej sieti, vaša súčasná sieť VPN bude nahradená a vypne sa režim vždy zapnutej siete."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"K sieti VPN ste sa už pripojili. Ak sa pripojíte k inej sieti, vaša súčasná sieť VPN bude nahradená."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Zapnúť"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> nie je možné pripojiť"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Táto aplikácia nepodporuje siete VPN, ktoré sú vždy zapnuté"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Pridať profil siete VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Upraviť profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Odstrániť profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Vždy zapnutá VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Neboli pridané žiadne siete VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Udržiavať neustále pripojenie k sieti VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Nepodporované touto aplikáciou"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Vždy zapnuté"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Nezabezpečené"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokovať pripojenia bez siete VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Vyžadovať pripojenie VPN?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Nezabezpečené. Aktualizujte na IKEv2 VPN."</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Nepodporovanú sieť VPN sa nepodarilo spustiť."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Vyberte profil VPN, ku ktorému chcete mať vždy pripojenie. Sieťová premávka bude povolená len v prípade pripojenia k tejto sieti VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Žiadna"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Vždy zapnutá sieť VPN vyžaduje adresu IP pre server aj DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nie je k dispozícii žiadne sieťové pripojenie. Skúste to neskôr."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Odpojiť od siete VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Žiadne"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Chýba certifikát. Skúste upraviť profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Systém"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Používateľ"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Deaktivovať"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Povoliť"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Odinštalovať"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Dôverovať"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Povoliť systémový certifikát CA?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Zakázať systémový certifikát CA?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Natrvalo odstrániť používateľský certifikát CA?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Používa:"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Tento záznam obsahuje"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 kľúč používateľa"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 certifikát používateľa"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 Certifikát CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"certifikáty CA (%d)"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Podrobnosti o povereniach"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Odstránené poverenie: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nie sú nainštalované žiadne poverenia používateľa"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Kontrola pravopisu"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Kontrola pravopisu pre prácu"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Tu zadajte aktuálne heslo pre úplné zálohy"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Tu zadajte nové heslo pre úplné zálohy"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Tu zadajte znova nové heslo pre úplné zálohy"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Nastaviť heslo"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Zrušiť"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Ďalšie aktualizácie systému"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Sieť môže byť monitorovaná"</string>
    <string name="done_button" msgid="6269449526248267">"Hotovo"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Nastavte certifikát ako dôveryhodný alebo ho odstráňte}few{Nastavte certifikáty ako dôveryhodné alebo ich odstráňte}many{Nastavte certifikáty ako dôveryhodné alebo ich odstráňte}other{Nastavte certifikáty ako dôveryhodné alebo ich odstráňte}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{Doména {orgName} nainštalovala do vášho zariadenia certifikačnú autoritu, ktorá jej umožní monitorovať aktivitu v sieti zariadenia vrátane pošty, aplikácií a zabezpečených webov.\n\nViac o tomto certifikáte sa dozviete od svojho správcu.}few{Doména {orgName} nainštalovala do vášho zariadenia certifikačné autority, ktoré jej umožnia monitorovať aktivitu v sieti zariadenia vrátane pošty, aplikácií a zabezpečených webov.\n\nViac o týchto certifikátoch sa dozviete od svojho správcu.}many{Doména {orgName} nainštalovala do vášho zariadenia certifikačné autority, ktoré jej umožnia monitorovať aktivitu v sieti zariadenia vrátane pošty, aplikácií a zabezpečených webov.\n\nViac o týchto certifikátoch sa dozviete od svojho správcu.}other{Doména {orgName} nainštalovala do vášho zariadenia certifikačné autority, ktoré jej umožnia monitorovať aktivitu v sieti zariadenia vrátane pošty, aplikácií a zabezpečených webov.\n\nViac o týchto certifikátoch sa dozviete od svojho správcu.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{Doména {orgName} nainštalovala pre váš pracovný profil certifikačnú autoritu, ktorá jej môže umožniť monitorovať aktivitu v pracovnej sieti vrátane pošty, aplikácií a zabezpečených webov.\n\nViac o tomto certifikáte sa dozviete od svojho správcu.}few{Doména {orgName} nainštalovala pre váš pracovný profil certifikačné autority, ktoré jej môžu umožniť monitorovať aktivitu v pracovnej sieti vrátane pošty, aplikácií a zabezpečených webov.\n\nViac o týchto certifikátoch sa dozviete od svojho správcu.}many{Doména {orgName} nainštalovala pre váš pracovný profil certifikačné autority, ktoré jej môžu umožniť monitorovať aktivitu v pracovnej sieti vrátane pošty, aplikácií a zabezpečených webov.\n\nViac o týchto certifikátoch sa dozviete od svojho správcu.}other{Doména {orgName} nainštalovala pre váš pracovný profil certifikačné autority, ktoré jej môžu umožniť monitorovať aktivitu v pracovnej sieti vrátane pošty, aplikácií a zabezpečených webov.\n\nViac o týchto certifikátoch sa dozviete od svojho správcu.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Vaša aktivita v sieti, vrátane e-mailov, aplikácií a zabezpečených webov môže byť monitorovaná treťou stranou.\n\nUmožňujú to dôveryhodné poverenia nainštalované vo vašom zariadení."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Skontrolovať certifikát}few{Skontrolovať certifikáty}many{Skontrolovať certifikáty}other{Skontrolovať certifikáty}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Viacerí používatelia"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Používatelia a profily"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Pridať používateľa alebo profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Obmedzený profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nenastavené"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Nie je nastavený – obmedzený profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Pracovný profil (nie je nastavený)"</string>
    <string name="user_admin" msgid="4024553191395768119">"Správca"</string>
    <string name="user_you" msgid="3070562015202859996">"Vy (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Nemôžete pridať žiadnych ďalších používateľov. Ak chcete pridať nového, odoberte existujúceho."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Profily s obmedzeniami nemôžu pridávať účty"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Odstrániť zo zariadenia (<xliff:g id="USER_NAME">%1$s</xliff:g>)"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Nastavenia uzamknutej obrazovky"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Pridávať používateľov z uzamknutej obrazovky"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"V doku prepnúť na správcu"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Chcete odstrániť svoj profil?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Chcete odobrať tohto používateľa?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Odstrániť tento profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Odstrániť pracovný profil?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Všetky aplikácie a dáta budú odstránené."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Ak budete pokračovať, všetky aplikácie a údaje v tomto profile budú odstránené."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Všetky aplikácie a dáta budú odstránené."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Pridáv. nového používateľa..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Odobrať používateľa"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Odstrániť"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Všetky aplikácie a údaje v tejto relácii budú odstránené."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Odstrániť"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Hosť (vy)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Používatelia"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Ďalší používatelia"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Odstrániť aktivitu hosťa"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Odstrániť všetky aplikácie a údaje hosťa pri ukončení režimu pre hostí"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Chcete odstrániť aktivitu hosťa?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Aplikácie a údaje z tejto relácie hosťa sa teraz odstránia a budúca aktivita hosťa sa odstráni vždy pri ukončení režimu pre hostí"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"odstrániť, hosť, aktivita, odobrať, údaje, návštevník, vymazať"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Povoliť hosťom volať"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"S hosťom sa bude zdieľať história hovorov"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Zapnúť telefonáty a SMS"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Nastaviť tohto používateľa ako správcu"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Odobrať používateľa"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Zapnúť telefonické hovory a správy SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"S týmto používateľom sa bude zdieľať história hovorov a správ SMS."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Chcete odstrániť správcovské oprávnenia?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Ak tomuto používateľovi odoberiete správcovské oprávnenia, vy alebo iný správca mu ich môžete neskôr vrátiť."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Tiesňové informácie"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informácie a kontakty používateľa <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Otvoriť aplikáciu <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Povoliť aplikácie a obsah"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikácie s obmedzením"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Rozbaliť nastavenia aplikácie"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Vyberte aplikácie na inštaláciu"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Inštalovať dostupné aplikácie"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Bezkontaktné platby"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Predvolená platobná aplikácia"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Ak chcete zaplatiť platobnou aplikáciou, priložte zariadenie zadnou stranou k platobnému terminálu"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Ďalšie informácie"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Nastaviť pracovnú aplikáciu ako predvolenú platobnú aplikáciu?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Ak chcete zaplatiť pracovnou aplikáciou:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"musí byť zapnutý pracovný profil;"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"ak v pracovnom účte používate kód PIN, vzor alebo heslo, budete ho musieť zadať."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Ako to funguje"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Plaťte v obchodoch telefónom"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Predvolená platobná aplikácia"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nenastavené"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Použiť predvolenú platobnú aplikáciu"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Použiť predvolenú platobnú aplikáciu"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Vždy"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Iba keď nie je spustená iná platobná aplikácia"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Pri bezkontaktnom termináli zaplatiť pomocou aplikácie:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Platenie pri termináli"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Nastavte si platobnú aplikáciu. Potom iba priložte zadnú časť svojho telefónu k akémukoľvek terminálu so symbolom pre bezkontaktné platby."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Dobre"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Viac…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Nastavenie predvolenej platobnej aplikácie"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Aktualizácia predvolenej platobnej aplikácie"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Pri bezkontaktnom termináli zaplaťte pomocou aplikácie <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Pri bezkontaktnom termináli zaplaťte pomocou aplikácie <xliff:g id="APP_0">%1$s</xliff:g>.\n\nNahradí sa tým vaša predvolená platobná aplikácia <xliff:g id="APP_1">%2$s</xliff:g>."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Nastaviť ako predvolené"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Aktualizovať"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Práca"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Obmedzenia"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Odstrániť obmedzenia"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Zmeniť kód PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Pomocník a spät. väzba"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Účet pre obsah"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID fotografie"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Extrémne hrozby"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Prijímať upozornenia na extrémne ohrozenie života a majetku"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Závažné hrozby"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Prijímať upozornenia na závažné ohrozenie života a majetku"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Upozornenia Amber"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Prijímať bulletiny o únosoch detí"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Opakovať"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Bezdrôtové núdzové upozornenia"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Sieťoví operátori"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Názvy prístupových bodov"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Rozšírené volanie"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Volanie cez 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Používať na zlepšenie hlasových hovorov služby LTE (odporúčané)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Používať na zlepšenie hlasových hovorov služby 4G (odporúčané)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Volajte cez 5G"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Odosielať kontakty operátorovi"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Odosielajte telefónne čísla svojich kontaktov na poskytovanie rozšírených funkcií"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Chcete odosielať kontakty operátorovi <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Chcete odosielať kontakty svojmu operátorovi?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Telefónne čísla vašich kontaktov budú pravidelne odosielané operátorovi <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Tieto informácie určujú, či vaše kontakty môžu používať určité funkcie, napríklad videohovory alebo niektoré funkcie správ."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Telefónne čísla vašich kontaktov budú pravidelne odosielané vášmu operátorovi.<xliff:g id="EMPTY_LINE">

</xliff:g>Tieto informácie určujú, či vaše kontakty môžu používať určité funkcie, napríklad videohovory alebo niektoré funkcie správ."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Preferovaný typ siete"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (odporúčané)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Správy MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Odosielať aj prijímať, keď sú mobilné dáta deaktivované"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Automaticky prepínať mobilné dáta"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Používať túto sieť, keď má lepšiu dostupnosť"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Pracovná SIM karta"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Prístup k aplikáciám a obsahu"</string>
    <string name="user_rename" msgid="8735940847878484249">"PREMENOVAŤ"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Nastaviť obmedzenia aplikácií"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Riadi: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Táto aplikácia má prístup k vašim účtom"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Táto aplikácia má prístup k vašim účtom. Riadené aplikáciou <xliff:g id="APP">%1$s</xliff:g>."</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Siete Wi‑Fi a mobilné siete"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Povoliť úpravu nastavení sietí Wi‑Fi a mobilných sietí"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Povoliť úpravy párovania a nastavení rozhrania Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Poloha"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Povoliť aplikáciám používať informácie o polohe"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Späť"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Ďalej"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formátovať iným spôsobom"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM karty"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobilné dáta nie sú k dispozícii"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Klepnutím vyberiete dátovú SIM kartu"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Vždy používať pre hovory"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Vyberte SIM na mobilné dáta"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Vybrať SIM kartu pre SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Prepínajú sa dátové SIM karty, môže to chvíľu trvať…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Chcete používať <xliff:g id="NEW_SIM">%1$s</xliff:g> na mobilné dáta?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Ak prepnete na <xliff:g id="NEW_SIM">%1$s</xliff:g>, <xliff:g id="OLD_SIM">%2$s</xliff:g> sa už nebude používať na mobilné dáta."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Použiť <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Volať pomocou služby"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Zadajte názov SIM karty"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Slot pre SIM kartu %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranžová"</string>
    <string name="color_purple" msgid="6603701972079904843">"Purpurová"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Stav SIM karty"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Stav SIM karty (slot na SIM kartu %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="6839556577405929262">"SIM karty boli vymenené"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Klepnutím prejdete do Nastavení"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Vždy sa opýtať"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Vyžaduje sa výber"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Výber SIM karty"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Nastavenia"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Sieť a internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobilné dáta, Wi‑Fi, hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi, hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Pripojené zariadenia"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, párovanie"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, režim v aute, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, režim v aute"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, režim v aute, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, režim v aute"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Nedostupné, pretože technológia NFC je vypnutá"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Pred použitím nainštalujte platobnú aplikáciu"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nedávne aplikácie, predvolené aplikácie"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Prístup k upozorneniam nie je k dispozícii pre aplikácie v pracovnom profile."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Heslá a účty"</string>
    <string name="account_dashboard_default_summary" msgid="7976899924144356939">"Návrhy prihlásenia a automatického dopĺňania"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Predvolené aplikácie"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Klonované aplikácie"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Vytvorte druhú inštanciu aplikácie, aby ste mohli súčasne používať dva účty."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Aplikácie, ktoré sa dajú klonovať"</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"Naklonované: <xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g>, k dispozícii na klonovanie: <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g>"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Odstrániť všetky klony aplikácie"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Nepodarilo sa odstrániť klony aplikácie"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Vytvára sa…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Klon"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Klon <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> sa vytvára"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Klon <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> bol vytvorený"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Jazyky, gestá, čas, záloha"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Jazyky systému, jazyky aplikácií, regionálne nastavenia, reč"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, sieťové pripojenie, internet, bezdrôtové, dáta, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Upozornenie Wi‑Fi, upozornenie wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"spotreba dát"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Používať 24-hodinový formát"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Otvoriť v aplikácii"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikácie"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"časové pásmo"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Záhlavie četu, systém, upozornenie, okno, dialógové okno, zobrazenie, nad inými aplikáciami, vykreslenie"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Svietidlo, svetlo, baterka"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, prepínač, ovládanie"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilné, mobil, mobilný operátor, bezdrôtové, dáta, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, hovor, volanie"</string>
    <string name="keywords_display" msgid="874738809280751745">"obrazovka, dotyková obrazovka"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"stlmiť obrazovku, dotyková obrazovka, batéria, svetlá"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"stlmiť obrazovku, noc, tónovanie, nočný režim, jas, farba obrazovky, farba, farby"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"pozadie, prispôsobenie, prispôsobiť obrazovku"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"veľkosť textu"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"premietanie, prenos, zrkadlenie obrazovky, zdieľanie obrazovky, zrkadlenie, zdieľať obrazovku, prenášanie obrazovky"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"miesto, disk, pevný disk, zariadenie, využitie"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"spotreba energie, nabíjanie"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"zobraziť spotrebu batérie, spotreba batérie, spotreba energie"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"šetrič batérie, šetrič energie, šetrič"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"predvoľby adaptácie, adaptácia batérie"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"pravopis, slovník, kontrola pravopisu, automatické opravy"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"rozpoznávač, vstup, reč, hovoriť, jazyk, súprava hands-free, hand free, rozpoznávanie, nevhodné, slovo, zvuk, história, náhlavná súprava bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"sadzba, jazyk, predvolené, reč, hovoriť, tts, dostupnosť, čítačka, zrakovo postihnutí"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"čas, vojenský"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"resetovať, obnoviť, továrenské nastavenia"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"trvale vymazať, odstrániť, obnoviť, vymazať, odobrať, obnoviť výrobné nastavenia"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"tlačiareň"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"zvukový signál reproduktora, reproduktor, hlasitosť, vypnúť zvuk, stíšenie, zvuk, hudba, hmatová odozva, vibrátor, vibrovať"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"nie, nerušiť, vyrušiť, vyrušenie, prerušenie"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"nablízku, poloha, história, nahlasovanie, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"účet, pridanie účtu, pracovný profil, pridať účet, vymazať, odstrániť"</string>
    <string name="keywords_users" msgid="3497517660077620843">"obmedzenie, obmedziť, obmedzené"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"oprava textu, opraviť, zvuk, vibrácie, automatický výber, jazyk, gesto, navrhnúť, návrh, motív, urážlivé slovo, typ, emodži, medzinárodné"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"resetovať, nastavenia, predvolené"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"aplikácie, sťahovanie, aplikácie, systém"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikácie, povolenia, bežpečnosť"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikácie, predvolené"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorovať optimalizácie, spánok, pohotovostný režim aplikácie"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"sýta, RGB, sRGB, farba, naturálna, štandardná"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, rozlíšenie, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"farby, teplota, D65, D73, biela, žltá, modrá, teplá, studená"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"odomknúť prejdením prstom, heslo, vzor, pin"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"pripnutie obrazovky"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"pracovná výzva, práca, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"pracovný profil, spravovaný profil, zjednotiť, zjednotenie, práca, profil"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"prebudený, spánok, nezamykať, ponechať odomknuté po zložení, zloženie, zavretie, zavrieť, vypnúť obrazovku"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestá"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"peňaženka"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"platiť, klepnutie, platby"</string>
    <string name="keywords_backup" msgid="707735920706667685">"záloha, zálohovanie"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"tvár, odomknutie, overenie totožnosti, prihlásenie"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"tvár, odomknúť, overiť, prihlásiť sa, odtlačok prsta, biometria"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, verzia prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"sieť, stav mobilnej siete, stav služby, sila signálu, typ mobilnej siete, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"sieť, stav mobilnej siete, stav služby, sila signálu, typ mobilnej siete, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"sieť, stav mobilnej siete, stav služby, sila signálu, typ mobilnej siete, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"sieť, stav mobilnej siete, stav služby, sila signálu, typ mobilnej siete, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"sériové číslo, hardvérová verzia"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"informácie o batérii, dátum výroby, počet cyklov, prvé použitie"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"úroveň opráv zabezpečenia androidu, verzia základného pásma, verzia jadra"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"motív, svetlý, tmavý, režim, svetloplachosť, fotofóbia, stmaviť, tmavý režim, migréna"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tmavý motív"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"chyba"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Ambientné zobrazenie, zobrazenie uzamknutej obrazovky"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"upozornenie na uzamknutej obrazovke, upozornenia"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"tvár"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"odtlačok prsta, pridať odtlačok prsta"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"tvár, odtlačok prsta, pridať odtlačok prsta"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"odomknutie hodinkami, pridanie odomknutia hodinkami"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"stmavenie obrazovky, dotyková obrazovka, batéria, inteligentný jas, dynamický jas, automatický jas"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"inteligentné, stlmiť obrazovku, spánok, batéria, časový limit, vnímavá, displej, obrazovka, nečinnosť"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"fotoaparát, inteligentné, automatické otáčanie, automaticky otočiť, otočiť, prevrátiť, otočenie, na výšku, na šírku, orientácia, zvisle, vodorovne"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"inovovať, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"nerušiť, rozpis, upozornenia, blokovať, stíšiť, vibrovať, spánok, práca, sústredenie, zvuk, vypnúť zvuk, deň, pracovný deň, víkend, noc pracovného dňa, udalosť"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"obrazovka, čas uzamknutia, časový limit, uzamknutá obrazovka"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"pamäť, vyrovnávacia pamäť, údaje, odstrániť, vymazať, voľné, miesto"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"pripojené, zariadenie, slúchadlá, slúchadlá s mikrofónom, reproduktor, bezdrôtové, párovať, slúchadlá do uší, hudba, médiá"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"pozadie, motív, mriežka, upraviť na mieru, prispôsobiť"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikona, zvýraznenie, farba, plocha, uzamknutá obrazovka, skratka, veľkosť hodín"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"predvolené, asistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"platby, predvolené"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"prichádzajúce upozornenie"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"tethering cez usb, tethering cez bluetooth, wi-fi, hotspot"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"hmatová spätná väzba, vibrovať, vibrácie"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"hmatová odozva, vibrovať, obrazovka, citlivosť"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"hmatová spätná väzba, vibrovanie, telefón, hovor, citlivosť, zvonenie"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"hmatová spätná väzba, vibrovanie, telefón, hovor, zvonenie, postupne"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"hmatová spätná väzba, vibrovať, citlivosť, upozornenie"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"hmatová odozva, vibrovať, citlivosť, budík"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"hmatová spätná väzba, vibrovať, citlivosť, médiá"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"hmatová spätná väzba, vibrovať, vibrácie"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"šetrič batérie, pevne umiestnené, trvalé, šetrič energie, batéria"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"postup, plán, šetrič batérie, šetrič energie, batéria, automaticky, percento"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"VoLTE, rozšírené hovory, volanie cez 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, rozšírené hovory, volanie cez 5g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"pridať jazyk, pridať určitý jazyk"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"veľkosť textu, veľkoformátová tlač, veľké písmo, veľký text, slabozrakosť, zväčšenie textu, zväčšovač písma, zväčšenie písma"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"vždy zapnuté ambientné zobrazenie"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, štítok, čítačka"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"klávesnica, hmatová spätná väzba, vibrovať,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Hlasitosť, vibrovanie, režim bez vyrušení"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Hlasitosť médií"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Hlasitosť prenášania"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Hlasitosť hovorov"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Hlasitosť budíkov"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Hlasitosť zvonení a upozornení"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Hlasitosť zvonenia"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Hlasitosť upozornení"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Tiché zvonenie"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Vibračné zvonenie"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Upozornenia majú vypnutý zvuk a budú vibrovať"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> má vypnutý zvuk"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Nedostupné, pretože je vypnuté zvonenie"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Tón zvonenia telefónu"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Predvolený zvuk upozornenia"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Zvuk z aplikácie"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Predvolený zvuk upozornenia"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Predvolený zvuk budíka"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Najprv vibrovať, potom stupňovať zvonenie"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Priestorový zvuk"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Zvuky číselnej klávesnice"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Zvuk uzamknutia obrazovky"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Zvuky a vibrácie pri nabíjaní"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Zvuky doku"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Zvuky klepnutia a kliknutia"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Vždy zobrazovať ikonu v režime vibrovania"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Reproduktory doku"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Všetky zvukové súbory"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Iba zvukové médiá"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Ticho"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tóny"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrácie"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Zvuky pri spustení"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Živý prepis"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatické titulkovanie médií"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Slúchadlá s káblom"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Zvuk z kompatibilných médií bude realistickejší"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Vypnuté"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Zapnuté / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Zapnuté / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> a <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Priestorový zvuk môžete zapnúť aj pre zariadenia s rozhraním Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Nastavenia pripojených zariadení"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Žiadne}=1{Bol nastavený 1 plán}few{Boli nastavené # plány}many{# schedules set}other{Bolo nastavených # plánov}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Režim bez vyrušení"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Prijímajte upozornenia iba od dôležitých ľudí a z dôležitých aplikácií"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Obmedzenie vyrušení"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Zapnite režim bez vyrušení"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Budíky a zvuky médií môžu vyrušiť"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Plány"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Odstrániť plány"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Odstrániť"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Upraviť"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Plány"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Plán"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Plán"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Stlmiť telefón v určitý čas"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Nastavenie pravidiel režimu bez vyrušení"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Plán"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Používať plán"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Povolenie zvukových vyrušení"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokovať vizuálne vyrušenia"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Povoliť vizuálne signály"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Možnosti zobrazenia skrytých upozornení"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Keď je zapnutý režim bez vyrušení"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Upozornenia bez zvuku"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Upozornenia bude vidieť na obrazovke"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Nové upozornenia nebudú vydávať zvuk ani vibrovať."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Upozornenia bez zobrazenia aj zvuku"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Upozornenia nebude vidieť ani počuť"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Váš telefón nebude zobrazovať nové ani existujúce upozornenia ani na ne nebude upozorňovať vibrovaním či zvukom. Upozorňujeme, že závažné upozornenia týkajúce sa aktivity a stavu zariadenia sa budú stále zobrazovať.\n\nKeď vypnete režim bez vyrušení, zmeškané upozornenia zobrazíte potiahnutím nadol z hornej časti obrazovky."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Vlastné"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Povoliť vlastné nastavenie"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Odstrániť vlastné nastavenie"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Upozornenia bez zvuku"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Čiastočne skryté"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Upozornenia bez zobrazenia aj zvuku"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Vlastné obmedzenia"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Keď je obrazovka zapnutá"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Keď je obrazovka vypnutá"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Stlmiť zvuk a vibrácie"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Nezapínať obrazovku"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Neblikať"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Nezobrazovať upozornenia na obrazovke"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Skryť ikony stavového riadka hore na obrazovke"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Skryť bodky upozornení na ikonách aplikácií"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Pri upozorneniach neprebúdzať obrazovku"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Skryť z panela upozornení"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nikdy"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Keď je obrazovka vypnutá"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Keď je obrazovka zapnutá"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Zvuk a vibrácie"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Zvuk, vibrácie a niektoré vizuálne signály upozornení"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Zvuk, vibrácie a vizuálne signály upozornení"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Upozornenia týkajúce sa základnej aktivity a stavu zariadenia nikdy nebudú skrývané."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Žiadne"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"ďalšie možnosti"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Pridať"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Zapnúť"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Zapnúť"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Vypnúť"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Režim bez vyrušení je zapnutý do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Režim bez vyrušení zostane zapnutý, dokým ho nevypnete"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Režim bez vyrušení bol automatický zapnutý v rámci plánu (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Režim bez vyrušení bol automaticky zapnutý aplikáciou (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Režim bez vyrušení je zapnutý pre pravidlá <xliff:g id="RULE_NAMES">%s</xliff:g> s vlastnými nastaveniami."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Zobraziť vlastné nastavenia"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Iba prioritné"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Zapnuté / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Zapnuté"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Vždy sa opýtať"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Dokým funkciu nevypnete"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 hodina}few{# hodiny}many{# hodiny}other{# hodín}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minúta}few{# minúty}many{# minúty}other{# minút}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Vypnuté}=1{Vypnuté / 1 plán sa môže automaticky zapnúť}few{Vypnuté / # plány sa môžu automaticky zapnúť}many{Off / # schedules can turn on automatically}other{Vypnuté / # plánov sa môže automaticky zapnúť}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Čo môže prerušiť režim bez vyrušení"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Ľudia"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikácie"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Budíky a iné vyrušenia"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Plány"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Trvanie rýchlych nastavení"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Všeobecné"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Keď je zapnutý režim bez vyrušení, zvuky a vibrácie budú vypnuté. Výnimku predstavujú položky, ktoré povolíte vyššie."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Vlastné nastavenia"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Skontrolovať plán"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Dobre"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Upozornenia"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Trvanie"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Správy, udalosti a pripomenutia"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Keď je zapnutý režim bez vyrušení, zvuky správ, pripomenutí a udalostí budú vypnuté. Výnimku predstavujú položky, ktoré povolíte vyššie. Môžete upraviť nastavenia správ a povoliť priateľom, rodine alebo ďalším kontaktom spojiť sa s vami."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Hotovo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Nastavenia"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Upozornenia bez zobrazenia aj zvuku"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Upozornenia bez zvuku"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Upozornenia sa nebudú zobrazovať ani vydávať zvuky. Povolené sú kontakty s hviezdičkou a opakujúci sa volajúci."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Aktuálne nastavenie)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Zmeniť nastavenia upozornení režimu bez vyrušení?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Zvuky pracovného profilu"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Použiť zvuky osobného profilu"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Používať rovnaké zvuky ako váš osobný profil"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Tón zvonenia pracovného telefónu"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Predvolený zvuk pracovného upozornenia"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Predvolený zvuk pracovného budíka"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Rovnaký ako osobný profil"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Chcete používať zvuky osobného profilu?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Potvrdiť"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Váš pracovný profil bude používať rovnaké zvuky ako osobný"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Upozornenia"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"História upozornení, konverzácie"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Konverzácia"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Správa"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Upozornenia aplikácií"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Ovládať upozornenia z jednotlivých aplikácií"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Všeobecné"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Pracovné upozornenia"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Pracovný profil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Priorita prispôsobivých upozornení"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Automaticky nastaviť upozornenia s nižšou prioritou ako nenápadné"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Pozícia prispôsobivých upozornení"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automaticky zoradiť upozornenia podľa relevancie"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Spätná väzba k prispôsobivým upozorneniam"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Uveďte úpravy upozornení a zobrazujte možnosť poskytnúť spätnú väzbu k systému"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Resetovať dôležitosť upozornenia"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Resetovanie nastavení dôležitosti zmenených používateľom a povolenie priorizácie v asistentovi upozornení"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Navrhované akcie a odpovede"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automaticky zobrazovať navrhované akcie a odpovede"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Zobrazovať nedávne a stlmené upozornenia"</string>
    <string name="notification_history" msgid="8663811361243456201">"História upozornení"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Používať históriu upozornení"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"História upozornení je vypnutá"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Ak si chcete zobraziť nedávne a stlmené upozornenia, zapnite históriu upozornení"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Žiadne nedávne upozornenia"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Tu sa budú zobrazovať nedávne a stlmené upozornenia"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"zobraziť nastavenia upozornení"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"otvoriť upozornenie"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Povoliť stlmenie upozornení"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Bodka upozornení na ikone aplikácie"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Bubliny"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Bubliny"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Zobrazovať túto konverzáciu v bubline"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Zobrazovať plávajúcu ikonu nad aplikáciami"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Chcete zapnúť bubliny pre zariadenie?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Zapnutím bublín pre túto aplikáciu aktivujete tiež bubliny pre zariadenie.\n\nOvplyvní to ďalšie aplikácie alebo konverzácie, ktoré môžu zobrazovať bubliny."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Zapnúť"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Zrušiť"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Zapnuté / konverzácie sa môžu zobrazovať ako plávajúce ikony"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Povoliť aplikáciám zobrazovať bubliny"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Niektoré konverzácie sa zobrazia ako plávajúce ikony navrchu iných aplikácií"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Všetky konverzácie sa môžu zobrazovať ako bubliny"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Vybrané konverzácie sa môžu zobrazovať ako bubliny"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Nič sa nemôže zobrazovať ako bublina"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Konverzácie"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Všetky konverzácie sa môžu zobrazovať v bublinách okrem"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Vypnúť bubliny pre túto konverzáciu"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Zapnúť bubliny pre túto konverzáciu"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Doprava: zavrieť, doľava: zobraziť ponuku"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Doľava: zavrieť, doprava: zobraziť ponuku"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Skryť tiché upozornenia v stavovom riadku"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Blikať"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Ochrana súkromia"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Preskakovať uzamknutú obrazovku"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Po odomknutí prejdete priamo na poslednú obrazovku. Upozornenia sa nebudú zobrazovať na uzamknutej obrazovke. Zobrazíte ich potiahnutím zhora nadol."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Uzamknutá obrazovka, preskočiť, obísť"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Keď je pracovný profil zamknutý"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Zobrazovať na uzamknutej obrazovke iba nové upozornenia"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Automaticky odstraňovať upozornenia zobrazené v minulosti z uzamknutej obrazovky"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Upozornenia na uzamknutej obrazovke"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Zobrazovať konverzácie, predvolené aj tiché"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Zobrazovať konverzácie, predvolené aj tiché"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Skrývať tiché konverzácie a upozornenia"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Nezobrazovať žiadne upozornenia"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Citlivé upozornenia"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Zobrazovať po uzamknutí citlivý obsah"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Citlivé upozornenia pracovného profilu"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Zobrazovať po uzamknutí citlivý obsah pracovného profilu"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Zobrazovať kompletné upozornenia"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Zobrazovať citlivý obsah iba po odomknutí"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Nezobrazovať upozornenia"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"Čo chcete zobrazovať na uzamknutej obrazovke?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Uzamknutá obrazovka"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Zobrazovať všetok obsah pracovných upozornení"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Skryť citlivý pracovný obsah"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Akým spôsobom chcete zobrazovať profilové upozornenia na uzamknutom zariadení?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profilové upozornenia"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Upozornenia"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Upozornenia aplikácií"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategória upozornenia"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Správanie"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Konverzácie"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Sekcia konverzácií"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Povoliť aplikácii používať sekciu konverzácií"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nejde o konverzáciu"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Odstrániť zo sekcie konverzácií"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Toto je konverzácia"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Pridať do sekcie konverzácií"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Žiadne prioritné konverzácie"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioritná konverzácia}few{# prioritné konverzácie}many{# priority conversations}other{# prioritných konverzácií}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioritné konverzácie"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Zobrazovať hore v sekcii konverzácií ako plávajúce bubliny"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Zobrazovať hore v sekcii konverzácií"</string>
    <string name="other_conversations" msgid="551178916855139870">"Konverzácie bez priority"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Konverzácie, ktoré ste zmenili"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Nedávne konverzácie"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Vymazať nedávne konverzácie"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Nedávne konverzácie boli odstránené"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Konverzácia bola odstránená"</string>
    <string name="clear" msgid="5092178335409471100">"Vymazať"</string>
    <string name="clear_conversation" msgid="5564321180363279096">"Vymazať konverzáciu <xliff:g id="CONVERSATION_NAME">%1$s</xliff:g>"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Tu sa budú zobrazovať prioritné a zmenené konverzácie"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Keď označíte konverzáciu ako prioritnú alebo vykonáte v konverzáciách akékoľvek iné zmeny, zobrazia sa tu. \n\nAko zmeniť nastavenia konverzácie: \nPotiahnutím z hornej časti obrazovky smerom nadol otvorte panel upozornení a potom pridržte požadovanú konverzáciu."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimalizovať"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Vyskakovať na obrazovke"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Tiché"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Predvolené"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Povoliť vyrušenia"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Povoliť aplikácii prehrávať zvuk, vibrovať alebo zobrazovať upozornenia na obrazovke"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Priorita"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Zobrazuje sa hore v sekcii konverzácií ako plávajúca bublina a ako profilová fotka na uzamknutej obrazovke"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> nepodporuje väčšinu funkcií konverzácie. Určitú konverzáciu môžete nastaviť ako prioritu a konverzácie sa nebudú zobrazovať ako plávajúce bubliny."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Na paneli upozornení zbaliť upozornenia do jedného riadka"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Žiadny zvuk ani vibrácie"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Žiadny zvuk ani vibrácie a zobrazuje sa nižšie v sekcii konverzácií"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Môže zvoniť či vibrovať podľa nastavení zariadenia"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Keď je zariadenie odomknuté, zobrazovať upozornenia ako banner v hornej časti obrazovky"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Všetky upozornenia aplikácie <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Všetky upozornenia aplikácie <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Približne # upozornenie denne}few{Približne # upozornenia denne}many{About # notifications per day}other{Približne # upozornení denne}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Približne # upozornenie týždenne}few{Približne # upozornenia týždenne}many{About # notifications per week}other{Približne # upozornení týždenne}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nikdy"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Upozornenia v zariadeniach a aplikáciách"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Ovládať, ktoré aplikácie a zariadenia môžu čítať upozornenia"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Prístup k upozorneniam pracovného profilu je zablokovaný"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Zlepšené upozornenia"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Získavať navrhované akcie, odpovede a ďalší obsah"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Žiadne"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Prístup k upozorneniam si nevyžiadali žiadne nainštalované aplikácie"</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Povoliť prístup k upozorneniam"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Adaptívne upozornenia Androidu boli v Androide 12 nahradené zlepšenými upozorneniami. Táto funkcia zobrazuje navrhované akcie aj odpovede a organizuje vaše upozornenia. \n\nZlepšené upozornenia majú prístup k obsahu upozornení vrátane osobných údajov, ako sú mená kontaktov a správy. Táto funkcia tiež môže zavrieť upozornenia alebo na ne reagovať, napríklad prijať telefonáty a ovládať režim bez vyrušení."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Povoliť prístup k upozorneniam pre službu <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Aplikácia <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bude môcť čítať všetky upozornenia vrátane osobných údajov, ako sú mená kontaktov, fotky a texty prijatých správ. Bude môcť aj stlmiť alebo zrušiť upozornenia, prípadne spustiť v nich obsiahnuté tlačidlá spúšťajúce akcie vrátane prijatia telefonického hovoru. \n\nAplikácia tým získa aj možnosť vypnúť alebo zapnúť režim bez vyrušení a meniť súvisiace nastavenia."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Aplikácia <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bude môcť:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Čítať vaše upozornenia"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Môže čítať vaše upozornenia vrátane osobných údajov, ako sú kontakty, správy a fotky."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Odpovedať na správy"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Môže odpovedať na správy a podniknúť akcie v súvislosti s tlačidlami v upozorneniach vrátane stlmenia alebo zavretia upozornení a prijímania hovorov."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Meniť nastavenia"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Môže zapnúť alebo vypnúť režim bez vyrušení a zmeniť súvisiace nastavenia."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Ak vypnete prístup k upozorneniam pre aplikáciu <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, môžete tým vypnúť aj prístup pre režim bez vyrušení."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Vypnúť"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Zrušiť"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Reálny čas"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Prebiehajúca komunikácia z používaných aplikácií, navigácie, telefónnych hovorov a ďalších položiek"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Konverzácie"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, textové správy a iná komunikácia"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Upozornenia"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Zvoní či vibruje podľa nastavení"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Tiché"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Upozornenia, ktoré nikdy nevydávajú zvuk ani nevibrujú"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Povolené"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nepovolené"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Zobraziť všetky aplikácie"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Zmeňte nastavenia každej aplikácie, ktorá odosiela upozornenia"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Aplikácie zobrazované v zariadení"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Táto aplikácia nepodporuje zlepšené nastavenia"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Ďalšie nastavenia"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"V tejto aplikácii sú k dispozícii ďalšie nastavenia"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Stlmenie upozornení"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Použiť stlmenie na všetky upozornenia"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Postupne znižovať hlasitosť upozornení, keď dostanete veľa upozornení za sebou z tej istej aplikácie"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Použiť stlmenie na všetky konverzácie"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Postupne znížiť hlasitosti upozornení, keď v krátkom čase dostanete veľa správ z toho istého četu"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Nepoužívať stlmenie upozornení"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Nikdy neznížiť hlasitosť upozornení bez ohľadu na počet po sebe idúcich upozornení z tej istej aplikácie"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Vibrovanie pri odomknutí"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Vibrovať iba pri odomknutej obrazovke"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Použiť na pracovné profily"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Použiť nastavenia stlmenia upozornení z osobného profilu na pracovný profil"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Pomocné služby VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Žiadne nainštalované aplikácie nežiadali, aby boli spúšťané ako pomocné služby VR."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Umožniť službe VR prístup do služby <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> bude možné spustiť pri používaní aplikácií v režime virtuálnej reality."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Keď je zariadenie v režime VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Znížiť rozmazanie (odporúčané)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Znížiť blikanie"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Obraz v obraze"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Žiadna z nainštalovaných aplikácií nepodporuje obraz v obraze"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Povoliť obraz v obraze"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Povoľte tejto aplikácii vytvoriť okno obrazu v obraze, kým je otvorená alebo keď ju opustíte (napríklad na pokračovanie v pozeraní videa). Toto okno sa zobrazuje cez ďalšie aplikácie, ktoré používate."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Prepojené pracovné a osobné aplikácie"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Prepojené"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Neprepojené"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Žiadne pripojené aplikácie"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"viac profilov pripojená aplikácia aplikácie pracovné a osobné"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Prepojené"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Prepojiť tieto aplikácie"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Prepojené aplikácie zdieľajú prihlasovacie údaje a majú vzájomný prístup k svojim údajom."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Prepojte iba tie aplikácie, ktorým dôverujete, že nebudú zdieľať osobné údaje s vaším správcom IT."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Aplikácie môžete kedykoľvek odpojiť v nastaveniach ochrany súkromia zariadenia."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Povolíte pracovnej aplikácii <xliff:g id="NAME">%1$s</xliff:g> prístup k svojim osobným údajom?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Prepojte iba tie aplikácie, ktorým dôverujete, že nebudú zdieľať osobné údaje s vaším správcom IT."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Dáta aplikácií"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Táto aplikácia má prístup k dátam osobnej aplikácie <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Povolenia"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Táto aplikácia môže používať povolenia osobnej aplikácie <xliff:g id="NAME">%1$s</xliff:g>, ako je prístup k polohe, úložisku či kontaktom."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Žiadne aplikácie neprepojené"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{Pripojená je # aplikácia}few{Pripojené sú # aplikácie}many{# apps connected}other{Pripojených je # aplikácií}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Ak chcete tieto aplikácie prepojiť, nainštalujte aplikáciu <xliff:g id="NAME">%1$s</xliff:g> vo svojom pracovnom profile"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Ak chcete tieto aplikácie prepojiť, nainštalujte aplikáciu <xliff:g id="NAME">%1$s</xliff:g> vo svojom osobnom profile"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Klepnutím získate aplikáciu"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Prístup k režimu bez vyrušení"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Povoliť režim bez vyrušení"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Prístup k režimu bez vyrušení si nevyžiadali žiadne nainštalované aplikácie"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Nepovolili ste upozornenia z tejto aplikácie"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Táto kategória upozornení je v zariadení na vašu žiadosť blokovaná Androidom"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Táto skupina upozornení je v zariadení na vašu žiadosť blokovaná Androidom"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Táto aplikácia neodosiela upozornenia"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategórie"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Iné"</string>
    <string name="no_channels" msgid="4716199078612071915">"Táto aplikácia ešte neposlala žiadne upozornenia"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Ďalšie nastavenia v aplikácii"</string>
    <string name="show_unused_channels" msgid="2754356124204058828">"Zobr. nevyuž. kanály"</string>
    <string name="hide_unused_channels" msgid="9049958190570733200">"Skryť nevyuž. kanály"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{Bola odstránená # kategória}few{Boli odstránené # kategórie}many{# categories deleted}other{Bolo odstránených # kategórií}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokovať všetko"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Tieto upozornenia nikdy nezobrazovať"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Zobrazovať upozornenia"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nikdy nezobrazovať upozornenia na paneli ani v periférnych zariadeniach"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Povoliť upozornenia na celú obrazovku"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Povoľte upozornenia na celú obrazovku, keď je zariadenie uzamknuté"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Povoliť bodku upozornení"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Zobrazovať bodku upozornení"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Prekonať režim bez vyrušení"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Povoliť týmto upozorneniam vyrušiť ma, keď je zapnutý režim bez vyrušení"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Uzamknutá obrazovka"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Hotovo"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Blikať"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibrácie"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Zvuk"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Priorita"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Názov plánu"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Zadajte názov plánu"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Názov plánu sa už používa"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Pridať ďalšie"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Pridať plán udalosti"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Pridať časový plán"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Vyberte typ plánu"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Chcete odstrániť pravidlo <xliff:g id="RULE">%1$s</xliff:g>?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Odstrániť"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Tieto nastavenia momentálne nemôžete zmeniť. Aplikácia (<xliff:g id="APP_NAME">%1$s</xliff:g>) automaticky zapla režim bez vyrušení pomocou vlastného správania."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Tieto nastavenia momentálne nemôžete zmeniť. Aplikácia automaticky zapla režim bez vyrušení pomocou vlastného správania."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Tieto nastavenia momentálne nemôžete zmeniť. Režim bez vyrušení bol automaticky zapnutý pomocou vlastného správania."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Čas"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Udalosť"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Počas udalostí"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"V ľubovoľnom kalendári"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"V prípade odpovede"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Áno, Možno alebo Bez odpovede"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Áno alebo Možno"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Áno"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Pravidlo sa nenašlo"</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Zapnuté / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Dni"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Žiadne"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Budík môže prepísať čas ukončenia"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Vypnúť plán, keď zazvoní budík"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Správanie režimu bez vyrušení"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Použiť predvolené nastavenia"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Vytvoriť vlastné nastavenia tohto plánu"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"V rámci plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Konverzácie"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Všetky konverzácie"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioritné konverzácie"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioritné konverzácie"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Žiadne"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Žiadne}=1{1 konverzácia}few{# konverzácie}many{# conversations}other{# konverzácií}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kto môže vyrušiť"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Komunikátory a telefonické aplikácie vám nemôžu posielať upozornenia, ale ľudia, ktorých si tu vyberiete, vás môžu prostredníctvom nich kontaktovať"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Hovory"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Hovory"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"hovory"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Hovory, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Skontrolujte, či je v zariadení zapnuté zvonenie, aby povolené hovory vyzváňali"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"V rámci plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> sú blokované prichádzajúce hovory. Môžete upraviť nastavenia a povoliť priateľom, rodine alebo ďalším kontaktom spojiť sa s vami."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Kontakty s hviezdičkou"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Žiadne}=1{{contact_1}}=2{{contact_1} a {contact_2}}=3{{contact_1}, {contact_2} a {contact_3}}few{{contact_1}, {contact_2} a # ďalšie kontakty}many{{contact_1}, {contact_2}, and # others}other{{contact_1}, {contact_2} a # ďalších kontaktov}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Bez mena)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Správy"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"správy"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Správy"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Správy, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Skontrolujte, či má zariadenie zapnuté zvonenie, aby na povolené správy upozorňovalo zvukom"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Prichádzajúce správy sú v rámci plánu <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> blokované. Môžete upraviť nastavenia a povoliť priateľom, rodine alebo ďalším kontaktom spojiť sa s vami."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Dostanete všetky správy"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Dostanete všetky hovory"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Žiadne}=1{1 kontakt}few{# kontakty}many{# contacts}other{# kontaktov}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Ktokoľvek"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakty"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Kontakty s hviezdičkou"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Žiadne"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Žiadne"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Budíky"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Z časovačov, budíkov, bezpečnostných systémov a ďalších aplikácií"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"budíky"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Budíky"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Zvuky médií"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Zvuky z videí, hier a ďalších médií"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"médiá"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Médiá"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Zvuky pri klepnutí"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Zvuky z klávesnice a iných tlačidiel"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"zvuky pri klepnutí"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Zvuky pri klpenutí"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Pripomenutia"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Z úloh a pripomenutí"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"pripomenutia"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Pripomenutia"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Udalosti v kalendári"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Z nadchádzajúcich udalostí v kalendári"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"udalosti"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Udalosti"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Povoľte aplikáciám prekonávať nastavenia"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikácie, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Vyberte ďalšie aplikácie"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Žiadne vybrané aplikácie"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Žiadne aplikácie nemôžu vyrušiť"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Pridať aplikácie"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Všetky upozornenia"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Niektoré upozornenia"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Vybraní ľudia vás stále môžu kontaktovať, aj keď nepovoľujete aplikáciám vyrušovať"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Žiadne aplikácie nemôžu vyrušiť}=1{{app_1} môže vyrušiť}=2{{app_1} a {app_2} môžu vyrušiť}=3{{app_1}, {app_2} a {app_3} môžu vyrušiť}few{{app_1}, {app_2} a # ďalšie aplikácie môžu vyrušiť}many{{app_1}, {app_2}, and # more can interrupt}other{{app_1}, {app_2} a # ďalších aplikácií môže vyrušiť}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikácie"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Upozornenia, ktoré môžu vyrušiť"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Povoliť všetky upozornenia"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Žiadne zvuky nemôžu vyrušiť}=1{{sound_category_1} môže vyrušiť}=2{{sound_category_1} a {sound_category_2} môžu vyrušiť}=3{{sound_category_1}, {sound_category_2} a {sound_category_3} môžu vyrušiť}few{{sound_category_1}, {sound_category_2} a # ďalšie zvuky môžu vyrušiť}many{{sound_category_1}, {sound_category_2}, and # more can interrupt}other{{sound_category_1}, {sound_category_2} a # ďalších zvukov môže vyrušiť}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Žiadne zvuky nemôžu vyrušiť"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Nikto nemôže vyrušiť"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Niektorí ľudia môžu vyrušiť"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Všetci ľudia môžu vyrušiť"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Opakované volania"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Povoliť opakované volania"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"kohokoľvek"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontaktov"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"kontaktov s hviezdičkou"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"opakované volania"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> a <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Ak tá istá osoba zavolá druhýkrát do <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Čas začatia"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Čas ukončenia"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> nasledujúci deň"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Zmena na možnosť Iba budíky platná natrvalo"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Zmena v budíkoch iba na minútu do {time}}few{Zmena v budíkoch iba na # minúty (do {time})}many{Change to alarms only for # minutes (until {time})}other{Zmena v budíkoch iba na # minút (do {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Zmena v budíkoch iba na hodinu do {time}}few{Zmena v budíkoch iba na # hodiny do {time}}many{Change to alarms only for # hours until {time}}other{Zmena v budíkoch iba na # hodín do {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Zmena na možnosť Iba budíky platná do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Zmena na možnosť Vždy prerušiť"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Upozornenie"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Zavrieť"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Odoslať spätnú väzbu o zariadení"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Zadajte PIN správcu"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Zapnuté"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Vypnuté"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Zapnuté"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Vypnuté"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Zapnuté"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Vypnuté"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Pripnutie aplikácie"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Pripnutie aplikácie umožňuje ponechať aktuálnu aplikáciu zobrazenú, než ju odopnete. Pomocou tejto funkcie môžete napríklad dôveryhodnému priateľovi umožniť hrať konkrétnu hru."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Pripnutá aplikácia môže otvárať ďalšie aplikácie a sprístupniť osobné údaje. \n\nAk chcete použiť pripnutie aplikácie: 	\n{0,number,integer}. Zapnite pripnutie aplikácie. 	\n{1,number,integer}. Otvorte Prehľad. 	\n{2,number,integer}. Klepnite na ikonu aplikácie v hornej časti obrazovky a potom na Pripnúť."</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Pripnutá aplikácia môže otvárať ďalšie aplikácie a sprístupniť osobné údaje. \n\nAk chcete zariadenie s niekým bezpečne zdieľať, skúste namiesto toho použiť hosťa. \n\nAk chcete použiť pripnutie aplikácie: 	\n{0,number,integer}. Zapnite pripnutie aplikácie. 	\n{1,number,integer}. Otvorte Prehľad. 	\n{2,number,integer}. Klepnite na ikonu aplikácie v hornej časti obrazovky a potom na Pripnúť."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Keď je aplikácia pripnutá: \n\n•		Môžu byť sprístupnené osobné údaje \n		(napríklad kontakty a obsah správ) \n•		Pripnutá aplikácia môže otvárať ďalšie aplikácie \n\nPripnutie aplikácie používajte iba s ľuďmi, ktorým dôverujete."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Pred odopnutím vyžiadať bezpečnostný vzor"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Pred odopnutím požiadať o PIN"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Pred odopnutím požiadať o heslo"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Pri odopnutí zamknúť zariadenie"</string>
    <string name="confirm_sim_deletion_title" msgid="7262127071183428893">"Potvrďte, že chcete eSIM kartu vymazať"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Pred vymazaním eSIM karty overovať svoju totožnosť"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Beta verzia rozšír. ochr. pamäte"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Rozšírená ochrana pamäte"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Táto beta funkcia pomáha chrániť vaše zariadenie pred chybami, ktoré môžu ohroziť jeho zabezpečenie."</string>
    <string name="memtag_on" msgid="824938319141503923">"Zapnutá"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Vypnuté"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Zapne sa po reštartovaní"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Vypne sa po reštartovaní"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Pre vaše zariadenie nie je momentálne k dispozícii"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Vždy zapnuté pre vaše zariadenie"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Ak chcete zapnúť alebo vypnúť rozšírenú ochranu pamäte, musíte reštartovať zariadenie. Keď bude zapnutá, môžete si všimnúť slabší výkon zariadenia."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Chcete reštartovať zariadenie?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Ak chcete zapnúť rozšírenú ochranu pamäte, musíte reštartovať zariadenie."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Ak chcete vypnúť rozšírenú ochranu pamäte, musíte reštartovať zariadenie."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Reštartovať"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Teraz nie"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Ďalšie informácie o rozšírenej ochrane pamäte"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Tento pracovný profil spravuje aplikácia:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Spravované aplikáciou <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Predvolené otváranie"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Otvárať podporované odkazy"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Povoliť otváranie webových odkazov v tejto aplikácii"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Odkazy na otvorenie v tejto aplikácii"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Podporované odkazy"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Ďalšie predvolené predvoľby"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Pridať odkaz"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Aplikácia môže overiť odkazy, aby sa v nej automaticky otvárali."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# overený odkaz}few{# overené odkazy}many{# verified links}other{# overených odkazov}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Tento odkaz je overený a automaticky sa otvára v tejto aplikácii.}few{Tieto odkazy sú overené a automaticky sa otvárajú v tejto aplikácii.}many{These links are verified and automatically open in this app.}other{Tieto odkazy sú overené a automaticky sa otvárajú v tejto aplikácii.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Zobrazenie zoznamu overovacích odkazov"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Vyhľadávajú sa ďalšie podporované odkazy…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Zrušiť"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# podporovaný odkaz}few{# podporované odkazy}many{# supported links}other{# podporovaných odkazov}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Pridať"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Otvára sa v aplikácii <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"Využité: <xliff:g id="SIZE">%1$s</xliff:g>, <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"interné úložisko"</string>
    <string name="storage_type_external" msgid="125078274000280821">"externé úložisko"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"Od <xliff:g id="DATE">%2$s</xliff:g> využité <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Využité úložisko"</string>
    <string name="change" msgid="273206077375322595">"Zmeniť"</string>
    <string name="change_storage" msgid="8773820275624113401">"Zmeniť úložisko"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Upozornenia"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Zapnuté"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g> / <xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Vypnuté"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategória bola vypnutá}few{# kategórie boli vypnuté}many{# categories turned off}other{# kategórií bolo vypnutých}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# ďalšie povolenie}few{# ďalšie povolenia}many{# additional permissions}other{# ďalších povolení}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Neboli udelené žiadne povolenia"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Neboli požadované žiadne povolenia"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Ovládajte prístup aplikácií k údajom"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Panel ochrany súkromia"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Zobraziť, ktoré aplikácie nedávno použili povolenia"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Nepoužívané aplikácie"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# nepoužívaná aplikácia}few{# nepoužívané aplikácie}many{# unused apps}other{# nepoužívaných aplikácií}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Nastavenia nepoužívanej aplikácie"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Pozastaviť aktivitu nepoužívanej aplik."</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Odstrániť povolenia, vymazať dočasné súbory a zastaviť upozornenia"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Spravovať aplikáciu, ak sa nepoužíva"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Odstrániť povolenia, vymazať dočasné súbory, zastaviť upozornenia a archivovať aplikáciu"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Všetky aplikácie"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Nainštalované aplikácie"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Okamžité aplikácie"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Vypnuté"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Rozšírené"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Správca povolení"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Aktualizácie zdieľania údajov o polohe"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Skontrolujte aplikácie, ktoré zmenili spôsob zdieľania vašich údajov o polohe"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Zobudiť klepnutím"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Zariadenie prebudíte dvojitým klepnutím na ľubovoľné miesto na obrazovke."</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Otváranie odkazov"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Neotvárať podporované odkazy"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Otvárať <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Otvárať <xliff:g id="DOMAIN">%s</xliff:g> a ďalšie webové adresy"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Povoliť aplikácii otvárať podporované odkazy"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Vždy sa opýtať"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Nepovoliť aplikácii otvárať odkazy"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Aplikácia žiada o spracovanie # odkazu}few{Aplikácia žiada o spracovanie # odkazov}many{App claims to handle # links}other{Aplikácia žiada o spracovanie # odkazov}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikácia žiada o spracovanie nasledujúcich odkazov:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Asistencia a hlasový vstup"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digitálny asistent"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Predvolený digitálny asistent"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Súhlasím"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Prehliadač"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Telefónna aplikácia"</string>
    <string name="system_app" msgid="1863291702508355041">"(Systémová)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Ukladací priestor aplikácií"</string>
    <string name="usage_access" msgid="5487993885373893282">"Prístup k údajom o používaní"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Povoliť prístup k údajom o používaní"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Čas používania"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Prístup k údajom o používaní umožňuje aplikácii sledovať, aké ďalšie aplikácie používate, ako často ich používate, a taktiež nastavenia jazyka, operátora a ďalšie podrobnosti."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Pamäť"</string>
    <string name="always_running" msgid="9012705720688200252">"Vždy spustené (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Niekedy spustené (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Výnimočne spustené (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimalizácia batérie"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Neoptimalizované"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Neoptimalizované"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimalizuje spotrebu batérie"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimalizácia batérie nie je k dispozícii"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Chcete povoliť aplikácii neustále bežať na pozadí?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Ak povolíte, aby aplikácia <xliff:g id="APP_NAME">%1$s</xliff:g> neustále bežala na pozadí, môže to skrátiť výdrž batérie. \n\nNeskôr to môžete zmeniť v sekcii Nastavenia &gt; Aplikácie."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> využitie od posledného úplného dobitia"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> použitie v posledných 24 hodinách"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Od posledného úplného nabitia nebola batéria využitá"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Chcete zdieľať hlásenie chyby?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Správca IT si vyžiadal hlásenie chyby, aby mohol vyriešiť problém na tomto zariadení. Aplikácie a dáta môžu byť zdieľané."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Správca IT si vyžiadal hlásenie chyby, aby mohol vyriešiť problém na tomto zariadení. Aplikácie a dáta môžu byť zdieľané. Môže to dočasne spomaliť vaše zariadenie."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Toto hlásenie chyby sa zdieľa s vaším správcom IT. Ak potrebujete ďalšie podrobnosti, kontaktujte ho."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Zdieľať"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Odmietnuť"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Žiadny prenos údajov"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Nabíjať pripojené zariadenie"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Prenos súborov"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Webkamera"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konvertovať videá do formátu AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videá sa budú prehrávať vo viacerých prehrávačoch médií, ale ich kvalita môže byť znížená"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Tethering cez USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Využitie USB"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Predvolená konfigurácia USB"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Tieto nastavenia sa použijú, keď bude pripojené ďalšie zariadenie a telefón bude odomknutý. Pripájajte sa iba k dôveryhodným zariadeniam."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Možnosti napájania"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Možnosti prenosu súborov"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Nastavenia USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB ovláda"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Pripojené zariadenie"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Toto zariadenie"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Prepína sa…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Nepodarilo sa prepnúť"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Nabíjanie tohto zariadenia"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Nabíja sa pripojené zariadenie"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Prenos súborov"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Tethering cez USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Webkamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Prenos súborov a poskytovanie napájania"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Tethering cez USB a poskytovanie napájania"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP a poskytovanie napájania"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI a poskytovanie napájania"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webkamera a napájací zdroj"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Kontrola na pozadí"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Používať text z obrazovky"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Povoliť asistenčnej aplikácii prístup k obsahu obrazovky v textovej podobe"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Používať snímku obrazovky"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Povoliť asistenčnej aplikácii prístup k snímke obrazovky"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Blikať obrazovkou"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Blikať okrajmi obrazovky, keď asistenčná aplikácia číta text z obrazovky alebo snímky obrazovky"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Asistenčné aplikácie vám pomáhajú na základe informácií zo zobrazenej obrazovky. Niektoré aplikácie podporujú spúšťač aj služby hlasového vstupu, aby vám poskytli integrovanú pomoc."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Priemerné využitie pamäte"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maximálne využitie pamäte"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Využitie pamäte"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Využitie aplikáciami"</string>
    <string name="memory_details" msgid="6133226869214421347">"Podrobnosti"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Za posledné 3 hodiny bolo priemerné využitie pamäte <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Za posledné 3 hodiny nebola využitá žiadna pamäť"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Zoradiť podľa priemerného využitia"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Zoradiť podľa maximálneho využitia"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Výkonnosť"</string>
    <string name="total_memory" msgid="5244174393008910567">"Celková pamäť"</string>
    <string name="average_used" msgid="690235917394070169">"Priemerné využitie (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Voľná pamäť"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Pamäť používaná aplikáciami"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 aplikácia použila pamäť v priebehu tohto uplynulého času: {time}}few{# aplikácie použili pamäť v priebehu tohto uplynulého času: {time}}many{# apps used memory in the last {time}}other{# aplikácií použilo pamäť v priebehu tohto uplynulého času: {time}}}"</string>
    <string name="force_enable_pss_profiling_title" msgid="2253816522775341523">"Zapnúť profilovanie využitia pamäte"</string>
    <string name="force_enable_pss_profiling_summary" msgid="7714294324548399136">"Profilovanie využitia pamäte vyžaduje ďalšie zdroje systému."</string>
    <string name="pss_profiling_disabled" msgid="1967278421143514850">"Profilovanie využitia pamäte je vypnuté"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frekvencia"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maximálne využitie"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Neboli spotrebované žiadne dáta"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Povoliť aplikácii <xliff:g id="APP">%1$s</xliff:g> prístup k režimu bez vyrušení?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplikácia bude môcť vypínať a zapínať režim bez vyrušení a meniť súvisiace nastavenia."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Musí zostať zapnuté, pretože je zapnutý prístup k upozorneniam"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Odvolať prístup k režimu bez vyrušení pre aplikáciu <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Všetky pravidlá režimu bez vyrušení vytvorené touto aplikáciou budú odstránené."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Neoptimalizovať"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimalizovať"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Batéria sa môže vybíjať rýchlejšie. Aplikácie už nebudú mať obmedzené používanie batérie na pozadí."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Odporúčajú sa na predĺženie výdrže batérie"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Žiadne"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Deaktivovaním prístupu k spotrebe dát pre túto aplikáciu nezabránite správcovi v sledovaní údajov o spotrebe dát pre aplikácie vo vašom pracovnom profile"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Zobrazenie cez iné aplikácie"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Zobrazenie cez iné aplikácie"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Povoliť zobrazenie cez iné aplikácie"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Umožní tejto aplikácii zobrazovať sa nad inými aplikáciami, ktoré používate. Táto aplikácia bude vidieť, kde klepnete, a môcť zmeniť obsah na obrazovke."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Zmena výstupu médií"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Povolenie aplikácií prepínať výstup médií"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Povoľte tejto aplikácii vyberať, ktoré pripojené zariadenie bude prehrávať zvuk či video z iných aplikácií. Ak tejto aplikácii udelíte povolenie, bude mať prístup k zoznamu dostupných zariadení (ako sú slúchadlá a reproduktory) a bude môcť vybrať, pomocou ktorého výstupného zariadenia sa bude streamovať či prenášať zvuk alebo video."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Prístup k všetkým súborom"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Povoliť prístup na správu všetkých súborov"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Povoľte tejto aplikácii čítať, upravovať a odstraňovať všetky súbory v tomto zariadení alebo akýchkoľvek pripojených úložiskách. Po udelení tohto povolenia bude môcť aplikácia používať súbory bez vášho vedomia."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Má prístup k všetkým súborom"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Aplikácie na aktiváciu hlasom"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Povoliť aktiváciu hlasom"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"Aktivácia hlasom zapne schválené aplikácie handsfree hlasovým príkazom. Vstavané adaptívne zisťovanie zaistí, že údaje zostanú súkromné, teda iba pre vás.\n\n"<a href="">"Viac o chránenom adaptívnom zisťovaní"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Upozornenia na celej obrazovke"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Povoliť zobrazovanie upozornení z tejto aplikácie na celej obrazovke"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Povoľte tejto aplikácii zobrazovať upozornenia na celú obrazovku, keď bude zariadenie uzamknuté. Aplikácie vás môžu pomocou nich informovať o budíkoch, prichádzajúcich hovoroch a ďalších dôležitých upozorneniach."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Aplikácie na správu médií"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Povoliť aplikácii spravovať médiá"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Ak toto nastavenie povolíte, táto aplikácia môže upravovať alebo odstraňovať súbory médií vytvorené v iných aplikáciách bez opýtania. Aplikácia musí mať povolenie na prístup k súborom a médiám."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Médiá, súbor, správa, správca, spravovať, upravovať, redaktor, aplikácia, program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtuálna realita prijímač stereo pomocné zariadenie"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Zobrazenie cez iné aplikácie"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikácie s povolením"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Povolené"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nepovolené"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"inštalácia aplikácie neznáme zdroje"</string>
    <string name="write_settings" msgid="6864794401614425894">"Úpravy nastavení systému"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"zápis a úprava nastavení systému"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Môže inštalovať ďalšie aplikácie"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Môže meniť nastavenia systému"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Môže meniť nastavenia systému"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Úprava nastavení systému"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Povoliť úpravy nastavení systému"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Toto povolenie umožňuje aplikácii meniť nastavenia systému"</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Povoliť z tohto zdroja"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Fotoaparát – dvakrát pokrúťte zápästím"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Otvorte aplikáciu fotoaparátu tak, že dvakrát pokrútite zápästím"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Veľkosť zobrazenia"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Zväčšite alebo zmenšite obsah na obrazovke"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"hustota obrazovky, priblíženie obrazovky, veľkosť, zmena veľkosti"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Ukážka"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Zmenšiť"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Zväčšiť"</string>
    <string name="disconnected" msgid="3469373726996129247">"Nepripojené"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nepripojené"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> nainštalovaných aplikácií"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Využité: <xliff:g id="PERCENTAGE">%1$s</xliff:g>, voľné: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tmavý motív, veľkosť písma, jas"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Využíva sa v priemere <xliff:g id="USED_MEMORY">%1$s</xliff:g> z celkovej pamäte <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Prihlásený používateľ <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Aktualizované na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"K dispozícii je aktualizácia"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Blokované pracovnými pravidlami"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Hlasitosť sa nedá zmeniť"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Nedá sa volať"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Nedajú sa posielať správy SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Fotoaparát nie je možné použiť"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Nedajú sa vytvárať snímky obrazovky"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Táto aplikácia sa nedá otvoriť"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokované vaším poskytovateľom úveru"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Vyžaduje sa rodič"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Odovzdaj telefón rodičovi, aby mohol začať túto funkciu nastavovať"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Podaj telefón rodičovi, aby mohol povoliť zmenu tohto nastavenia."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Ďalšie informácie vám poskytne váš správca IT"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Ďalšie podrobnosti"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Správca môže sledovať a spravovať aplikácie a údaje priradené k vášmu pracovnému profilu vrátane nastavení, povolení, firemného prístupu, aktivity siete a informácií o polohe zariadenia."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Správca môže sledovať a spravovať aplikácie a údaje priradené k tomuto používateľovi vrátane nastavení, povolení, firemného prístupu, aktivity siete a informácií o polohe zariadenia."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Správca môže sledovať a spravovať aplikácie a údaje priradené k tomuto zariadeniu vrátane nastavení, povolení, firemného prístupu, aktivity siete a informácií o polohe zariadenia."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Správca vášho zariadenia môže mať prístup k údajom spojeným s týmto zariadením, spravovať aplikácie a meniť jeho nastavenia."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Vypnúť"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Zapnúť"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Zobraziť"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Skryť"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot je aktívny"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Režim v lietadle je zapnutý"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Siete nie sú k dispozícii"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Je zapnutý režim bez vyrušení"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefón má vypnutý zvuk"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"S výnimkami"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Šetrič batérie je zapnutý"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funkcie sú obmedzené"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobilné dáta sú vypnuté"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet je k dispozícii iba cez Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Šetrič dát"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funkcie sú obmedzené"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Pracovný profil je vypnutý"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Pre aplikácie a upozornenia"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Zapnúť zvuk"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Zvonenie bolo vypnuté"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Pri hovoroch a upozorneniach"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Iba vibrácie"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Pri hovoroch a upozorneniach"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Nastavenie harmonogramu Nočného režimu"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Každý večer automaticky tónovať obrazovku"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Nočný režim je zapnutý"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Obrazovka má oranžový tón"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Odfarbenie"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Zobraziť iba sivo"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Zbaliť"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Studená teplota farby"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Používať studenšie farby obrazovky"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Ak chcete použiť zmenu farby, vypnite obrazovku"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Laserový snímač fotoaparátu"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatické aktualizácie systému"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Použiť aktualizácie po reštartovaní zariadenia"</string>
    <string name="usage" msgid="287782903846013936">"Spotreba"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Spotreba mobilných dát"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Spotreba dát aplikáciami"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Spotreba dát cez Wi‑Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Spotreba dát mimo operátora"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Spotreba dát prostredníctvom ethernetu"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi‑Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobilných dát"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"Dáta Wi‑Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"Ethernetové dáta: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Dátové upozornenie a limit"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Cyklus spotreby mobilných dát"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Dátové upozornenie: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Dátový limit: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Dátové upozornenie: <xliff:g id="ID_1">^1</xliff:g> / dátový limit: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Nezahŕňa dáta využité sieťami operátora"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Spotreba <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Nastaviť dátové upozornenie"</string>
    <string name="data_warning" msgid="2925054658166062884">"Dátové upozornenie"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Dátové upozornenie a dátový limit meria zariadenie. Údaje sa môžu líšiť od údajov operátora."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Nastaviť dátový limit"</string>
    <string name="data_limit" msgid="8731731657513652363">"Dátový limit"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_2">%2$s</xliff:g> spotreba <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigurovať"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Iné aplikácie zahrnuté v prehľade spotreby dát"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 aplikácia má povolené používať neobmedzené dáta, keď je zapnutý šetrič dát}few{# aplikácie majú povolené používať neobmedzené dáta, keď je zapnutý šetrič dát}many{# apps allowed to use unrestricted data when Data Saver is on}other{# aplikácií má povolených používať neobmedzené dáta, keď je zapnutý šetrič dát}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Primárne dáta"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Dáta Wi‑Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Využité: <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Prekročený limit <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Zostáva: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graf zobrazuje spotrebu dát od <xliff:g id="START_DATE">%1$s</xliff:g> do <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Pre tento rozsah dátumov neexistujú žiadne údaje."</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Zostáva # deň}few{Zostávajú # dni}many{Zostáva # dňa}other{Zostáva # dní}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Žiadny zostávajúci čas"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Zostáva menej ako 1 deň"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Aktualizované pred <xliff:g id="ID_2">^2</xliff:g> – <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Aktualizované pred <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Práve aktualizované – <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Práve aktualizované"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Zobraziť podrobnosti"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Šetrič dát"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neobmedzené dáta"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Dáta na pozadí sú vypnuté"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Zapnutý"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Vypnutý"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Používať šetrič dát"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neobmedzená spotreba dát"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Povoliť neobmedzený prístup k dátam, keď je zapnutý šetrič dát"</string>
    <string name="home_app" msgid="6056850504746902747">"Vstupná aplikácia"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Pridať ďalší odtlačok prsta"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Odomknutie pomocou iného odtlačku"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Zapnuté"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Zapne sa na úrovni <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Vypnuté"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Spotreba batérie aplikáciami"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Nastavte spotrebu batérie aplikáciami"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Zobraziť nastavenia"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Skontrolovať"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Dobre"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Je táto správa užitočná?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Výstražná ikona tipov týkajúcich sa batérie"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Ak chcete predĺžiť výdrž batérie, zapnite adaptáciu jasu"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Ak chcete predĺžiť výdrž batérie, znížte časový limit obrazovky"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"Aplikácia <xliff:g id="APP_LABEL">%1$s</xliff:g> využívala batériu vo vyššej miere"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"Aplikácia <xliff:g id="APP_LABEL">%1$s</xliff:g> využívala batériu viac než zvyčajne"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"Aplikácia <xliff:g id="APP_LABEL">%1$s</xliff:g> využívala batériu vo vyššej miere na pozadí"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"Aplikácia <xliff:g id="APP_LABEL">%1$s</xliff:g> využívala batériu viac než zvyčajne na pozadí"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"Aplikácia <xliff:g id="APP_LABEL">%1$s</xliff:g> využívala batériu vo vyššej miere na popredí"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"Aplikácia <xliff:g id="APP_LABEL">%1$s</xliff:g> využívala batériu viac než zvyčajne na popredí"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Anomália spotreby batérie"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Vysoká spotreba batérie"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Vysoká spotreba batérie na pozadí"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Vysoká spotreba batérie na popredí"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Bez obmedzení"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimalizované"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Obmedzené"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Predvolená kontrola pravopisu"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Výber kontroly pravopisu"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Používať kontrolu pravopisu"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nie je vybraté"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"balík"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"kľúč"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"skupina"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(súhrn)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"verejná verzia"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"dôležitosť"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"vysvetlenie"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"môže zobraziť odznak"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intencia"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"odstrániť intenciu"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intencia celej obrazovky"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"akcie"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"nadpis"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"vzdialené vstupy"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"vlastné zobrazenie"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"Bonusové položky"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"veľkosť parcely"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"aktivované upozornenie"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanál"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Chýba objekt hodnotenia."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Objekt hodnotenia neobsahuje tento kľúč."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Výrez obrazovky"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"výrez obrazovky, výrez"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Predvolené nastavenie zariadenia"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Nepodarilo sa prekryť"</string>
    <string name="special_access" msgid="1767980727423395147">"Špeciálny prístup aplikácií"</string>
    <string name="special_access_more" msgid="132919514147475846">"Zobraziť viac"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Dlhé úlohy na pozadí"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Povoliť dlhotrvajúce úlohy na pozadí"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Dlhé úlohy na pozadí"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Povoľte tejto aplikácii spúšťať dlhé úlohy na pozadí. Umožní jej to spúšťať úlohy, ktorých dokončenie môže trvať viac ako niekoľko minút, napríklad sťahovania a nahrávania. \n\nAk toto povolenie neudelíte, systém bude obmedzovať, ako dlho môže aplikácia vykonávať dané úlohy na pozadí."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"dlhé úlohy, prenos údajov, úlohy na pozadí"</string>
    <string name="run_backup_tasks_title" msgid="8572480651659803275">"Vykonávanie úloh zálohovania na pozadí"</string>
    <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Povoliť aplikácii spúšťať úlohy na pozadí súvisiace so zálohovaním"</string>
    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Označuje, či táto aplikácia má hlavný prípad použitia, pri ktorom potrebuje zálohovať alebo synchronizovať obsah. Udelením tohto povolenia umožníte jej spúšťanie na pozadí na trochu dlhší čas, aby mohla dokončiť prácu súvisiacu so zálohovaním. \n\nAk toto povolenie neudelíte, systém neposkytne tejto aplikácii žiadnu špeciálnu výnimku umožňujúcu dokončovať prácu súvisiacu so zálohovaním na pozadí."</string>
    <string name="keywords_run_backup_tasks" msgid="632219905465766211">"úlohy zálohovania"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Resetovať obmedzovanie frekvencie žiadostí v službe ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Obmedzovanie frekvencie žiadostí v službe ShortcutManager bolo resetované"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Nastaviť info na uzamknutej obrazovke"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Zobrazujte si obsah upozornení alebo ho skryte"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Tipy a podpora"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Minimálna šírka"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Prístup k prémiovým SMS si nevyžiadali žiadne nainštalované aplikácie"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Za prémiové správy SMS sa môžu účtovať poplatky, ktoré sa naúčtujú na faktúru operátora. Ak aktivujete toto povolenie pre aplikáciu, budete môcť pomocou nej posielať prémiové správy SMS."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Prístup k prémiovým SMS"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Vypnuté"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Pripojené k zariadeniu <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Pripojené k viacerým zariadeniam"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Ukážka používateľského rozhrania systému"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tmavý motív"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Dočasne vypnuté šetričom batérie"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Dočasne vypnuté šetričom batérie"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Vypnúť šetrič batérie"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Dočasne zapnuté šetričom batérie"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Vyskúšať tmavý motív"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Pomáha predĺžiť výdrž batérie"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Dlaždice rýchlych nastavení pre vývojárov"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Vypnúť časový limit autorizácií adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Vypnúť automatické odvolanie autorizácií adb systémov, ktoré neboli pripojené počas predvoleného (7 dní) alebo používateľom nastaveného (minimálne 1 deň) časového obdobia"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Senzory sú vypnuté"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Nastavenia pracovného profilu"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Vyhľadávať v osobných aplikáciách kontakty pracovného adresára"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Správca IT môže vidieť vaše vyhľadávania a prichádzajúce hovory"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalendár s viacerými profilmi"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Zobrazovať pracovné udalosti v osobnom kalendári"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Keď sú pracovné aplikácie vypnuté, sú pozastavené, nedá sa do nich získať prístup ani vám nemôžu odosielať upozornenia"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Spravovať úložisko"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Správca úložiska odstraňuje zálohované fotky a videá z vášho zariadenia, čím pomáha uvoľniť miesto v úložisku."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Odstrániť fotky a videá"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Správca úložiska"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Používať správcu priestoru"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestá"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Rýchlo spustiť kameru"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Rýchlo otvoriť kameru dvojitým stlačením vypínača. Funguje to na každej obrazovke."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Otočiť kameru na selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Režim navigácie"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigácia dvoma tlačidlami"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Medzi aplikáciami prepnete potiahnutím nahor po tlačidle plochy. Opätovným potiahnutím nahor zobrazíte všetky aplikácie. Vrátite sa klepnutím na tlačidlo Späť."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Bezpečnosť a tieseň"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Pomoc v tiesni, zdravotné údaje, upozornenia"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigácia gestami"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Na plochu prejdete potiahnutím z dolnej časti obrazovky smerom nahor. Aplikácie prepnete potiahnutím zdola nahor, podržaním a následným uvoľnením. Vrátite sa potiahnutím z ľavého alebo pravého okraja."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Trojtlačidlová navigácia"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Na návrat späť, zobrazenie plochy a prepínanie aplikácií slúžia tlačidlá v dolnej časti obrazovky."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigácia v systéme, navigácia dvoma tlačidlami, navigácia troma tlačidlami, navigácia gestami, potiahnutie"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitálny asistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Aktivovať asistenta potiahnutím"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Aktivujte aplikáciu digitálneho asistenta potiahnutím nahor z dolného rohu"</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Aktivovať Asistenta pridržaním tlačidla plochy"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Pridržaním tlačidla plochy spustiť digitálneho asistenta"</string>
    <string name="low_label" msgid="6525629096999711220">"Nízka"</string>
    <string name="high_label" msgid="357503396626018487">"Vysoká"</string>
    <string name="left_edge" msgid="1513576842959071849">"Ľavý okraj"</string>
    <string name="right_edge" msgid="1505309103265829121">"Pravý okraj"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Vyššia citlivosť môže kolidovať s gestami aplikácie pri okrajoch obrazovky."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Citlivosť prechádzania späť"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Citlivosť navigácie gestami"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigácia tlačidlami"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigácia gestami, citlivosť prechádzania späť, gesto späť"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigácia, tlačidlo plochy"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Režim jednej ruky"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Používať režim jednej ruky"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Skratka pre režim jednej ruky"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"dosiahnuteľnosť"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Potiahnutím nadol:"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Použitie tejto skratky"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Potiahnite nadol hornú polovicu obrazovky, aby ste na ňu ľahšie dosiahli jednou rukou"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Ako používať režim jednej ruky"</b>\n" • Nezabudnite v nastaveniach navigácie systému vybrať navigáciu gestami.\n • Potiahnite nadol popri dolnom okraji obrazovky."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Potiahnuť obrazovku na dosah"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Horná časť obrazovky sa presunie na dosah palca."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Zobrazovať upozornenia"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Zobrazia sa upozornenia a nastavenia."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Zobraziť čas, kontrolovať upozornenia a získať ďalšie informácie dvojitým klepnutím na obrazovku"</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Prebudiť obrazovku"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Zobraziť čas, kontrolovať upozornenia a získať ďalšie informácie klepnutím na obrazovku"</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Pomoc v tiesni"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Používať pomoc v tiesni"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Ak chcete spustiť akcie nižšie, stlačte vypínač aspoň päťkrát rýchlo po sebe"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Prehrať upozornenie na odpočítavanie"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Pri spustení pomoci v tiesni prehrať hlasný zvuk"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Volanie o pomoc"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Volanie o pomoc"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Číslo na volanie o pomoc"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Zmeníte klepnutím."</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Keď zadáte linku, ktorá nie je tiesňová:\n • vaše zariadenie musí byť odomknuté, aby sa dalo použiť na volanie o pomoc v tiesni;\n • hovor nemusí byť prijatý."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Zobraziť upozornenia odtlačkom prsta"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Potiahnutie prstom"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Rýchle zobrazenie upozornení"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Zapnuté"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Vypnuté"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Zavádzací program systému je už odomknutý"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Pripojte sa k internetu alebo kontaktujte svojho operátora"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nedostupné na zariadeniach s blokovaním operátora"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Reštartujte zariadenie a aktivujte tak funkciu ochrany zariadenia."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Uvoľnené celkove: <xliff:g id="SIZE">%1$s</xliff:g>\n\nNaposledy spustené: <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Okamžité aplikácie"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Otvárať odkazy v aplikáciách, aj keď nie sú nainštalované"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Okamžité aplikácie"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Nastavenia okamžitých aplikácií"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Nainštalované aplikácie"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Vaše úložisko odteraz riadi správca úložiska"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Účty používateľa <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automaticky synchronizovať dáta aplikácií"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Umožniť aplikáciám automatické obnovovanie dát"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Synchronizácia účtu"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Synchronizácia je zapnutá pre <xliff:g id="ID_1">%1$d</xliff:g> z <xliff:g id="ID_2">%2$d</xliff:g> položiek"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Synchronizácia je zapnutá pre všetky položky"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Synchronizácia je vypnutá pre všetky položky"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informácie o spravovanom zariadení"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Zmeny a nastavenia spravované vašou organizáciou"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Zmeny a nastavenia spravované organizáciou <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Vaša organizácia môže zmeniť nastavenia a nainštalovať softvér na vašom zariadení, aby vám poskytla prístup k pracovným dátam.\n\nĎalšie informácie získate od správcu organizácie."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Typy informácií, ktoré vidí vaša organizácia"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Zmeny, ktoré vykonal správca vašej organizácie"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Váš prístup k tomuto zariadeniu"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Dáta priradené k vášmu pracovnému účtu, ako napríklad pošta a kalendár"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Zoznam aplikácií na zariadení"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Strávený čas a objem využitých dát v každej aplikácii"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Posledný denník sieťovej premávky"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Posledné hlásenie chyby"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Posledný denník zabezpečenia"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Žiadne"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Nainštalované aplikácie"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Počet aplikácií je odhadnutý. Nemusí zahrnovať aplikácie nainštalované mimo Obchodu Play."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimálne # aplikácia}few{Minimálne # aplikácie}many{Minimum # apps}other{Minimálne # aplikácií}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Miestne povolenia"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Povolenia mikrofónu"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Povolenia fotoaparátu"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Predvolené aplikácie"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# aplikácia}few{# aplikácie}many{# apps}other{# aplikácií}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Predvolená klávesnica"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Nastavené na možnosť <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Trvalé pripojenie k sieti VPN je zapnuté"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Trvalé pripojenie k sieti VPN je zapnuté vo vašom osobnom profile"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Trvalé pripojenie k sieti VPN je zapnuté vo vašom pracovnom profile"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Bol nastavený globálny proxy server protokolu HTTP"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Dôveryhodné poverenia"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Dôveryhodné poverenia vo vašom osobnom profile"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Dôveryhodné poverenia vo vašom pracovnom profile"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimálne # certifikát CA}few{Minimálne # certifikáty CA}many{Minimum # CA certificates}other{Minimálne # certifikátov CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Správca môže uzamknúť zariadenie a obnoviť heslo"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Správca môže zo zariadenia odstrániť všetky údaje"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Počet nesprávnych zadaní hesla pred odstránením všetkých dát zariadenia"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Počet nesprávnych zadaní hesla pred odstránením dát pracovného profilu"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# pokus}few{# pokusy}many{# attempts}other{# pokusov}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Toto zariadenie spravuje vaša organizácia."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Toto zariadenie spravuje organizácia <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Ďalšie informácie"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Obmedzené nastavenie"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Povolené obmedzené nastavenia pre apl. <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"V rámci ochrany zabezpečenia toto nastavenie nie je momentálne k dispozícii."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informácie o financovanom zariadení"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Poskytovateľ úveru môže v tomto zariadení počas nastavovania meniť nastavenia a inštalovať softvér.\n\nAk zmeškáte splátku, poskytovateľ úveru môže uzamknúť vaše zariadenie a zmeniť jeho nastavenia.\n\nViac sa dozviete od svojho poskytovateľa úveru."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Ak máte zariadenie na úver, nemôžete:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Inštalovať aplikácie z iného zdroja ako Obchod Play"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Reštartovať svoje zariadenie do núdzového režimu"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Pridať do zariadenia viacero používateľov"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Zmeniť dátum, čas a časové pásma"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Používať nastavenia pre vývojárov"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Poskytovateľ úveru môže:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Získať prístup k číslu IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Ak sa niečo pokazí, obnovte výrobné nastavenia svojho zariadenia"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Po uzamknutí zariadenia budete môcť pomocou neho:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Uskutočňovať tiesňové volania"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Zobraziť si informácie o systéme, napríklad dátum, čas, stav siete a údaje o batérii"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Zapnúť alebo vypnúť zariadenie"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Zobrazovať upozornenia a textové správy"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Získať prístup k aplikáciám povoleným poskytovateľom úveru"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Po zaplatení plnej sumy:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Zo zariadenia budú odstránené všetky obmedzenia"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Môžete odinštalovať aplikáciu veriteľa"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Informácie o financovanom zariadení"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Kamerová aplikácia}few{Kamerové aplikácie}many{Camera apps}other{Kamerové aplikácie}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikácia Kalendár"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikácia Kontakty"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{E‑mailový klient}few{E‑mailové klienty}many{Email client apps}other{E‑mailové klienty}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikácia Mapa"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Telefónna aplikácia}few{Telefónne aplikácie}many{Phone apps}other{Telefónne aplikácie}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"Toto zariadenie"</string>
    <string name="storage_games" msgid="1176568610086802469">"Hry"</string>
    <string name="storage_files" msgid="7968460921272772299">"Súbory"</string>
    <string name="storage_images" msgid="2055893015567979387">"Obrázky"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videá"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Zvuk"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Aplikácie"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumenty a iné"</string>
    <string name="storage_system" msgid="8472410119822911844">"Systém"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Kôš"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Chcete vysypať kôš?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"V koši je tento počet súborov: <xliff:g id="TOTAL">%1$s</xliff:g>. Všetky položky budú navždy odstránené a nebudete ich môcť obnoviť."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Kôš je prázdny"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Vysypať kôš"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Využitý priestor: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Celkove <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Vymazať aplikáciu"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Chcete túto okamžitú aplikáciu odstrániť?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Otvoriť"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Hry"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Využitý priestor"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(odinštalované pre používateľa <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(vypnuté pre používateľa <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Služba automatického dopĺňania"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Predvolená služba automatického dopĺňania"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Heslá"</string>
    <string name="credman_chosen_app_title" msgid="7735183808067729319">"Preferovaná služba"</string>
    <string name="credman_credentials" msgid="2620352336624160642">"Ďalšie služby"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# heslo}few{# heslá}many{# passwords}other{# hesiel}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automaticky, vypĺňanie, automatické dopĺňanie, heslo"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"údaje, prístupový kľúč, heslo"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automatické, dopĺňanie, automatické dopĺňanie, údaje, prístupový kľúč, heslo"</string>
    <string name="credman_button_change" msgid="4072629639218503790">"Zmeniť"</string>
    <string name="credman_button_open" msgid="7519871964170816850">"Otvoriť"</string>
    <string name="credman_app_list_preference_none" msgid="2509646651254971448">"Nič nie je vybraté"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Skontrolujte, či ide o dôveryhodnú aplikáciu&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Automatické dopĺňanie Google&gt;%1$s&lt;/xliff:g&gt; určuje na základe obsahu obrazovky, čo je možné automaticky vyplniť."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Use &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Tu sa budú odteraz ukladať nové heslá, prístupové kľúče a ďalšie informácie. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; môže určovať, čo treba automaticky doplniť, pomocou obsahu na obrazovke."</string>
    <string name="credman_picker_title" msgid="8442086614222006564">"Preferovaná služba pre heslá, prístupové kľúče a automatické dopĺňanie"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Chcete službu %1$s vypnúť?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Chcete túto službu vypnúť?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Keď sa prihlásite, uložené informácie, ako sú heslá, prístupové kľúče, spôsoby platby a iné, sa nebudú dopĺňať. Ak chcete používať uložené údaje, vyberte heslo, prístupový kľúč alebo službu poskytujúcu údaje."</string>
    <string name="account_dashboard_title_with_passkeys" msgid="6214673787161409996">"Heslá, prístup. kľúče a autom. dopĺňanie"</string>
    <string name="credman_confirmation_message_new_ui" msgid="6126274509951156460">"&lt;b&gt;Chcete vypnúť všetky služby?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Keď sa prihlásite, heslá, prístupové kľúče a ďalšie uložené informácie nebudú pre automatické dopĺňanie k dispozícii."</string>
    <string name="credman_autofill_confirmation_message_new_ui" msgid="6222139222478822267">"&lt;b&gt;Chcete zmeniť preferovanú službu na &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Nové heslá, prístupové kľúče a ďalšie informácie sa budú odteraz ukladať tu. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; môže určovať, čo treba automaticky doplniť, pomocou obsahu na obrazovke."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Chcete používať %1$s?"</string>
    <string name="credman_confirmation_turn_off_positive_button" msgid="5678773011513369161">"Vypnúť"</string>
    <string name="credman_confirmation_change_provider_positive_button" msgid="7732302992885116967">"Zmeniť"</string>
    <string name="credman_limit_error_msg_title" msgid="1525814645803612135">"Môžete mať zapnutých maximálne päť služieb"</string>
    <string name="credman_limit_error_msg" msgid="2521803280130310063">"Vypnite aspoň jednu službu, ak chcete pridať ďalšiu"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s určuje na základe obsahu na obrazovke, čo je možné automaticky doplniť."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Limit hesiel, prístupových kľúčov a služieb poskytujúcich údaje"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"Naraz môžete mať aktívnych až päť hesiel, prístupových kľúčov a služieb poskytujúcich údaje. Ak chcete pridať ďalšiu službu, jednu vypnite."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Vypnúť"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automatické dopĺňanie"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Úroveň zaznamenávania"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maximum žiadostí na reláciu"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maximum viditeľných množín údajov"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Resetovať na predvolené hodnoty"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Možnosti automatického dopĺňania pre vývojárov boli obnovené"</string>
    <string name="location_category" msgid="3496759112306219062">"Poloha"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indikátor umiestnenia stavového riadka"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Zobrazí všetky miesta vrátane siete a pripojenia"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Vynútiť úplné meranie GNSS"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Sledovať všetky konštelácie a frekvencie GNSS bez cyklického vypínania a zapínania"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Metóda vstupu"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Písanie dotykovým perom"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Keď povolíte túto možnosť, aktuálne vybraná metóda vstupu dostane po zameraní editora parameter MotionEvent z dotykového pera."</string>
    <string name="device_theme" msgid="5027604586494772471">"Motív zariadenia"</string>
    <string name="default_theme" msgid="4815428567082263639">"Predvolený"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Názov siete"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Zobrazovať názov siete v stavovom riadku"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Okamžitá aplikácia"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Vypnúť správcu úložiska?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Aktualizovať režim bez vyrušení"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pozastavte upozornenia, aby ste sa mohli sústrediť"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkcia nie je k dispozícii"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Táto funkcia bola vypnutá, pretože spomaľuje telefón"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Vždy zobrazovať dialógové okno zlyhania"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Zobraziť dialógové okno pri každom zlyhaní aplikácie"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Vybrať aplikáciu podporujúcu ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nie je nastavená žiadna aplikácia podporujúca ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikácia podporujúca ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Predvoľby grafického ovládača"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Zmeniť nastavenia grafického ovládača"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Keď je k dispozícii viacero grafických ovládačov, môžete použiť aktualizovaný grafický ovládač pre aplikácie nainštalované v zariadení."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Povoliť pre všetky aplikácie"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Vybrať grafický ovládač"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Predvolené"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Ovládač hry"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Ovládač vývojára"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Grafický ovládač systému"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="enable_angle_as_system_driver" msgid="4648827560023949786">"Experimentálne: povoliť ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Upozornenie: Povoľte ovládač ANGLE ako predvolený ovládač OpenGL ES. Táto funkcia je experimentálna a nemusí byť kompatibilná s niektorými aplikáciami na ovládanie kamery a tvorbu videa."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Zmena systémového ovládača OpenGL ES vyžaduje reštart"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Zmeny v kompatibilite aplikácie"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Prepínať zmeny kompatibility aplikácie"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Predvolené aktivované zmeny"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Predvolené deaktivované zmeny"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Zmeny kompatibility môžete upraviť iba v prípade laditeľných aplikácií. Nainštalujte si laditeľnú aplikáciu a skúste to znova."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Závisí od iného nastavenia"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Účet"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"Počet účtov: %d"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Názov zariadenia"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Základné informácie"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Právne a regulačné informácie"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Podrobnosti o zariadení"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identifikátory zariadenia"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Ovládanie Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Povoliť aplikácii ovládať Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Toto povolenie umožňuje tejto aplikácii zapínať a vypínať Wi-Fi, hľadať siete Wi-Fi a pripájať sa k nim, pridávať a odstraňovať siete alebo vytvárať miestny hotspot"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Spustenie cez NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Povoliť spustenie po naskenovaní štítka NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Povoľte spúšťanie tejto aplikácie po naskenovaní štítka NFC.\nKeď je toto povolenie zapnuté, aplikácia bude k dispozícii ako možnosť pri každom rozpoznaní štítka."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Prehrať média v zariadení"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Pustiť <xliff:g id="LABEL">%s</xliff:g> cez"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"Zvuk sa prehrá cez"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Toto zariadenie"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Počas hovorov nie je k dispozícii"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Prijať hovor v zariadení"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Tento názov prístupového bodu sa nedá zmeniť."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Vypnúť zvonenie"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Súčasné stlačenie vypínača a tlačidla zvýšenia hlasitosti umožní:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Skratka na vypnutie zvonenia"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrovať"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Vypnúť zvuk"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrovať"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Vypnúť zvuk"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Ak chcete túto funkciu zapnúť, najprv zmeňte možnosť Pridržanie vypínača na ponuku vypínača."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Podrobnosti siete"</string>
    <string name="devices_title" msgid="649715719278562515">"Zariadenia"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Vybrať sieť"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Odpojené"</string>
    <string name="network_connected" msgid="7637745547242487795">"Pripojené"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Pripája sa…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Nepodarilo sa pripojiť"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nebola nájdená žiadna sieť."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Nepodarilo sa nájsť siete. Skúste to znova."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(zakázané)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Žiadna SIM karta"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Žiadne"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Na pripojenie sa vyžaduje SIM karta"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Na pripojenie sa vyžaduje SIM karta <xliff:g id="WIRELESS_CARRIER">%s</xliff:g>"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Preferovaný režim siete: preferované WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Preferovaný režim siete: iba GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Preferovaný režim siete: iba WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Preferovaný režim siete: GSM / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Preferovaný režim siete: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Preferovaný režim siete: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Preferovaný režim siete: iba CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Preferovaný režim siete: iba EVDO"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Preferovaný režim siete: CDMA / EvDo / GSM / WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Preferovaný režim siete: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Preferovaný režim siete: GSM / WCDMA / LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Preferovaný režim siete: CDMA + LTE / EvDo"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Preferovaný režim siete: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Preferovaný režim siete: globálny"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Preferovaný režim siete: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Uprednostňovaný režim siete: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Preferovaný režim siete: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Preferovaný režim siete: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Preferovaný režim siete: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Preferovaný režim siete: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Preferovaný režim siete: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Preferovaný režim siete: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Preferovaný režim siete: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Preferovaný režim siete: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Preferovaný režim siete: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Preferovaný režim siete: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Preferovaný režim siete: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Preferovaný režim siete: iba NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Preferovaný režim siete: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Preferovaný režim siete: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Preferovaný režim siete NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Preferovaný režim siete: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Preferovaný režim siete: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Preferovaný režim siete: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Preferovaný režim siete: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Preferovaný režim siete: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Preferovaný režim siete: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Preferovaný režim siete: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (odporúčané)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (odporúčané)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (odporúčané)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Vybrať sieť automaticky"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Nastavenia operátora"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Nastaviť dátovú službu"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobilné dáta"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Pristupovať k dátam pomocou mobilnej siete"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefón sa automaticky prepne na tohto operátora, keď bude v dosahu"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Nie je k dispozícii žiadna SIM karta"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Predvolená služba pre hovory"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Predvolená služba pre SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Vždy sa opýtať"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Pridať sieť"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Predvolená pre hovory"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Predvolená pre SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Predvolená pre hovory a SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Predvolená pre mobilné dáta"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobilné dáta sú aktívne"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobilné dáta sú vypnuté"</string>
    <string name="subscription_available" msgid="2659722770210403365">"K dispozícii"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Pridať SIM kartu"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktívne / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Neaktívne / SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktívna / eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Neaktívna / eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Názov a farba SIM karty"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Názov"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Farba (používajú kompatibilné aplikácie)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Uložiť"</string>
    <string name="mobile_network_use_sim_on" msgid="5333182776279917886">"Používať túto SIM kartu"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Vypnuté"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="7182341033728911879">"Ak chcete túto SIM kartu vypnúť, odstráňte ju"</string>
    <string name="mobile_network_tap_to_activate" msgid="5280456487243915465">"Klepnutím aktivujete SIM kartu operátora <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="5387971155494245850">"Vymazať eSIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Preferovaný typ siete"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Zmeniť prevádzkový režim siete"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Preferovaný typ siete"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Verzia nastavení operátora"</string>
    <string name="call_category" msgid="641461844504128789">"Volanie"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videohovory prostredníctvom operátora"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Výber systému"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Zmeniť režim roamingu CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Výber systému"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Sieť"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Odber CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Prepnúť medzi RUIM/SIM a NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"odber"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatická registrácia…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Chcete povoliť dátový roaming?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Informácie o cenách získate od svojho poskytovateľa siete."</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Neplatný režim siete <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorovať."</string>
    <string name="satellite_setting_title" msgid="2543034229989047673">"Správy cez satelit"</string>
    <string name="satellite_setting_enabled_summary" msgid="3554127722727530845">"Odosielajte a prijímajte textové správy cez satelit. Táto možnosť je zahrnutá vo vašom účte."</string>
    <string name="satellite_setting_disabled_summary" msgid="6789122487534159857">"Odosielajte a prijímajte textové správy cez satelit. Táto možnosť nie je zahrnutá vo vašom účte."</string>
    <string name="keywords_satellite_setting" msgid="3312183289776517695">"Správy cez satelit"</string>
    <string name="category_name_about_satellite_messaging" msgid="3756205049485508340">"Správy cez satelit"</string>
    <string name="title_about_satellite_setting" msgid="9212860038048311345">"Textová správy môžete odosielať a prijímať cez satelit, pretože váš účet <xliff:g id="CARRIER_NAME">%1$s</xliff:g> spĺňa podmienky."</string>
    <string name="category_title_your_satellite_plan" msgid="3017895097366691841">"Vaša tarifa <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="title_have_satellite_plan" msgid="2048372355699977947">"Správy cez satelit sú zahrnuté vo vašom účte"</string>
    <string name="title_no_satellite_plan" msgid="2876056203035197505">"Správy cez satelit nie sú zahrnuté vo vašom účte"</string>
    <string name="summary_add_satellite_setting" msgid="3815254731634052432">"Pridať správy cez satelit"</string>
    <string name="category_name_how_it_works" msgid="585303230539269496">"Ako to funguje"</string>
    <string name="title_satellite_connection_guide" msgid="3294802307913609072">"Keď nemáte k dispozícii mobilnú sieť"</string>
    <string name="summary_satellite_connection_guide" msgid="3496123195218418456">"Váš telefón sa automaticky pripojí k satelitu. V záujme čo najlepšieho pripojenia choďte na miesto, odkiaľ je dobrý výhľad na oblohu."</string>
    <string name="title_supported_service" msgid="4275535165812691571">"Keď sa váš telefón pripojí k satelitu"</string>
    <string name="summary_supported_service" msgid="4320535903444834786">"Textové správy môžete posielať komukoľvek, aj tiesňovej linke. Keď bude k dispozícii mobilná sieť, váš telefón sa k nej znova pripojí."</string>
    <string name="satellite_setting_summary_more_information" msgid="4008690241760925372">"Odosielanie a prijímanie správ cez satelit môže trvať dlhšie a v niektorých oblastiach nie je k dispozícii. Počasie a určité budovy môžu mať vplyv na pripojenie cez satelit. Volanie cez satelit nie je k dispozícii.\n\nMôže určitý čas trvať, kým zmeny vo vašom účte prejavia v Nastaveniach. Viac informácií vám poskytne <xliff:g id="CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="more_about_satellite_messaging" msgid="3385673133561348509">"Viac o správach cez satelit"</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Názvy prístupových bodov"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nie je k dispozícii pri pripojení k operátorovi <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Zobraziť viac"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Chcete zapnúť operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Chcete zapnúť SIM kartu?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Chcete prepnúť na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Chcete prepnúť na SIM kartu?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Chcete používať operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="7474905814976249607">"Naraz môže byť zapnutá iba jedna SIM karta.\n\nPrechodom k operátorovi <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> službu <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> nezrušíte."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="6415848271400253954">"Naraz môže byť zapnutá iba jedna eSIM karta.\n\nPrechodom k operátorovi<xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> službu <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> nezrušíte."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="421658355882679837">"Naraz môže byť zapnutá iba jedna SIM karta.\n\nPrechodom službu <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> nezrušíte."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Naraz môžete používať dve SIM karty. Ak chcete používať operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, vypnite druhú SIM kartu."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Prepnúť na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Vypnúť <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Vypnutím SIM karty službu nezrušíte"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="8144175623622669136">"Aktivuje sa SIM karta…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="697127154780501304">"Prepína sa na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="2718084141744769701">"SIM karty sa nedajú prepnúť"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="8332742656111984482">"Niečo sa pokazilo. SIM karty sa nedajú prepnúť."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Chcete vypnúť operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Chcete vypnúť SIM kartu?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Vypína sa SIM karta<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="1808735136395980905">"SIM karta sa nedá vypnúť"</string>
    <string name="privileged_action_disable_fail_text" msgid="6236231745255527458">"Niečo sa pokazilo a SIM kartu sa nepodarilo vypnúť."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Chcete používať dve SIM karty?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"V tomto zariadení môžu byť naraz aktívne dve SIM karty. Ak chcete ďalej používať len jednu, klepnite na Nie, vďaka."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Chcete reštartovať zariadenie?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Áno"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Reštartovať"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nie, vďaka"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Zrušiť"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Prepnúť"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Vypnúť"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"SIM kartu sa nepodarilo aktivovať"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Skúste SIM kartu znova zapnúť. Ak bude problém pretrvávať, reštartujte zariadenie."</string>
    <string name="sim_onboarding_bottomsheets_title" msgid="143711121394213711">"Nastavte si SIM kartu"</string>
    <string name="sim_onboarding_bottomsheets_msg" msgid="7367245016476460849">"Nastavte si predvoľby mobilnej siete, aby ste mohli v tomto zariadení používať viac SIM kariet"</string>
    <string name="sim_onboarding_label_sim_title" msgid="273162565849288273">"Označte si SIM karty štítkami"</string>
    <string name="sim_onboarding_label_sim_msg" msgid="5105859235219529056">"Tieto štítky sa budú zobrazovať v Nastaveniach a pri uskutočňovaní hovorov, odosielaní textových správ a používaní dát."</string>
    <string name="sim_onboarding_label_sim_dialog_title" msgid="5839073125605286120">"Štítok SIM karty"</string>
    <string name="sim_onboarding_label_sim_dialog_label" msgid="9020433985426525185">"Štítok"</string>
    <string name="sim_onboarding_select_sim_title" msgid="5895262188167744055">"Vyberte, ktoré SIM používať"</string>
    <string name="sim_onboarding_select_sim_msg" msgid="5638859405391915048">"Nemôžete súčasne používať dve SIM karty"</string>
    <string name="sim_onboarding_primary_sim_title" msgid="2793090401371135675">"Nastavte si primárne SIM karty"</string>
    <string name="sim_onboarding_primary_sim_msg" msgid="5484656671490558032">"Vyberte, ktoré SIM karty sa majú predvolene využívať na hovory, textové správy a dáta"</string>
    <string name="primary_sim_title" msgid="2508161011657571566">"Vaše primárne SIM karty"</string>
    <string name="primary_sim_calls_title" msgid="4961189133582615685">"Hovory"</string>
    <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>
    <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>
    <string name="sim_onboarding_progressbar_turning_sim_on" msgid="1163318788393361574">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> sa zapína…"</string>
    <string name="mobile_network_spn_title" msgid="3053793174495329077">"Mobilná sieť"</string>
    <string name="mobile_network_phone_number_title" msgid="2090794402855021784">"Telefónne číslo"</string>
    <string name="mobile_network_sim_label_color_title" msgid="2401352348041132876">"Štítok a farba SIM karty"</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktivácia siete"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Prepnutie operátora"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="975447139749692794">"SIM karta operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g> je aktívna"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Klepnutím aktualizujete nastavenia SIM karty"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Prepnuté na operátora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Prepnuté na iného operátora"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Mobilná sieť bola zmenená"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Nastavte ďalšiu SIM kartu"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Vyberte aktívnu SIM kartu alebo používajte dve naraz"</string>
    <string name="choose_sim_title" msgid="66509047151583877">"Vyberte, ktorá SIM karta sa má používať"</string>
    <string name="choose_sim_text" msgid="8992163497852069924">"{count,plural, =1{V tomto zariadení je k dispozícii 1 SIM karta, naraz sa dá však používať iba jedna}=2{2 SIMs are available on this device, but only one can be used at a time}few{V tomto zariadení sú k dispozícii # SIM karty, naraz sa dá však používať iba jedna}many{# SIMs are available on this device, but only one can be used at a time}other{V tomto zariadení je k dispozícii # SIM kariet, naraz sa dá však používať iba jedna}}"</string>
    <string name="choose_sim_activating" msgid="6485547671356386998">"Zapína sa profil<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="866488735834045525">"Túto SIM kartu sa momentálne nepodarilo zapnúť"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Chcete používať operátora <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> sa bude používať pre mobilné dáta, hovory a SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nie sú k dispozícii žiadne aktívne SIM karty"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Ak budete chcieť neskôr použiť mobilné dáta, funkcie hovorov a SMS, prejdite do nastavení siete"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM karta"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Chcete vymazať túto eSIM kartu?"</string>
    <string name="erase_sim_dialog_text" msgid="1406141218170595272">"Týmto odstránite službu <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> z tohto zariadenia, ale tarifa <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> sa nezruší."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Vymazať"</string>
    <string name="erasing_sim" msgid="4237180547590463930">"Vymazáva sa eSIM…"</string>
    <string name="erase_sim_fail_title" msgid="1445700500168357303">"eSIM sa nedá vymazať"</string>
    <string name="erase_sim_fail_text" msgid="6898841004987411547">"Niečo sa pokazilo a táto eSIM karta sa nevymazala.\n\nReštartujte zariadenie a skúste to znova."</string>
    <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"Pripojte sa pred vymazaním k sieti Wi-Fi"</string>
    <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"Uľahčuje to opätovné používanie eSIM v budúcnosti bez toho, aby ste museli kontaktovať operátora"</string>
    <string name="wifi_warning_continue_button" msgid="8171574741789688214">"Aj tak vymazať"</string>
    <string name="wifi_warning_return_button" msgid="6226063181583906340">"OK"</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Pripojenie k zariadeniu"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"<xliff:g id="APPNAME">%1$s</xliff:g> chce použiť dočasnú sieť Wi‑Fi na pripojenie k vášmu zariadeniu"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nenašli sa žiadne zariadenia. Skontrolujte, či sú zariadenia zapnuté a dostupné na pripojenie."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Skúsiť znova"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Vyskytol sa problém. Aplikácia zrušila žiadosť o výber zariadenia."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Pripojenie je úspešné"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Nepodarilo sa pripojiť"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Zobraziť všetko"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Hľadá sa zariadenie…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Pripája sa k zariadeniu…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Ľavé"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Pravé"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Puzdro"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Panel s nastaveniami"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Vynútiť režim pracovnej plochy"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Vynútiť experimentálny režim pracovnej plochy na sekundárnych obrazovkách"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Povoliť v režime viac. okien aplik. bez možn. zmeny veľkosti"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Povoliť v režime viacerých okien aplikácie bez možnosti zmeny veľkosti"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Presadiť tmavý režim"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Presadiť, aby bol tmavý režim vždy zapnutý"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Ochrana súkromia"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Povolenia, aktivita účtu, osobné údaje"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Ovládanie"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Odstrániť"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Ponechať"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Chcete odstrániť tento návrh?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Málo miesta. Využité: <xliff:g id="PERCENTAGE">%1$s</xliff:g>, voľné: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Odoslať spätnú väzbu"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Chcete nám v súvislosti s týmto návrhom poskytnúť spätnú väzbu?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Položka <xliff:g id="COPY_CONTENT">%1$s</xliff:g> bola skopírovaná do schránky."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Využitie dostupnosti"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{Do vášho zariadenia má úplný prístup 1 aplikácia}few{Do vášho zariadenia majú úplný prístup # aplikácie}many{# apps have full access to your device}other{Do vášho zariadenia má úplný prístup # aplikácií}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Dôležité informácie"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"POKRAČOVAŤ"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NIE, ĎAKUJEM"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Poloha"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Pri používaní tejto služby na tiesňové volania môže operátor zhromažďovať údaje o vašej polohe.\n\nPodrobnosti nájdete v pravidlách ochrany súkromia svojho operátora."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Môžete prísť o prístup k zostávajúcemu času či dátam. Pred odstránením sa poraďte so svojím operátorom."</string>
    <string name="content_capture" msgid="868372905432812238">"Obsah aplikácie"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Umožniť aplikáciám odosielať obsah do systému Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Zachytávať výpisy haldy systému"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Rozšírenie Memory Tagging Extension (MTE) uľahčuje vyhľadávanie problémov s bezpečnosťou pamäte vo vašej aplikácii a zvyšuje zabezpečenie natívneho kódu v nej."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Ak zapnete MTE, výkon zariadenia sa môže znížiť."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Ďalšie informácie o rozšírení MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Povoľte rozšírenie MTE, dokým ho nevypnete"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Ak chcete zapnúť MTE, musíte reštartovať zariadenie."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Ak chcete vypnúť MTE, musíte reštartovať zariadenie."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Povoliť MTE pre jednu reláciu"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Systém sa reštartuje a umožní experimentovanie s rozšírením Memory Tagging Extension (MTE). MTE môže negatívne ovplyvniť výkon a stabilitu systému. Resetuje sa pri ďalšom nasledujúcom reštarte."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Reštartovať pre jednu reláciu s povoleným rozšírením MTE"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"Rozšírenie MTE je už povolené"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Zachytávajú sa zálohy údajov systému"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Nepodarilo sa zachytiť výpis haldy systému"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automaticky zachytávať zálohy údajov systému"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automaticky zachytávať výpis haldy systému Android, keď využíva príliš veľa pamäte"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Odpojiť"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Tiesňové volania"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Váš operátor nepodporuje tiesňové volania pomocou volania cez Wi‑Fi.\nZariadenie sa na tiesňové volanie automaticky prepne na mobilnú sieť.\nTiesňové volania sú možné iba v oblastiach s mobilným signálom."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Volajte cez Wi‑Fi a zlepšite tak kvalitu"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Prichádzajúca správa MMS"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Správu MMS sa nepodarilo odoslať"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Klepnutím povolíte správy MMS cez operátora <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> pri vypnutých mobilných dátach"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problém s kombináciou SIM kariet"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Použitie operátora <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> môže obmedziť funkcie. Ďalšie informácie zobrazíte klepnutím."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Kombinácia SIM kariet"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informácie o pracovných pravidlách"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Nastavenia spravované vaším správcom IT"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"Grafický procesor"</string>
    <string name="enable_16k_pages" msgid="5009476566957520607">"Zapínať s veľkosťou stránky 16 kB"</string>
    <string name="enable_16k_pages_summary" msgid="428117226069445198">"Zap. zar. pomocou podpor. jadra so 16 kB stránkou"</string>
    <string name="confirm_enable_16k_pages_title" msgid="6751570067857011642">"Chcete reštartovať s kompatibilným jadrom so 16 kB stránkami?"</string>
    <string name="confirm_enable_16k_pages_text" msgid="702888115148257215">"UPOZORNENIE: Niektoré aplikácie nemusia byť s týmto režimom kompatibilné. Po potvrdení sa zariadenie reštartuje."</string>
    <string name="confirm_enable_4k_pages_title" msgid="626987400420355263">"Chcete reštartovať s kompatibilným jadrom so 4 kB stránkami?"</string>
    <string name="confirm_enable_4k_pages_text" msgid="6168921566226074524">"Po potvrdení sa zariadenie reštartuje."</string>
    <string name="toast_16k_update_failed_text" msgid="8888858987184345567">"Jadro sa nepodarilo aktualizovať na kompatibilné jadro so 16 KB stránkami"</string>
    <string name="progress_16k_ota_title" msgid="2117218313875523741">"Zmena sa uplatňuje"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Obsluha hlásení chýb"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Určuje, ktorá aplikácia vo vašom zariadení obsluhuje odkaz na hlásenie chýb."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Osobné"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Práca"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Predvolené systémom"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Žiadna aplikácia"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Táto voľba už nie je platná. Skúste to znova."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Pridržanie vypínača"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Pridržaním vypínača sa otvorí:"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Ponuka vypínača"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitálny asistent"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Prístup k digitálnemu asistentovi"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Otvorenie ponuky vypínača"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Pred použitím je potrebné nastaviť zámku obrazovky"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Ponuka vypínača:\nStlačte naraz vypínač a tlačidlo zvýšenia hlasitosti."</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Vypnutie zvonenia:\nskratku zobrazíte stlačením tlačidla hlasitosti"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Trvanie pridržania"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Upravte citlivosť tak, že vyberiete, ako dlho treba pridržať vypínač"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Krátke"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Dlhé"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Zobraziť peňaženku"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Povoliť prístup k peňaženke z uzamknutej obrazovky a rýchlych nastavení"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Zobrazovať skener QR kódov"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Povolenie prístupu ku skeneru QR kódov na uzamknutej obrazovke"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Zobrazovať ovládanie zariadení"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Z uzamknutej obrazovky"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Používať ovládanie zariadení"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Ak ho chcete použiť, najprv musíte zapnúť Zobraziť ovládanie zariadení"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Veľkosť hodín sa mení podľa obsahu na uzamknutej obrazovke"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dynamické hodiny"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Skratky"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="few"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="many"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Chcete vypnúť VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Bude tiež vypnuté pripojenie 5G.\nPočas hlasového hovoru nebudete môcť používať internet a niektoré aplikácie nemusia fungovať."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Pozastaviť spúšťanie aplikácií z vyrovnávacej pamäte"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Nikdy nevyprší."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Prenájom nikdy nevyprší."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Povoliť prekrývajúce prvky v Nastaveniach"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Povoliť aplikáciám, ktoré sa môžu zobraziť cez iné aplikácie, prekrývanie obrazoviek Nastavení"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Povoliť službu Mock Modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Povoliť spúšťanie služby Mock Modem v tomto zariadení na testovanie inštrumentácie. Túto možnosť nepovoľujte počas bežného používania telefónu"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications" msgid="4987116103699222633">"Deaktivácia ochrán počas zdieľania obrazovky"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications_summary" msgid="932295234626582052">"Deaktivuje ochrany aplikácie a upozornení systému počas zdieľania obrazovky"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Médiá"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Pripnúť prehrávač médií"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Prehrávač médií zostane otvorený v rýchlych nastaveniach, aby bolo možné rýchlo obnoviť prehrávanie"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Zobrazovať médiá na uzamknutej obrazovke"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Prehrávač médií zostane otvorený na uzamknutej obrazovke, aby bolo možné rýchlo obnoviť prehrávanie"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Zobrazovať odporúčania médií od Asistenta"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Na základe vašej aktivity"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Skryť prehrávač"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Zobraziť prehrávač"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"médiá"</string>
    <string name="camera_extensions_fallback_title" msgid="3604579046777004989">"Povoliť rozšírenia softvéru kamery"</string>
    <string name="camera_extensions_fallback_description" msgid="6939818294458854536">"Povolí predvolenú implementáciu softvéru pokročilých funkcií kamery, napríklad videografiu Eyes Free"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Zapne sa Bluetooth"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM karty"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Hovory a SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Volanie cez Wi‑Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Volajte a prijímajte hovory cez sieť Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Hovory"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferované"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"preferovaný na hovory"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"preferovaný na SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nie je k dispozícii"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Dočasne nedostupné"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Žiadna SIM karta"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Nastavenia siete"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"pripojenie k sieti, internet, bezdrôtové, dátové, wifi, wi-fi, wi fi, mobilné, mobilný operátor, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Chcete internet resetovať?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Internet sa resetuje…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Odstrániť problém s pripojením"</string>
    <string name="networks_available" msgid="3299512933684383474">"Dostupné siete"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Ak chcete prepnúť siete, odpojte ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Pripojenia W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Umožnite službe Google Fi zlepšovať rýchlosť a silu signálu pomocou sietí W+"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Sieť W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIM karty"</string>
    <string name="sim_category_active_sim" msgid="3077009911935592178">"Zapnutá"</string>
    <string name="sim_category_inactive_sim" msgid="7351553344148400450">"Vypnutá"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Predvolené pre <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"hovory"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobilné dáta"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Aplikácie a služby môžu kedykoľvek vyhľadávať siete Wi‑Fi (a to aj vtedy, keď je pripojenie Wi‑Fi vypnuté), čím zlepšujú prostredie v zariadení. Môžu tak napríklad zlepšovať fungovanie funkcií a služieb podmienených polohou. Toto nastavenie môžete zmeniť v nastaveniach vyhľadávania sietí Wi‑Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Zmeniť"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Pripojené"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Dočasne pripojené"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Dočasne sa používa <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Bez pripojenia"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobilné dáta sa nepripájajú automaticky"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Chcete vypnúť mobilné dáta?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Prostredníctvom operátora <xliff:g id="CARRIER">%s</xliff:g> nebudete mať prístup k dátam ani internetu. Internet bude k dispozícii iba cez Wi‑Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"váš operátor"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Nie je povolené vašou organizáciou"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nedostupné, pretože je zapnutý režim večierky"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Resetovanie dôležitosti upozornenia je dokončené."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikácie"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Zariadenie vyžaduje prístup k vašim správam. Klepnutím zobrazíte podrobnosti."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Chcete povoliť prístup k správam?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Zariadenie <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> s rozhraním Bluetooth vyžaduje prístup k vašim správam.\n\nK zariadeniu <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> ste sa predtým nikdy nepripojili."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Zariadenie vyžaduje prístup k vašim kontaktom a zoznamu hovorov. Klepnutím zobrazíte podrobnosti."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Chcete povoliť prístup ku kontaktom a zoznamu hovorov?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Zariadenie <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> s rozhraním Bluetooth vyžaduje prístup k vašim kontaktom a zoznamu hovorov. Zahŕňa to údaje o prichádzajúcich a odchádzajúcich hovoroch.\n\nK zariadeniu <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> ste sa predtým nikdy nepripojili."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Jas"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Uzamknutie obrazovky"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Vzhľad"</string>
    <string name="category_name_color" msgid="937514550918977151">"Farba"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Ďalšie ovládanie obrazovky"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Všeobecné"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Používať tmavý motív"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Používať Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Vypnúť zvonenie"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Používať hotspot Wi‑Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Používať pripnutie aplikácie"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Používať nastavenia pre vývojárov"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Používať tlačovú službu"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Povoliť viacero používateľov"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"povoliť, viacero, používateľ, povolenie, veľa"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Používať bezdrôtové ladenie"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Používanie predvolieb grafického ovládača"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Používať nočný režim"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Používať NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Používať adaptáciu jasu"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Používanie volania cez Wi‑Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Zobraziť všetky aplikácie"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Inteligentné presmerovanie"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Inteligentné presmerovanie je aktivované"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Inteligentné presmerovanie je deaktivované"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Nastavenia hovorov"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Aktualizujú sa nastavenia…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Chyba nastavení hovorov"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Chyba siete alebo SIM karty."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM karta nie je aktivovaná."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Zadajte telefónne čísla"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Zadajte telefónne číslo"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Chýba telefónne číslo."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Povoliť 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"Sieť 2G je menej bezpečná, ale na niektorých miestach môže zlepšiť pripojenie. V prípade tiesňových volaní je sieť 2G stále povolená."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> vyžaduje dostupnosť siete 2G"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Vyžadovať šifrovanie"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Šifrovanie je viac zabezpečené, ale na niektorých miestach sa možno nebudete môcť pripojiť. V prípade tiesňových volaní sa nikdy nevyžaduje."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Všetky služby"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Zobraziť prístup k schránke"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Zobrazovať správu, keď aplikácie získajú pristup k textu, obrázkom alebo inému obsahu, ktorý ste skopírovali"</string>
    <string name="all_apps" msgid="3054120149509114789">"Všetky aplikácie"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Nepovoliť"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra-Wideband (UWB)"</string>
    <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>
    <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>
    <string name="mic_toggle_description" msgid="484139688645092237">"Pre aplikácie a služby. Keď je toto nastavenie vypnuté a zavoláte na tiesňovú linku, môžu sa stále zdieľať údaje mikrofónu."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Naspäť"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Ďalej"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Ukážka farby"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Žiadosť o prístup k SIM karte"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Zariadenie požaduje prístup k vašej SIM karte. Klepnutím zobrazíte podrobnosti."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Chcete povoliť prístup k SIM karte?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Zariadenie s rozhraním Bluetooth <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> požaduje prístup k údajom na vašej SIM karte. Zahŕňa to aj kontakty.\n\nPočas pripojenia bude zariadenie <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> prijímať všetky hovory smerujúce na číslo <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"K dispozícii je zariadenie s rozhraním Bluetooth"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Zariadenie sa chce pripojiť. Klepnutím zobrazíte podrobnosti."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Chcete sa pripojiť k zariadeniu s rozhraním Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> sa chce pripojiť k tomuto telefónu.\n\nK zariadeniu <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> ste sa ešte nikdy nepripojili."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Nepripojiť"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Pripojiť"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Nastavenia TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Zapnuté"</string>
    <string name="tare_off" msgid="6305694402929756726">"Vypnuté"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Vrátiť na predvolené nastavenia"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Boli vrátené predvolené nastavenia."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Max. rovnováha pri úplnom nabití zariad."</string>
    <string name="tare_balances" msgid="731881382594747961">"Zostatky"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Limity spotreby"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Limit počiatočnej spotreby"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Limit minimálnej spotreby"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Limit maximálnej spotreby"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikátory"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Akcie (realizačné náklady)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Akcie (základná cena)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Odmeny za jednu udalosť"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Odmeny za každú sekundu trvania udalosti"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maximálny počet odmien za deň"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Inštalácia aplikácie"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Najčastejšia aktivita"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Zhliadnutie upozornenia"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Zhliadnutie upozornenia do 15 minút"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interakcia s upozornením"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interakcia s miniaplikáciou"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Iná interakcia používateľa"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Spustenie procesu s maximálnou prioritou"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Je spustený proces s max. prioritou"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Spustenie procesu s vysokou prioritou"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Je spustený proces s vysokou prioritou"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Spustenie procesu s predvol. prioritou"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Je spustený proces s predvol. prioritou"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Spustenie procesu s nízkou prioritou"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Je spustený proces s nízkou prioritou"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Spustenie procesu s minimálnou prioritou"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Je spustený proces s min. prioritou"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Pokuta za vypršanie čas. limitu procesu"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimálna rovnováha pri úplnom nabití zariadenia (s výnimkou)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Min. rovnováha pri úplnom nabití (systémová aplikácia bez grafického rozhrania)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimálna rovnováha pri úplnom nabití zariadenia (zvyšné aplikácie)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Minimálny zostatok pri úplnom nabití (aktualizácia aplikácií)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Nabíjanie"</item>
    <item msgid="658627268149681677">"Zdriemnutie"</item>
    <item msgid="1599558140284643834">"Úsporný režim"</item>
    <item msgid="588427840913221601">"Stav procesov"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Potvrdiť"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Zobraziť ukážku"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Vyberte šetrič obrazovky"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Zobrazovať ďalšie informácie"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Zobrazovať na šetriči obrazovky informácie ako čas, počasie a ďalšie"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Zobrazovať ovládanie domácnosti"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Zobrazovať na šetriči obrazovky tlačidlo ovládania domácnosti"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Ďalšie nastavenia"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Výber šetriča obrazovky"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Vyberte, čo sa bude zobrazovať na vašej obrazovke po vložení tabletu do doku. Zariadenie môže pri používaní šetriča obrazovky spotrebúvať viac energie."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Prispôsobiť"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Prispôsobiť <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Zapnutie podpory funkcie Freeform vyžaduje reštartovanie."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Vynútenie režimu pracovnej plochy na sekundárnych obrazovkách vyžaduje reštartovanie."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Reštartovať"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Reštartovať neskôr"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Priestorový zvuk"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Zvuk z kompatibilných médií bude strhujúcejší"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Sledovanie pohybov hlavy"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Zmeny zvuku pri pohybe hlavou budú prirodzenejšie"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Synchronizácia povolení z telefónu"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Udeľte hodinkám rovnaké povolenia aplikácie, ktoré ste poskytli v tomto telefóne"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Typ audio zariadenia"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Neznáme"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Reproduktor"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Slúchadlá"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Načúvadlo"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Súprava do auta"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Iné"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Limit rýchlosti sťahovania v sieti"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Nakonfigurujte limit rýchlosti sťahovania v sieti, ktorý sa bude vzťahovať na všetky siete umožňujúce pripojenie k internetu."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfigurácia limitu rýchlosti sťahovania v sieti"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Bez limitu"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Vypnúť obmedzenia podradených procesov"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Vypnúť obmedzenia podradených procesov na používanie zdroja systému"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Vynútiť povolenie roly Poznámky"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Povoľte integrácie systému na písanie poznámok prostredníctvom roly Poznámky. Ak je rola Poznámky už povolená, nič sa nestane. Vyžaduje sa reštart."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Vysielanie"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Vysielanie aplikácie <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Počúvajte vysielania v okolí"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Vysielajte médiá do zariadení v okolí alebo si vypočujte vysielanie inej osoby"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Vysielania"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Vysielania, ktoré počúvate"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Vyhľadať vysielania"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Opustiť vysielanie"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Skenovať QR kód"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Zadajte heslo"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Nedá sa pripojiť. Skúste to znova."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Nesprávne heslo"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"K vysielaniu sa nedá pripojiť"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Ak chcete začať počúvať, umiestnite QR kód do stredu nižšie"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR kód nie je platný formát"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Konvertovať na eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Preniesť eSIM kartu do iného zariadenia"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# aplikácia}few{# aplikácie}many{# apps}other{# aplikácií}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Aplikácie inštalované na pozadí"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Výrobca vášho zariadenia môže v zariadení inštalovať aplikácie na pozadí alebo takýto postup povoliť vášmu operátorovi či iným partnerom.\n\nŽiadne aplikácie, ktoré sú tu uvedené, nie sú potrebné na to, aby vaše zariadenie normálne fungovalo. Aplikácie, ktoré nechcete, môžete odinštalovať."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Na pozadí neboli nainštalované žiadne aplikácie"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Odinštalovať aplikáciu"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Aplikácie nainštalované za posledný # mesiac}few{Aplikácie nainštalované za posledné # mesiace}many{Aplikácie nainštalované za posledného # mesiaca}other{Aplikácie nainštalované za posledných # mesiacov}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Aplikácie nainštalované pred viac než # mesiacom}few{Aplikácie nainštalované pred viac než # mesiacmi}many{Aplikácie nainštalované pred viac než # mesiaca}other{Aplikácie nainštalované pred viac než # mesiacmi}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Pomer strán"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Vyskúšajte nový pomer strán, v ktorom sa bude aplikácia zobrazovať, ak nie je navrhnutá pre rozmer obrazovky vášho zariadenia <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Vyskúšajte nový pomer strán, v ktorom sa bude aplikácia zobrazovať, ak nie je navrhnutá pre rozmer obrazovky vášho zariadenia <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Niektoré aplikácie nemusia byť optimalizované pre určité pomery strán."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Vyskúšajte nový pomer strán na zobrazenie aplikácie, keď nebola navrhnutá pre zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Vyskúšajte nový pomer strán na zobrazenie aplikácie, keď nebola navrhnutá pre zariadenie <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Niektoré aplikácie sa nemusia dať optimalizovať na určité pomery strán."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Navrhované aplikácie"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Zmenené aplikácie"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Predvolené nastavenie aplikácie"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Celá obrazovka"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Polovica obrazovky"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Pomer strán zariadenia"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16 : 9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g> – <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Keď zmeníte pomer strán, aplikácia sa reštartuje. Môžete prísť o neuložené zmeny. Niektoré aplikácie nemusia byť optimalizované pre určité pomery strán."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Pomer strán (experimentálne)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Pomer strán (experiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Pomer strán (laboratóriá)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Experimentálne"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Experiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Laboratóriá"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Senzor odtlačkov prstov"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Svetelné upozornenia"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Svetelné upozornenia"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Vypnuté"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Zapnuté / zasvieti blesk"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Zapnuté / blikanie obrazovky"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Zapnuté / zasvieti blesk aj obrazovka"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Nastavte si, aby zasvietil blesk či obrazovka, keď dostanete upozornenie alebo zaznie budík"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Aktivujte si funkciu blikania obrazovky, keď dostanete upozornenie alebo zaznie budík"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Ak patríte medzi osoby citlivé na svetlo, používajte svetelné upozornenia obozretne"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"blesk, svetlo, slabo počujúci, strata sluchu"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Zobraziť ukážku"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Pri upozornení zasvietiť bleskom"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Pri upozornení blikať obrazovkou"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Farba blikania obrazovky"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Modrá"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azúrová"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Modrozelená"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Jarná zelená"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Zelená"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Bylinkovo zelená"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Žltá"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranžová"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Červená"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Ružová"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Ružovofialová"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Fialová"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Hotovo"</string>
    <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>
    <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>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Zapnuté"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Vypnuté"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Vypnuté"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Vypnuté"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Zapnuté"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Vypnuté"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Zapnuté"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Vypnuté"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Prepne svetlú obrazovku na tmavú a naopak"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Priblíženie obrazovky"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Vypnuté"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Vypnuté"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Zapnuté"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Vypnuté"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Zapnuté"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Názov zariadenia je viditeľný pre aplikácie, ktoré ste nainštalovali. Keď sa pripojíte k zariadeniam s rozhraním Bluetooth alebo sieti Wi‑Fi, prípadne nastavíte hotspot Wi‑Fi, môžu ho uvidieť aj ďalší ľudia."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Gramatický rod"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Výber gramatického rodu"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Kontrola prítomnosti klamlivých aplikácií"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Kontrola aktivity v aplikácii, či nedochádza k phishingu"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Používať detekciu podvodných aplikácií"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Používať detekciu podvodných pracovných aplikácií"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
    <string name="accessibility_setup_password_complete" msgid="6358749253318369077">"Heslo je nastavené"</string>
    <string name="show_stylus_pointer_icon" msgid="1010583689203665786">"Zobrazovať ukazovateľ pri umiestnení kurzora myši"</string>
</resources>
