<?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">"Jah"</string>
    <string name="no" msgid="5541738710521607130">"Ei"</string>
    <string name="create" msgid="986997212165228751">"Loo"</string>
    <string name="allow" msgid="3763244945363657722">"Luba"</string>
    <string name="deny" msgid="7326117222944479942">"Keela"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Lülita sisse"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Tundmatu"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Puudutage teabe kuvamiseks"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{# toiming veel ja olete arendaja.}other{# toimingut veel ja olete arendaja.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Olete nüüd arendaja!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Ei ole vaja, olete juba arendaja."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Lubage esmalt arendaja valikud."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Süsteem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Teenus toimib"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Teenus ei toimi"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Raadio on väljas"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Rändlus"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Rändlus puudub"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Ühendus katkestatud"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Ühendamine"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Ühendatud"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Peatatud"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Teadmata"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Eelvaade"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Vähendamine"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Suurendamine"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Alati"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Esiekraan lülitub seadme kokkuvoltimisel sisse"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Ainult mängude, videote jne puhul"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Esiekraan lülitub sisse rakenduste jaoks, mis takistavad ekraanil unerežiimile lülitumist"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Mitte kunagi"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Esiekraan lukustub seadme kokkuvoltimisel"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Kasuta automaatset pööramist"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Näotuvastus kasutab esikaamerat, et parandada automaatse pööramise täpsust. Pilte ei salvestata ega saadeta kunagi Google\'ile."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Nähtav kõigile lähedalasuvatele Bluetooth-seadmetele (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Nähtav kõigile lähedalasuvatele Bluetooth-seadmetele"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Ei ole nähtav teistele Bluetooth-seadmetele"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Nähtav ainult seotud seadmetele"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth-seadmed"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Seadme nimi"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Seadme ümbernimetamine"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Nimeta ümber"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Kas katkestada seadme ühendus?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Uue seadme sidumine"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Seo parempoolne"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Seo vasakpoolne"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Teise kõrva sidumine"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Teie vasakpoolne kuuldeseade on ühendatud.\n\nParempoolse sidumiseks veenduge, et see oleks sisse lülitatud ja sidumiseks valmis."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Teie parempoolne kuuldeseade on ühendatud.\n\nVasakpoolse sidumiseks veenduge, et see oleks sisse lülitatud ja sidumiseks valmis."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Seo parempoolne"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Seo vasakpoolne"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Kõigi saadaolevate kuuldeseadmete jaoks"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Kuuldeseadme seaded"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Otsetee, ühilduvus kuuldeaparaatidega"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Selle seadme jaoks"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Heliväljund"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Teave heliväljundi kohta"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Helid suunatakse kuuldeseadmesse või telefoni kõlarisse"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Seotud"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Helin ja äratused"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Heli kõnede ajal"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Meedia"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Märguanded ja muud süsteemihelid"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Vaikimisi määravad heliväljundi individuaalsed rakendused"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Nimetu Bluetooth-seade"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Otsimine"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Läheduses ei leitud Bluetooth-seadmeid."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Bluetoothi sidumisettepanek"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Sidumistaotlus"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Puudutage seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> sidumiseks."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth on väljas"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Puudutage sisselülitamiseks"</string>
    <string name="device_picker" msgid="2427027896389445414">"Bluetooth-seadme valimine"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi sisse lülitada"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi välja lülitada"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Rakendus soovib Bluetoothi sisse lülitada"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Rakendus soovib Bluetoothi välja lülitada"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Bluetoothi sisselülitamine ..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Bluetoothi väljalülitamine ..."</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Bluetooth-ühenduse taotlus"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Taotlus telefoniraamatule juurdepääsuks"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Taotlus sõnumile juurdepääsuks"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Teistele seadmetele nähtav seadmena „<xliff:g id="DEVICE_NAME">^1</xliff:g>”"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Teiste seadmetega ühendamiseks lülitage Bluetooth sisse."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Teie seadmed"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Uue seadme sidumine"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Keela Bluetoothi A2DP riistvara mahalaadimine"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Keela Bluetooth LE Audio riistvara mahalaadimine"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Kas taaskäivitada seade?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Selle seade muutmiseks peate seadme taaskäivitama."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Taaskäivita"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Tühista"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Keela Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Keelab funktsiooni Bluetooth LE Audio, kui seade toetab LE Audio riistvara võimalusi."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Kuva seadme üksikasjades LE Audio lüliti"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Bluetooth LE Audio lubamisloendist möödaminek"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"LE Audiot kasutatakse vaikimisi isegi siis, kui LE Audio välisseadme vastavust lubamisloendi kriteeriumitele pole kinnitatud."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Meediaseadmed"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Helistamisseadmed"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Muud seadmed"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Salvestatud seadmed"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Kontoga seotud"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Varem kontoga kasutatud"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth lülitatakse sidumiseks sisse"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Ühenduse eelistused"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Eelnevalt ühendatud"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth on sisse lülitatud"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Kuva kõik"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Kuva kõik"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Elektronpliiats"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Taganupu vajutus"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (tööprofiil)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Kirjutamine tekstiväljadele"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Elektronpliiatsi kõigi nupuvajutuste eiramine"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Elektronpliiats"</string>
    <string name="audio_sharing_title" msgid="4144157137502923821">"Heli jagamine"</string>
    <string name="audio_sharing_switch_title" msgid="7052827328670825701">"Heli jagamine"</string>
    <string name="calls_and_alarms_device_title" msgid="6993559028175454198">"Kõned ja äratused"</string>
    <!-- no translation found for audio_sharing_streams_category_title (862958129650324581) -->
    <skip />
    <!-- no translation found for audio_sharing_streams_pref_title (4636293245167657721) -->
    <skip />
    <!-- no translation found for audio_sharing_streams_title (8269455097512153101) -->
    <skip />
    <!-- no translation found for audio_sharing_streams_qr_code_summary (4231875597377863735) -->
    <skip />
    <string name="date_and_time" msgid="1788358029823431692">"Kuupäev ja kellaaeg"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Puhverserver"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Kustuta"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Puhverserveri port"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Puhverserverist mööduvad"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Taasta vaikeväärtused"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Valmis"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Puhverserveri hosti nimi"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Tähelepanu"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Sisestatud hosti nimi on kehtetu."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Sisestatud välistusloend ei ole õigesti vormindatud. Sisestage välistatud domeenide komadega eraldatud loend."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Peate täitma pordi välja."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Pordi väli peab olema tühi, kui hosti väli on tühi."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Sisestatud port on kehtetu."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Brauser kasutab HTTP-puhverserverit, kuid muud rakendused ei pruugi seda kasutada."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Pingi hosti nimi (www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP-kliendi test:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Pingimistesti käitamine"</string>
    <string name="skip_label" msgid="6380034601349015895">"Jäta vahele"</string>
    <string name="next_label" msgid="1248293387735652187">"Järgmine"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Keeled"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Eelistatud keelte järjestus"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Süsteemi keel"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Eemalda"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Lisa keel"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Keel"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Eelistatud keel"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Rakenduste keeled"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Iga rakenduse keele määramine"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Rakenduse keel"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Soovitatud keeled"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Kõik keeled"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Süsteemi keel"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Süsteemi vaikeseade"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Selle rakenduse jaoks pole seadetes keele valimine saadaval."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Keel võib rakenduses saadaolevatest keeltest erineda. Mõni rakendus ei pruugi seda seadet toetada."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Määrake iga rakenduse jaoks keel."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Teie süsteem, rakendused ja veebisaidid kasutavad teie eelistatud keelte hulgast esimest toetatud keelt."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Iga rakenduse puhul keele valimiseks avage rakenduse keeleseaded."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Lisateave rakenduse keelte kohta"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Kas valida süsteemi keeleks %s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Kas lisada %s eelistatud keelte hulka?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"See annab rakendustele ja veebisaitidele teada, et eelistate ka seda keelt."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Teie seadme seaded ja piirkondlikud eelistused muutuvad."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Muuda"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s pole saadaval"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Seda keelt ei saa süsteemi keelena kasutada, kuid olete teavitanud rakendusi ja veebisaite, et eelistate seda keelt."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Piirkondlikud eelistused"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Ühikute ja numbrite eelistuste määramine"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Esitage rakendustele oma piirkondlikud eelistused, et need saaks teie kasutuskogemust isikupärastada."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Rakendused kasutavad võimaluse korral teie piirkondlikke eelistusi."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatuur"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Nädala esimene päev"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Numbrite eelistused"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Kasuta vaikesätet"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Pühapäev"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Esmaspäev"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Teisipäev"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Kolmapäev"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Neljapäev"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Reede"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Laupäev"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Kui rakendus ei toeta piirkondlikke eelistusi, kasutab rakendus oma vaikelokaadi seadeid."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Vaadake keele-eelistuste kohta lisateavet."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Lisaeelistused"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Aadressitingimused"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Määrake, kuidas soovite, et teie poole pöördutaks"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Rakendused võivad kasutada teie aadressitingimusi, et isikupärastada, kuidas teie poole pöörduda."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Pole määratud"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Naissoost"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Meessoost"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutraalne"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Kas eemaldada valitud keel?}other{Kas eemaldada valitud keeled?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Tekst kuvatakse teises keeles."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Kõiki keeli ei saa eemaldada"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Jätke alles vähemalt üks eelistatud keel"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Pole süsteemikeelena saadaval"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Teisalda üles"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Teisalda alla"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Teisalda kõige üles"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Teisalda kõige alla"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Eemalda keel"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Tegevuse valimine"</string>
    <string name="cancel" msgid="5780102414089664898">"Tühista"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Unusta"</string>
    <string name="save" msgid="3125033126936493822">"Salvesta"</string>
    <string name="done" msgid="7497982645646431310">"Valmis"</string>
    <string name="apply" msgid="7834684883190163536">"Rakenda"</string>
    <string name="share" msgid="8502235338607613795">"Jaga"</string>
    <string name="add" msgid="8335206931421683426">"Lisa"</string>
    <string name="remove" msgid="1028414219245072102">"Eemalda"</string>
    <string name="settings_label" msgid="943294133671632976">"Seaded"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Seaded"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Seadete otsetee"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Lennukirežiim"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Traadita ühendus ja võrgud"</string>
    <string name="roaming" msgid="3055365654530847985">"Rändlus"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Ühenda rändluse ajal andmesideteenustega"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Ühenda rändluse ajal andmesideteenustega"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Rakenduda võivad rändlustasud."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Määra kellaaeg automaatselt"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Määra automaatselt"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Kui lüliti on sisse lülitatud, siis kasutatakse ajavööndi määramiseks seadme asukohta."</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Kasuta lokaadi vaikeseadet"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"24-tunnise vormingu kasutamine"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Kellaaeg"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Kellaaja vorming"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Ajavöönd"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Ajavööndi valimine"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Kuupäev"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Otsingupiirkond"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Piirkond"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"UTC-nihke valimine"</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">"Kasutab ajavööndit <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> algab kuupäeval <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Kasutab ajavööndit <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Suveaega pole."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Suveaeg"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Aeg"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Vali piirkonna alusel"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"UTC nihke alusel valimine"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Lukustamine pärast ekraani ajalõppu"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast ajalõppu"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Kohe pärast ajalõppu, välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> hoiab seadme avatuna"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast ajalõppu, välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> hoiab seadme avatuna"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Teksti lisamine lukustuskuvale"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Puudub"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Nt Martini Android."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Asukoht"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Kasuta asukohta"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Väljas"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Sees / # rakendusel on asukohale juurdepääs}other{Sees / # rakendusel on asukohale juurdepääs}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Laadimine …"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Rakendused, millel on luba läheduses olevatele seadmetele juurde pääseda, saavad määrata ühendatud seadmete suhtelise asukoha."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Juurdepääs asukohale on rakenduste ja teenuste jaoks välja lülitatud. Teie seadme asukoht võidakse siiski päästeteenistusele saata, kui helistate või saadate sõnumi hädaabinumbrile."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Lisateave asukohaseadete kohta"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Kontod"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Turvalisus"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Krüpteerimine ja mandaadid"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Lukustuskuva"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Mida kuvada?"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Pole saadaval"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Turvalisuse olek"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Ekraanilukk, Leia mu seade, rakenduse turvalisus"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Turvalisus ja privaatsus"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Rakenduste turvalisus, seadme lukustus, load"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Nägu on lisatud"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Seadistamine on vajalik"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Näoga avamine"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Näoga avamine töö jaoks"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Näoga avamise seadistamine"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Näoga avamise seadistamine"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Kasutage autentimiseks oma nägu"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Alustage"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Kui hõlbustatud näoga avamine välja lülitatakse, ei pruugi mõned seadistustoimingud TalkBackiga õigesti töötada."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Mine tagasi"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Jätka seadistamist"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Kasuta juurdepääset. seadistust"</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">"Tühista"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Tänan, ei"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Nõustun"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Rohkem"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Avage oma näoga"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Lubage näoga avamine"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Kasutage autentimiseks oma nägu"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Kasutage telefoni avamiseks või ostude kinnitamiseks oma nägu.\n\nMärkus: te ei saa kasutada oma nägu selle seadme avamiseks. Lisateabe saamiseks võtke ühendust oma organisatsiooni administraatoriga."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Kasutage oma nägu telefoni avamiseks, ostude volitamiseks või rakendustesse sisselogimiseks"</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">"Hoidke oma nägu ringi keskel"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Jäta vahele"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Olete lisanud maksimaalse arvu nägusid"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Rohkem nägusid ei saa lisada"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registreerimist ei lõpetatud"</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">"Näo registreerimisaeg lõppes. Proovige uuesti."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Näo registreerimine ei toiminud."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Kõik on valmis. Kõik on korras."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Valmis"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Täiustage näoga avamise toimivust"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Seadistage näoga avamine uuesti"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Seadistage näoga avamine uuesti"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Täiustage turvalisust ja toimivust"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Näoga avamise seadistamine"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Näoga avamise uuesti seadistamiseks kustutage oma praegune näomudel.\n\nTeie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist tuleb teil telefoni avamiseks või rakendustes autentimiseks sisestada PIN-kood, muster või parool."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Näoga avamise uuesti seadistamiseks kustutage oma praegune näomudel.\n\nTeie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist tuleb teil telefoni avamiseks või rakendustes autentimiseks kasutada sõrmejälge või sisestada PIN-kood, muster või parool."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Kasuta näoga avamist"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Näoga avamise kasutamisel"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Nõua avatud silmi"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Telefoni avamiseks peavad teie silmad avatud olema"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Nõua alati kinnitust"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Näoga avamise kasutamisel rakendustes nõutakse alati kinnitustoimingut."</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Kustuta näomudel"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Näoga avamise seadistamine"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Kas kustutada näomudel?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Teie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist vajate telefoni avamiseks või rakendustes autentimiseks PIN-koodi, mustrit või parooli."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Teie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist vajate telefoni avamiseks PIN-koodi, mustrit või parooli."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Teie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist vajate telefoni avamiseks või rakendustes autentimiseks sõrmejälge, PIN-koodi, mustrit või parooli."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Teie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist vajate telefoni avamiseks sõrmejälge, PIN-koodi, mustrit või parooli."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Kasutage oma telefoni avamiseks näoga avamise funktsiooni"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Sõrmejälg"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Sõrmejälg"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Sõrmejäljega avamist kasutades"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Sõrmejälg töö jaoks"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Sõrmejälje lisamine"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Sõrmejälg on lisatud}other{# sõrmejälge on lisatud}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Seadistamine on vajalik"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Sõrmejälje seadistamine"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Lubage sõrmejäljega avamine"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Sõrmejälje kasutamine"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Vaadake lisateavet sõrmejäljega avamise kohta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Teie juhite toimuvat"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Kontroll on teie ja teie lapse käes"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Pidage meeles"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Kasutage telefoni avamiseks või ostude kinnitamiseks oma sõrmejälge.\n\nMärkus: te ei saa kasutada oma sõrmejälge selle seadme avamiseks. Lisateabe saamiseks võtke ühendust oma organisatsiooni administraatoriga."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Tühista"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Tänan, ei"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Nõustun"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Kas jätta sõrmejälg vahele?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Sõrmejälje seadistamiseks kulub vaid paar minutit. Kui selle vahele jätate, saab sõrmejälje hiljem lisada jaotises Seaded."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Kui näete seda ikooni, kasutage autentimiseks (nt rakendustesse sisselogimisel või ostude kinnitamisel) oma sõrmejälge"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Pidage meeles"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Kuidas see toimib?"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Sõrmejäljega avamise funktsioon loob teie sõrmejäljest kordumatu mudeli, mille abil teie isik kinnitada. Sõrmejäljemudeli loomiseks jäädvustate seadistamise ajal kujutised oma sõrmejäljest eri asendites."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Sõrmejäljega avamise funktsioon loob teie lapse sõrmejäljest kordumatu mudeli, mille abil tema isik kinnitada. Sõrmejäljemudeli loomiseks jäädvustatakse seadistamise ajal kujutised tema sõrmejäljest eri asendites."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Parimate tulemuste jaoks kasutage ekraanikaitset, millel on sertifikaat Made for Google. Teiste ekraanikaitsmetega ei pruugi teie sõrmejälg toimida."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Parimate tulemuste jaoks kasutage ekraanikaitset, millel on sertifikaat Made for Google. Teiste ekraanikaitsetega ei pruugi teie lapse sõrmejälg toimida."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Kellaga avamine"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Kui seadistate näoga ja sõrmejäljega avamise, küsib telefon teie sõrmejälge, kui kannate maski või olete hämaras.\n\nKui teie nägu või sõrmejälge ei tunta ära, saate avada ka kellaga."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Kui teie sõrmejälge ei tunta ära, saate avada kellaga."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Kui teie nägu ei tunta ära, saate avada kellaga."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Sõrmejälje või kella kasutamine:"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Näo või kella kasutamine:"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Näo, sõrmejälje või kella kasutamine:"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Kella kasutamine:"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Näo või kella kasutamine"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Sõrmejälje või kella kasutamine"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Näo, sõrmejälje või kella kasutamine"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Kella kasutamine"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Kõigepealt seadistage näoga või sõrmejäljega avamine"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Kui teie nägu või sõrmejälge ei tunta ära, saate avada kellaga"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Kõigepealt seadistage sõrmejäljega avamine"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Kui teie sõrmejälge ei tunta ära, saate avada kellaga"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Kõigepealt seadistage näoga avamine"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Kui teie nägu ei tunta ära, saate avada kellaga"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Seadistage"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Sõrmejälg ja kell <xliff:g id="WATCH">%s</xliff:g> on lisatud"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Sõrmejäljed ja kell <xliff:g id="WATCH">%s</xliff:g> on lisatud"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Nägu ja kell <xliff:g id="WATCH">%s</xliff:g> on lisatud"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Nägu, sõrmejälg ja kell <xliff:g id="WATCH">%s</xliff:g> on lisatud"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Nägu, sõrmejäljed ja kell <xliff:g id="WATCH">%s</xliff:g> on lisatud"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Kaugautentija avamine"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Kell on lisatud"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Kella seadistamine"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Kellaga avamine on veel üks mugav viis selle telefoni avamiseks, näiteks kui teie sõrmed on märjad või nägu ei tuvastata.\n\nSaate kasutada oma kella telefoni avamiseks järgmistel juhtudel."</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Mitte praegu"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Jätka"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Rohkem"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Tööpõhimõtted"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Teie kell peab olema lukustamata, randmel ja telefoni lähedal. Seni, kuni kell on teie randmel, ei pea te seda uuesti avama."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Kui telefon avatakse, saate märguande oma kellas. Kui see avati kogemata, puudutage telefoni uuesti lukustamiseks märguannet."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Kontroll on teie käes"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Võite oma kella funktsioonist Kellaga avamine igal ajal seadete kaudu eemaldada"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Puudutage märguannet"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Pühkige lukustuskuval üles"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Kella valimine"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Saadaolevad kellad"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Tühista"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Kinnita"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Valmis!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Saate nüüd kasutada oma kella selle telefoni avamiseks, kui pühite lukustuskuval üles või puudutate märguannet"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Valmis"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Kellaga avamine"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Saate kasutada oma kella selle telefoni avamiseks, kui pühite lukustuskuval üles või puudutate märguannet"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Kellaga avamise kasutamiseks peab teie kell olema lukustamata, randmel, käeulatuses ja ühendatud selle telefoniga. Kui ühendus katkeb, peate enne kellaga avamise kasutamist telefoni avama.\n\nPidage meeles.\nKorraga saab seadistada ainult ühe kella. Teise kella lisamiseks eemaldage esmalt praegune kell."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Lisateave kellaga avamise kohta"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Lisa kell"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Kella eemaldamine"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Sõrmejälje ja Näoga avamine"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Näo ja sõrmejäljega avamine töö jaoks"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Seadistamine on vajalik"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Nägu ja sõrmejäljed on lisatud"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Nägu ja sõrmejälg on lisatud"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Kui seadistate näoga ja sõrmejäljega avamise, küsib telefon teie sõrmejälge, kui kannate maski või olete hämaras."</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Võimalused avamiseks"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Kasutage nägu või sõrmejälge järgmiseks"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Telefoni avamine"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Oma isiku kinnitamine rakendustes"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Näo kasutamine"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Sõrmejälje kasutamine"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Näo või sõrmejälje kasutamine"</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">"Face Unlocki seadistamine ei õnnestu"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Näoga avamise seadistamiseks väljuge jagatud ekraanikuvalt"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Sõrmejälge ei saa seadistada"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Sõrmejäljega avamise seadistamiseks väljuge jagatud ekraanikuvalt"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Kas jätta ekraanilukk vahele?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Jäta ikka vahele"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Mine tagasi"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Jäta vahele"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Tühista"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Puudutage andurit"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Puudutage toitenuppu ilma seda vajutamata"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Kuidas sõrmejälg seadistada?"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"See asub telefoni tagaküljel. Kasutage oma nimetissõrme."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Sõrmejäljeandur on ekraani sees. Sõrmejälje jäädvustate järgmisel ekraanikuval."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Alusta"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Anduri leidmiseks liigutage sõrme ekraanil. Puudutage pikalt sõrmejäljeandurit."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Seadme joonis ja sõrmejäljeanduri asukoht"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nimi"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Proovige uuesti"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Kustuta"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Puudutage andurit"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Asetage oma sõrm andurile ja kui tunnete värinat, siis tõstke see üles."</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Hoidke sõrmeotsa anduril, kuni tunnete vibratsiooni."</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Hoidke sõrme nuppu vajutamata sõrmejäljeanduril, kuni tunnete vibreerimist.\n\nLiigutage iga kord pisut sõrme. See aitab jäädvustada suurema osa teie sõrmejäljest."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Puudutage pikalt sõrmejäljeandurit"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Tõstke, seejärel puudutage uuesti"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Veel üks kord"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Järgige sõrmejälje ikooni"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Tõstke sõrme, et lisada sõrmejälje eri osad."</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Puudutage pikalt iga kord, kui sõrmejäljeikoon liigub. See aitab jäädvustada suurema osa teie sõrmejäljest."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Asetage oma sõrmeots andurile"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Asetage sõrme vasak külg andurile"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Asetage sõrme parem külg andurile"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Asetage oma sõrme keskosa andurile"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Asetage oma sõrmeots andurile"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Asetage oma sõrme vasak külg andurile"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Lõpetuseks asetage andurile oma sõrme parem külg"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Asetage oma sõrmejälje külg andurile ja hoidke all, seejärel asetage andurile sõrmejälje teine külg"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"See aitab jäädvustada suurema osa teie sõrmejäljest"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Sõrmejälje registreerimine: <xliff:g id="PERCENTAGE">%d</xliff:g>%%"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Registreerunud on <xliff:g id="PERCENTAGE">%d</xliff:g>%%"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Sõrmejälje registreerimine: <xliff:g id="PERCENTAGE">%d</xliff:g>%%"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Sõrmejälg on lisatud"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Avamiseks ükskõik millal puudutamine"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Saate anduri puudutamisega seadme avada ka siis, kui ekraan on välja lülitatud. Selle seadega on kogemata avamine tõenäolisem."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Ekraan, avamine"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Teen seda hiljem"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Tõstke sõrm üles, seejärel puudutage uuesti"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Asetage oma sõrmejälje külg andurile ja hoidke all, seejärel asetage andurile sõrmejälje teine külg"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Kas jätta sõrmejälje seadistus vahele?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Valisite telefoni avamise üheks viisiks sõrmejälje kasutamise. Kui seadistamise praegu vahele jätate, peate seda tegema hiljem. See võtab ainult umbes minuti."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Kas jätta järgmis(t)e seadistamine vahele: <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Kas jätta PIN-koodi määramine vahele?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Kas soovite PIN-koodi ja näo seadistamise vahele jätta?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Kas soovite PIN-koodi ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Kas soovite PIN-koodi, näo ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Kas jätta parooli määramine vahele?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Kas soovite parooli ja näo seadistuse vahele jätta?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Kas soovite parooli ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Kas soovite parooli, näo ja sõrmejälje seadistamise vahele jätta?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Kas jätta mustri määramine vahele?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Kas soovite mustri ja näo vahele jätta?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Kas soovite mustri ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Kas soovite mustri, näo ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Seadista ekraanilukk"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Valmis"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Vabandust, see pole andur"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Puud. telefoni tagaküljel asuvat andurit. Kasut. oma nimetissõrme."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Sõrmejälje seadistamist ei saa lõpule viia"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Saate kohe uuesti proovida või seadistada oma sõrmejälje hiljem jaotises Seaded."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Saate kohe uuesti proovida või hiljem oma sõrmejälje seadistada."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Sõrmejälje seadistamine aegus"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Saate oma sõrmejäljed seadistada hiljem jaotises Seaded."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Midagi läks valesti. Saate oma sõrmejäljed seadistada hiljem jaotises Seaded."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Saate oma sõrmejälje hiljem seadistada."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Midagi läks valesti. Saate oma sõrmejälje hiljem seadistada."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Lisa veel üks"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Järgmine"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Ekraaniluku valik on keelatud. Lisateabe saamiseks võtke ühendust oma organisatsiooni administraatoriga."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Saate siiski sõrmejäljega oste volitada ja rakendustele juurde pääseda."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Tõstke sõrme, seejärel puudutage sõrmejäljeandurit uuesti"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Sõrmejäljeandurit ei saa kasutada"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Külastage remonditeenuse pakkujat."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Rohkem turvaseadeid"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Tööprofiili lukustus, krüpteerimine ja muu"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Krüpteerimine, mandaadid ja muu"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"turvalisus, rohkem turvaseadeid, rohkem seadeid, täpsemad turvaseaded"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Rohkem privaatsusseadeid"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Rohkem turvalisuse ja privaatsuse kohta"</string>
    <string name="security_header" msgid="961514795852103424">"Turvalisus"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privaatsus"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Tööprofiil"</string>
    <string name="private_space_title" msgid="7078627930195569767">"Privaatne ruum"</string>
    <string name="private_space_summary" msgid="8237652417163408001">"Peida privaatses kaustas olevad rakendused"</string>
    <string name="private_space_one_lock_title" msgid="7306547190751832568">"Avamine ekraaniluku abil"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Peida lukustatuna"</string>
    <string name="privatespace_hide_page_title" msgid="972581369094289386">"Privaatse ruumi peitmine, kui see on lukustatud"</string>
    <string name="privatespace_hide_page_summary" msgid="1052569521186403642">"Privaatse ruumi saate oma rakenduste loendis peita, et teised ei teaks selle olemasolust teie seadmes"</string>
    <string name="privatespace_access_header" msgid="982809349769470185">"Juurdepääs privaatsele ruumile, kui see on peidetud"</string>
    <string name="privatespace_search_description" msgid="983837656432484282">"Sisestage otsinguribale tekst „Privaatne ruum”"</string>
    <string name="privatespace_tap_tile_description" msgid="4146608898639668340">"Puudutage privaatse ruumi paani"</string>
    <string name="privatespace_unlock_description" msgid="4132755357482447360">"Avage oma privaatne ruum"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Väljas"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Sees"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Süsteem"</string>
    <string name="private_space_create_title" msgid="47273568884806726">"Privaatse ruumi loomine"</string>
    <string name="private_space_delete_title" msgid="3075645119800272800">"Privaatse ruumi kustutamine"</string>
    <string name="private_space_created" msgid="2978055968937762232">"Privaatse ruumi loomine õnnestus"</string>
    <string name="private_space_already_exists" msgid="1253034947621867419">"Privaatne ruum on juba olemas"</string>
    <string name="private_space_create_failed" msgid="4908100791174213808">"Privaatset ruumi ei saanud luua"</string>
    <string name="private_space_deleted" msgid="7825768516955610897">"Privaatse ruumi kustutamine õnnestus"</string>
    <string name="private_space_delete_failed" msgid="8500755484258565011">"Privaatset ruumi ei saanud kustutada"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Ekraaniluku seadistamine"</string>
    <string name="no_device_lock_summary" msgid="7653477413589207824">"Seadistage privaatse ruumi jaoks seadmele ekraanilukk."</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Seadistage ekraanilukk"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Tühista"</string>
    <string name="privatespace_cancel_label" msgid="362351004019511784">"Tühista"</string>
    <string name="privatespace_setup_button_label" msgid="3696372546231047258">"Seadistamine"</string>
    <string name="privatespace_setup_title" msgid="177623114624330394">"Privaatse ruumi seadistamine"</string>
    <string name="privatespace_hide_apps_summary" msgid="4016518749055602268">"Privaatsete rakenduste peitmine turvalises ruumis, millele pääsete juurde ainult teie"</string>
    <string name="privatespace_how_title" msgid="8794102046435526065">"Tööpõhimõtted"</string>
    <string name="privatespace_access_bottom_text" msgid="1075244097441349030">"Privaatsele ruumile pääsete juurde oma rakenduste loendi allosas"</string>
    <string name="privatespace_protected_lock_text" msgid="7320604832432017423">"Privaatse ruumi rakendused on lukuga kaitstud"</string>
    <string name="privatespace_hidden_notifications_text" msgid="8121285743543004812">"Kui privaatne ruum on lukustatud, siis on privaatse ruumi rakenduste märguanded peidetud"</string>
    <string name="privatespace_apps_permission_text" msgid="4418511924151828812">"Kui privaatne ruum on lukustatud, ei kuvata privaatse ruumi rakendusi lubade halduris, privaatsuse juhtpaneelil ega muudes seadetes"</string>
    <string name="privatespace_setting_up_text" msgid="8532777749891406509">"Privaatse ruumi seadistamine…"</string>
    <string name="privatespace_lock_protected_title" msgid="7409801274869666860">"Privaatne ruum on lukuga kaitstud"</string>
    <string name="privatespace_apps_hidden_title" msgid="6146605677591599107">"Kui privaatne ruum on lukustatud, siis on privaatse ruumi rakenduste kasutusteave peidetud"</string>
    <string name="privatespace_access_from_apps_title" msgid="6787000636686810564">"Juurdepääs privaatsele ruumile rakenduste loendist"</string>
    <string name="privatespace_error_screen_title" msgid="8658511165913662275">"Privaatset ruumi ei saanud seadistada"</string>
    <string name="privatespace_error_screen_summary" msgid="5679626031159521676">"Proovige kohe uuesti või tulge hiljem tagasi"</string>
    <string name="privatespace_tryagain_label" msgid="4091466165724929876">"Proovi uuesti"</string>
    <string name="privatespace_lockscreen_title" msgid="7459425150560213662">"Kas kasutada lukust avamiseks ekraanilukku?"</string>
    <string name="privatespace_lockscreen_summary" msgid="980268845497843861">"Privaatse ruumi saate lukust avada samal moel seadme lukust avamisega või valida erineva luku"</string>
    <string name="privatespace_use_screenlock_label" msgid="2775404941450049991">"Kasuta ekraanilukku"</string>
    <string name="privatespace_set_lock_label" msgid="6277529807188602545">"Uue luku valimine"</string>
    <string name="privatespace_success_title" msgid="4854425684898602993">"Valmis!"</string>
    <string name="privatespace_access_text" msgid="8756118686974614618">"Juurdepääsuks privaatsele ruumile pühkige avakuva allosast üles ja seejärel kerige alla"</string>
    <string name="privatespace_done_label" msgid="5534818213879562387">"Valmis"</string>
    <string name="scrolldown_to_access" msgid="5160743933093369151">"Juurdepääsuks privaatsele ruumile kerige alla"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Saate lisada kuni <xliff:g id="COUNT">%d</xliff:g> sõrmejälge"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Olete lisanud maksimaalse arvu sõrmejälgi"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Rohkem sõrmejälgi ei saa lisada"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Kustuta „<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>”"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Te ei saa oma sõrmejälge kasutades tööprofiili avada, oste volitada ega töörakendustesse sisse logida."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Krüpteerimine"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Krüpteeritud"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Seadistage ekraanilukk"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Turvalisuse huvides määrake sellele seadmele PIN-kood, muster või parool."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Ekraaniluku seadistamine"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Ekraaniluku seadistamine"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Turvalisuse huvides määrake sellele seadmele PIN-kood, muster või parool."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Tagage oma telefoni turvalisus"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Avamiseks lisage sõrmejälg"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Ekraaniluku valimine"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Ekraaniluku valimine"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Valige uus ekraanilukk"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Valige töörakendustele lukk"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Valige uus tööprofiili lukk"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Lisaturvalisuse huvides seadistage varuekraanilukk."</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Valige oma ekraaniluku varumeetod"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Kui unustate oma ekraaniluku, ei saa IT-administraator seda lähtestada."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Seadistage eraldi töökell"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Kui unustate selle luku, paluge IT-administraatoril see lähtestada"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Ekraaniluku valikud"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Ekraaniluku valikud"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Avamise automaatne kinnitamine"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Avatakse automaatselt, kui sisestate vähemalt 6-kohalise PIN-koodi õigesti. See on veidi vähem turvaline kui kinnitamiseks sisestusklahvi vajutamine."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Õige PIN-koodi automaatne kinnitamine"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"PIN-koodi kinnitamine sisestusklahvi abil on turvalisem kui automaatse kinnitamise kasutamine."</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Automaatse kinnitamise lubamiseks sisestage seadme PIN-kood"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Automaatse kinnitamise keelamiseks sisestage seadme PIN-kood"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Ekraanilukk"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Tööprofiili lukk"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Puudub"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Pühkimine"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Muster"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN-kood"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Parool"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Mitte praegu"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Praegune ekraanilukk"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Muster • Sõrmejälg"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN-kood • Sõrmejälg"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Parool • Sõrmejälg"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Jätkamine ilma sõrmejäljeta"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Muster • Nägu"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN-kood • Nägu"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Parool • Nägu"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Jätka ilma näoga avamiseta"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Ilma näoga avamise või sõrmejäljeta jätkamine"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Puudub"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Pühkimine"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Muster"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN-kood"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Parool"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Kas kustutada ekraanilukk?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Kas eemaldada profiili kaitsefunktsioonid?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Muster kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Muster kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>Samuti kustutab see teie seadmesse salvestatud sõrmejäljemudeli. Te ei saa oma sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Muster kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Muster kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>See kustutab teie seadmesse salvestatud sõrmejäljemudeli. Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu ega sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"PIN-kood kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN-kood kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>Samuti kustutab see teie seadmesse salvestatud sõrmejäljemudeli. Te ei saa oma sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN-kood kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN-kood kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>See kustutab teie seadmesse salvestatud sõrmejäljemudeli. Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu ega sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Parool kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Parool kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>Samuti kustutab see teie seadmesse salvestatud sõrmejäljemudeli. Te ei saa oma sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Parool kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Parool kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

</xliff:g>See kustutab teie seadmesse salvestatud sõrmejäljemudeli. Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu ega sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Seadme kaitsefunktsioonid ei tööta ilma teie ekraanilukuta."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Seadme kaitsefunktsioonid ei tööta ilma teie ekraanilukuta.<xliff:g id="EMPTY_LINE">

</xliff:g>Samuti kustutab see teie seadmesse salvestatud sõrmejäljemudeli. Te ei saa oma sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Seadme kaitsefunktsioonid ei tööta ilma teie ekraanilukuta.<xliff:g id="EMPTY_LINE">

</xliff:g>Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Seadme kaitsefunktsioonid ei tööta ilma teie ekraanilukuta.<xliff:g id="EMPTY_LINE">

</xliff:g>See kustutab teie seadmesse salvestatud sõrmejäljemudeli. Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu ega sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Kustuta"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab keerukat PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut mustrit, PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut ekraanilukku"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Proovige uuesti. Katse <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>/<xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>-st."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Teie andmed kustutatakse"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Kui sisestate järgmisel katsel vale mustri, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Kui sisestate järgmisel katsel vale parooli, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Kui sisestate järgmisel katsel vale mustri, kustutatakse see kasutaja"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse see kasutaja"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Kui sisestate järgmisel katsel vale parooli, kustutatakse see kasutaja"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Kui sisestate järgmisel katsel vale mustri, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Kui sisestate järgmisel katsel vale parooli, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Peab sisaldama vähemalt # tähemärki.}other{Peab sisaldama vähemalt # tähemärki.}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Kui kasutate ainult numbreid, peab parool sisaldama vähemalt ühte numbrit}other{Kui kasutate ainult numbreid, peab parool sisaldama vähemalt # numbrit}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN-kood peab sisaldama vähemalt # numbrit}other{PIN-kood peab sisaldama vähemalt # numbrit}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN-kood peab sisaldama vähemalt # numbrit, kuid parema turvalisuse tagamiseks on soovitatav kasutada {minAutoConfirmLen} numbriga PIN-koodi.}other{PIN-kood peab sisaldama vähemalt # numbrit, kuid parema turvalisuse tagamiseks on soovitatav kasutada {minAutoConfirmLen} numbriga PIN-koodi.}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Peab olema lühem kui # tähemärk}other{Peab olema lühem kui # tähemärki}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Peab olema lühem kui # number}other{Peab olema lühem kui # numbrit}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Seadme administraator ei luba kasutada viimast PIN-koodi"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"See ei tohi sisaldada sobimatut tähemärki"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Peab sisaldama vähemalt 1 tähte}other{Peab sisaldama vähemalt # tähte}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Peab sisaldama vähemalt 1 väiketähte}other{Peab sisaldama vähemalt # väiketähte}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Peab sisaldama vähemalt 1 suurtähte}other{Peab sisaldama vähemalt # suurtähte}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Peab sisaldama vähemalt 1 numbrit}other{Peab sisaldama vähemalt # numbrit}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Peab sisaldama vähemalt 1 erisümbolit}other{Peab sisaldama vähemalt # erisümbolit}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Peab sisaldama vähemalt 1 tähemärki, mis ei ole täht}other{Peab sisaldama vähemalt # tähemärki, mis ei ole täht}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Peab sisaldama vähemalt 1 tähemärki, mis ei ole number}other{Peab sisaldama vähemalt # tähemärki, mis ei ole number}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Seadme administraator ei luba kasutada hiljutist parooli"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Kasvavad, kahanevad või korduvad numbrijadad on keelatud"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Kinnita"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Kustuta"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Ekraanilukk on juba muudetud. Proovige uue ekraanilukuga veel kord."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Tühista"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Järgmine"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Seadme admin. rakendused"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Aktiivseid rakendusi ei ole"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktiivne rakendus}other{# aktiivset rakendust}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Usaldusväärsed agendid"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Kasutamiseks määrake kõigepealt ekraanilukk"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Mitte ükski"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktiivne usaldusväärne agent}other{# aktiivset usaldusväärset agenti}}"</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">"Kas siduda seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Olemasolevasse koordineeritud komplekti uue liikme lisamine"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetoothi sidumiskood"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Sisestage sidumiskood ja vajutage seejärel sisestusklahvi"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN-kood sisaldab tähti või sümboleid"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Tavaliselt 0000 või 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Peab olema 16-kohaline"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Võib-olla peate selle PIN-koodi sisestama ka teise seadmesse."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Võib-olla peate selle parooli sisestama ka teise seadmesse."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Kinnitage koordineeritud komplektiga sidumiseks"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Luba juurdepääs kontaktidele ja kõneajaloole"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Lubage juurdepääs ka kontaktidele ja kõneajaloole"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Teavet kasutatakse kõne teadaannete ja muu jaoks"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ei saanud ühendust."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Saadaval seadmed"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Ühenda"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Katkesta ühendus"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Seo ja ühenda"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Kui Bluetooth on sisse lülitatud, saab seade suhelda teiste lähikonna Bluetooth-seadmetega."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Kui Bluetooth on sisse lülitatud, saab teie seade suhelda teiste läheduses olevate Bluetooth-seadmetega.\n\nSeadme kasutuskogemuse täiustamiseks saavad rakendused ja teenused endiselt igal ajal otsida läheduses olevaid seadmeid isegi siis, kui Bluetooth on välja lülitatud. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Saate seda muuta Bluetoothi skannimise seadetes."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Muutke"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Seadme üksikasjad"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Klaviatuuriseaded"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Seadme Bluetoothi aadress: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Seadme Bluetoothi aadress:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Kas unustada seade?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Eemalda seos"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Kas katkestada rakenduse ühendus?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> ei loo enam teie seadmega <xliff:g id="DEVICE_NAME">%2$s</xliff:g> ühendust"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Katseline. Parandab helikvaliteeti."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Unusta seade"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Katkesta rakenduse ühendus"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maksimaalne arv ühendatud Bluetoothi heliseadmeid"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Maksimaalse arvu ühendatud Bluetoothi heliseadmete valimine"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"NFC virna silumise logi"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"NFC virna logimise taseme suurendamine"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"NFC teenusepakkuja paljusõnaline silumise logi"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Veaaruannetesse kaasatakse täiendavad seadmepõhised teenusepakkuja logid, mis võivad sisaldada privaatset teavet."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"NFC NCI filtreerimata logi"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Jäädvustatakse üksikasjalikud NFC-paketid, mis võivad sisaldada privaatset teavet."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Kas taaskäivitada seade?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Üksikasjalik NFC logimine on mõeldud ainult arenduseks. Veaaruannetesse kaasatakse täiendavad NFC andmed, mis võivad sisaldada privaatset teavet. Selle seade muutmiseks taaskäivitage oma seade."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Taaskäivita"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Ülekandmine"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"peegeldamine"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Luba juhtmeta ekraaniühendus"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Läheduses olevaid seadmeid ei leitud."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Ühendamine"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Ühendatud"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Kasutusel"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Pole saadaval"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Juhtmeta ekraaniühenduse valikud"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Unusta"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Valmis"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nimi"</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">"Logi sisse"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Ava sait"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> on jäänud"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Aegub <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> Mbit/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"Rakendus <xliff:g id="REQUESTER">%s</xliff:g> soovib WiFi sisse lülitada"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"Rakendus <xliff:g id="REQUESTER">%s</xliff:g> soovib WiFi välja lülitada"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Kinnita silutavate rakenduste baidikood"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Luba ART silutavate rakenduste baidikoodi kinnitamiseks"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Kuva värskendussagedus"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Kuva ekraani praegune värskendussagedus"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Nõua NFC puhul seadme avamist"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Valmis edastama rakenduse sisu NFC kaudu"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Väljas"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Pole saadaval, kuna NFC on välja lülitatud"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Kui see funktsioon on sisse lülitatud, saate rakenduse sisu teise NFC-toega seadmesse saata, kui hoiate seadmeid üksteise lähedal. Nii saate edastada näiteks veebilehti, YouTube\'i videoid, kontakte ja muud.\n\nLihtsalt hoidke seadmeid lähestikku (tavaliselt tagakülgi koos) ja seejärel puudutage seadme ekraani. Rakendus määrab, mida edastatakse."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"WiFi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"WiFi kasutus"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"WiFi-seaded"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"WiFi valimine"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"WiFi sisselülitamine ..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"WiFi väljalülitamine ..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Viga"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz riba pole selles riigis saadaval"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Lennurežiimis"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Teavita avalike võrkude puhul"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Teavita, kui kvaliteetne avalik võrk on saadaval"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Lülita WiFi automaatselt sisse"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"WiFi lülitub uuesti sisse kvaliteetsete salvestatud võrkude, näiteks teie koduse võrgu läheduses"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Pole saadaval, sest asukoha otsimine on välja lülitatud. Lülitage valik "<annotation id="link">"Asukoht"</annotation>" sisse."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Sertifikaatide installimine"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Asukoha täpsuse parandamiseks võivad rakendused ja teenused siiski alati otsida WiFi-võrke isegi siis, kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Seda saab muuta <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>WiFi-skannimise seadetes<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Asukoha täpsuse parandamiseks lülitage <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>WiFi-skannimise seadetes<xliff:g id="LINK_END_1">LINK_END</xliff:g> WiFi-skannimine sisse."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Lülita automaatselt mobiilsele andmesidele"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Kui WiFi-l puudub Internetile juurdepääs, kasutatakse mobiilset andmesidet. Rakenduda võivad andmekasutustasud."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Võrgu lisamine"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"WiFi-eelistused"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"WiFi lülitub automaatselt tagasi sisse"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"WiFi ei lülitu automaatselt uuesti sisse"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"WiFi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Võrkude kuvamiseks lülitage WiFi sisse."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Võrkude otsimine …"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Teil pole WiFi-võrgu muutmiseks luba."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Kas lülitada WiFi-skannimine sisse?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"WiFi automaatseks sisselülitamiseks peate esmalt lülitama WiFi-skannimise sisse."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"WiFi-skannimine lubab rakendustel ja teenustel alati otsida WiFi-võrke, isegi kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Lülita sisse"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"WiFi-skannimine on lülitatud sisse"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Täpsemad valikud"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rippmenüü loend Täpsemad valikud"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"laienda"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Võrgu nimi"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Sisestage SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Turvalisus"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Peidetud võrk"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Kui teie ruuter ei edasta võrgu-ID-d, kuid soovite võrguga tulevikus ühenduse luua, võite võrgu peita.\n\nSee võib tekitada turvariski, kuna teie telefon edastab võrgu leidmiseks pidevalt signaali.\n\nVõrgu peitmisel ruuteri seadeid ei muudeta."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Signaali tugevus"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Olek"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Saatmiskanali kiirus"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Vastuvõtukanali kiirus"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Lingi kiirus"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Sagedus"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP-aadress"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Salvestusviis:"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Üksuse <xliff:g id="NAME">%1$s</xliff:g> mandaat"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP meetod"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"2. etapi autentimine"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA-sertifikaat"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimaalne TLS-i versioon"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Sertifikaadi olek onlainis"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domeen"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Kasutaja sertifikaat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identiteet"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonüümne identiteet"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Parool"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Kuva parool"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4 GHz riba"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Eelistatud on 5,0 GHz riba"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP-seaded"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privaatsus"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Tellimus"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Tellimuse vaatamine või muutmine"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Juhuslikustatud MAC-aadress"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Seadme lisamine"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Seadme võrku „<xliff:g id="SSID">%1$s</xliff:g>” lisamiseks paigutage QR-kood allolevas aknas keskele"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"QR-koodi skannimine"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Võrguga „<xliff:g id="SSID">%1$s</xliff:g>” ühenduse oomiseks paigutage QR-kood allolevas aknas keskele"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Liituge WiFi-võrguga, skannides QR-koodi."</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"WiFi jagamine"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Võrguga „<xliff:g id="SSID">%1$s</xliff:g>” liitumiseks skannige see QR-kood teise seadmega"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Võrguga „<xliff:g id="SSID">%1$s</xliff:g>” ühenduse loomiseks skannige see QR-kood"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Proovige uuesti. Kui see probleem jätkub, võtke ühendust seadme tootjaga"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Midagi läks valesti"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Veenduge, et seade oleks ühendatud, laetud ja sisse lülitatud"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Veenduge, et seade oleks ühendatud, laetud ja sisse lülitatud. Kui see probleem jätkub, võtke ühendust seadme tootjaga"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"See seade ei toeta SSID „<xliff:g id="SSID">%1$s</xliff:g>” lisamist"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Liigutage seade WiFi-pääsupunktile/-ruuterile lähemale"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Kontrollige parooli ja proovige uuesti"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Võtke ühendust seadme tootjaga"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Kontrollige ühendust ja proovige uuesti"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Võrgu valimine"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Oma seadme ühendamiseks valige võrk"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Kas lisada see seade võrku „<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"WiFi-t jagatakse seadmega"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Lisa teine seade"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Valige mõni teine võrk"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Seadet ei õnnestunud lisada"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Leiti seade"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"WiFi-võrgu jagamine selle seadmega …"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Ühendamine …"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Kuumkoha jagamine"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Kinnitage oma isik"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"WiFi-võrgu parool: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Kuumkoha parool: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automaatne ühendamine"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Luba levialas selle võrguga ühendamine"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Seadme lisamine"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Kasutage sellesse võrku seadme lisamiseks QR-koodi"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR-kood ei ole sobilik vorming"</string>
    <string name="retry" msgid="7542103800274026915">"Proovi uuesti"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Jaga seadme teiste kasutajatega"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(muutmata)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Valige"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Lisati mitu sertifikaati)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Kasuta süsteemi sertifikaate"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Ära esita"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Usalda esimesel kasutuskorral"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Võrgu nimi on liiga pikk."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Domeeni määramine on kohustuslik."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Sertifikaat on nõutav."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Täpsema asukoha ja muude toimingute jaoks tahab rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> võrkude skannimise sisse lülitada, isegi kui WiFi on välja lülitatud.\n\nKas lubada see kõigi rakenduste jaoks, mis skannida tahavad?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Täpsema asukoha ja muude toimingute jaoks tahab tundmatu rakendus võrkude skannimise sisse lülitada, isegi kui WiFi on välja lülitatud.\n\nKas lubada see kõigi rakenduste jaoks, mis skannida tahavad?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Luba"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Keela"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Sellel võrgul puudub juurdepääs Internetile. Kas soovite ühenduse säilitada?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Mõned rakendused ja teenused ei pruugi piiratud ühenduse tõttu töötada. Kas soovite siiski kasutada?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ära selle võrgu puhul uuesti küsi"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"WiFi pole Internetiga ühendatud"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Kui WiFi-ühendus on halb, võite aktiveerida mobiilsidevõrgu. Andmekasutus võib olla tasuline."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Lülita mobiilsidevõrku"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Kasuta edasi WiFi-t"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Ära näita enam kunagi"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Ühenda"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"WiFi on sisse lülitatud"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Ühendatud võrguga <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Ühendamine võrguga <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Ühendamine …"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Võrguga ühenduse loomine ebaõnnestus"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Te ei ole võrgu levialas"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Unusta"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Muuda"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Salvesta"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Võrgu säilitamine ebaõnnestus"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Tühista"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Kas unustada võrk?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 võrk}other{# võrku}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 tellimus}other{# tellimust}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 võrk ja tellimus}other{# võrku ja tellimust}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Seadme MAC-aadress"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Juhuslikustatud MAC-aadress"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Juhuslikustatud MAC-aadress (viimati kasutatud)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Võrgu üksikasjad"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Alamvõrgu mask"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Tüüp"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6-aadressid"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Kuumkoha seadme üksikasjad"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Interneti allikas"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"WiFi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Mobiilne andmeside"</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> – laadimine"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Kuumkoha ühendus"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Ühenduse tugevus"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Salvestatud võrgud"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Tellimused"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Muud võrgud"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Sisestage kehtiv IP-aadress."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Sisestage kehtiv lüüsi aadress."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Sisestage kehtiv DNS-aadress."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Sisestage võrgu eesliide pikkusega 0 kuni 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (kui privaatne DNS pole seda alistanud)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (kui privaatne DNS pole seda alistanud)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Lüüs"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Võrgu prefiksi pikkus"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"WiFi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Otsi seadmeid"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Otsing …"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Nimeta seade ümber"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Võrdõigusvõrgu seadmed"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Meeldejäetud rühmad"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Ühenduse loomine ebaõnnestus."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Seadme ümbernimetamine ebaõnnestus."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Kas katkestada ühendus?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Kui katkestate ühenduse, siis katkeb ühendus seadmega <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Kui katkestate ühenduse, siis lõpeb ühendus seadmega <xliff:g id="PEER_NAME">%1$s</xliff:g> ja veel <xliff:g id="PEER_COUNT">%2$s</xliff:g> seadmega."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Kas tühistada kutse?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Kas soovite tühistada kutse kasutajaga <xliff:g id="PEER_NAME">%1$s</xliff:g> ühenduse loomiseks?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Kas unustada see rühm?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"WiFi-kuumkoht"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Internetiühendust ega sisu ei jagata teiste seadmetega"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Parool on määramata"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Kuumkoha nimi"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Kuumkoha parool"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Pääsupunkti sagedusriba"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Lülita kuumkoht automaatselt välja"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kui ükski seade pole ühendatud"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Laienda ühilduvust"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Aitab muudel seadmetel selle kuumkoha leida. Vähendab kuumkoha ühenduse kiirust."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Aitab muudel seadmetel selle kuumkoha leida. Akukasutus suureneb."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Kiirus ja ühilduvus"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz / Ühildub enamiku seadmetega"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / Ühildub paljude seadmetega"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / Ühildub väheste seadmetega"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 ja 5 GHz / Ühildub enamiku seadmetega"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Valige kuumkoha jaoks sagedus. Sagedus mõjutab ühenduse kiirust ja seda, mis tüüpi seadmed teie kuumkohta leida saavad."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Eelistatud sagedus"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Väiksemad kiirused. Ühildub enamiku seadmetega."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Suured kiirused. Ühildub paljude seadmetega."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 ja 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Suured kiirused. See kaheribaline kuumkoht ühildub enamiku seadmetega."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Suurimad kiirused. Ühildub väheste seadmetega."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Pole saadaval teie riigis või piirkonnas"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Kui teie eelistatud sagedus pole saadaval, võib kuumkoht kasutada muud sagedust. Sageduse muutmisel võivad muutuda kuumkoha turvaseaded."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Pole saadaval sagedusel 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Kuumkoha sageduse muutmise korral võivad muutuda turvaseaded."</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Vahetu kuumkoht"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Sees"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Väljas"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Kuumkoha sisselülitamine ..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Kuumkoha väljalülitamine ..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Jagamine pole saadaval"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Lisateavet küsige operaatorilt"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> on aktiivne"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Kas soovite võrgu salvestada?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Salvestamine …"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Salvestatud"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Ei saa salvestada. Proovige uuesti."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Kas salvestada võrgud?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Salvestatakse <xliff:g id="NUMBER">%d</xliff:g> võrku …"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Võrgud salvestati"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"WiFi-kõned"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Suurendage WiFi abil helistamisulatust"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Lülitage WiFi-kõned sisse, et ulatust suurendada"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Kõne-eelistus"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Kõne-eelistus"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Rändluse eelistus"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Rändluse eelistus"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"WiFi"</item>
    <item msgid="8622872038388687383">"Mobiilne andmeside"</item>
    <item msgid="3027927219952052398">"Ainult WiFi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"WiFi"</item>
    <item msgid="7566603075659706590">"Mobiilne andmeside"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Kasuta mobiilsidevõrku, kui WiFi ei ole saadaval"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Kasuta WiFi-ühendust, kui mobiilsidevõrk ei ole saadaval"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Helistage WiFi-võrgu kaudu. WiFi-ühenduse katkemisel kõne lõpeb."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Kui WiFi-kõned on sisse lülitatud, saab telefon olenevalt eelistustest ja signaalitugevusest kõnesid marsruutida WiFi-võrkude või teie operaatori võrgu kaudu. Enne selle funktsiooni sisselülitamist uurige operaatorilt tasude ja muude üksikasjade kohta. <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">"Hädaolukorra aadress"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Seda kasutatakse WiFi kaudu hädaabikõne tegemisel teie asukohana"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Lisateave"</annotation>" privaatse DNS-i funktsioonide kohta"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Sees"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktiveerige WiFi-kõned"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Lülitage WiFi-kõned sisse"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Ühendus võrguga <xliff:g id="SSID">%1$s</xliff:g> katkestati"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Heli ja vibreerimine"</string>
    <string name="account_settings" msgid="255404935489127404">"Kontod"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Tööprofiili kontod – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Isikliku profiili kontod"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Profiilikontode kloonimine"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Töökonto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Isiklik konto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Otsing"</string>
    <string name="display_settings" msgid="7197750639709493852">"Ekraan"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Kuva automaatne pööramine"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Väljas"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Sees"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Sees – näopõhine"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Näotuvastus"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Lisateave automaatse pööramise kohta"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Ekraani eraldusvõime"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Kõrge eraldusvõime"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Täiseraldusvõime"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Täiseraldusvõime kasutab rohkem akut. Eraldusvõime vahetamine võib mõne rakenduse taaskäivitada."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Valitud"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Värvid"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Loomulikud"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Võimendatud"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Küllastatud"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Kohanduvad"</string>
    <string name="brightness" msgid="6216871641021779698">"Ereduse tase"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Kohanduv eredus"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Teie ekraanikuva eredust kohandatakse automaatselt teie keskkonna ja tegevuste järgi. Võite liugurit käsitsi liigutada, et aidata kohanduval eredusel teie eelistusi õppida."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Sees"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Väljas"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Ekraani valge tasakaal"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Jätka rakenduste kasutamist voldituna"</string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Suurendab teatud sisu puhul värskendamissagedust automaatselt kuni <xliff:g id="ID_1">%1$d</xliff:g> hertsini. Akukasutus suureneb."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Jõusta kõrgeim värskendamissagedus"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Kõrgeim värskendamissagedus täiustab puutetundlikkust ja pakub sujuvamaid animatsioone. Akukasutus suureneb."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Ekraanivaatamise tuvastus"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Vajalik on kaamera juurdepääs"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Ekraanivaatamise tuvastuse kasutamiseks on vaja juurdepääsu kaamerale. Puudutage, et hallata seadme isikupärastamise teenuste lube"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Lubade haldamine"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Takistab ekraani väljalülitamist, kui seda vaatate"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Ekraanivaatamise tuvastuse funktsioon kontrollib esikaamera abil, kas keegi vaatab ekraani. See töötab ainult seadmes ja pilte ei salvestata kunagi ega saadeta Google\'ile."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Lülita ekraanivaatamise tuvastus sisse"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Ekraan jääb vaatamise ajal sisselülitatuks"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kaamera on lukus"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Näotuvastuse kasutamiseks peab kaamera olema avatud"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Kaamera peab ekraanivaatamise tuvastuse kasutamiseks olema avatud"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Näotuvastuse kasutamiseks on vaja juurdepääsu kaamerale. Puudutage, et hallata seadme isikupärastamise teenuste lube"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Lubade haldamine"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Öövalgus"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Funktsioon Öövalgus toonib ekraani oranžkollaseks. Nii on hämaras ekraani mugavam vaadata ja sellelt teksti lugeda. See võib aidata teil ka hõlpsamini magama jääda."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Ajastamine"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Mitte kunagi"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Lülitub sisse kohandatud ajal"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Lülitub sisse loojangust tõusuni"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Algusaeg"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Lõppaeg"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensiivsus"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Ei lülitu kunagi automaatselt sisse"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Lülitub automaatselt sisse kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Lülitub automaatselt sisse päikeseloojangul"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Ei lülitu kunagi automaatselt välja"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Lülitub automaatselt välja kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Lülitub automaatselt välja päikesetõusul"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Öövalgus pole praegu sees"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Päikeseloojangu ja -tõusu aja määramiseks on vaja teada seadme asukohta."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Asukohaseaded"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Lülita kohe sisse"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Lülita kohe välja"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Lülita sisse päikesetõusuni"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Lülita välja päikeseloojanguni"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Tume režiim"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Ajakava"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Puudub"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Sees loojangust päikesetõusuni"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Lülitub sisse kohandatud ajal"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Lülitub sisse magamamineku ajal"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Olek"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Ei lülitu kunagi automaatselt sisse"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Lülitub automaatselt sisse päikeseloojangul"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Lülitub automaatselt sisse kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Lülitub automaatselt sisse magamamineku ajal"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Ei lülitu kunagi automaatselt välja"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Lülitub automaatselt välja päikesetõusul"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Lülitub automaatselt välja kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Lülitub automaatselt välja pärast magamist"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tume teema kasutab musta tausta, et teie aku kestaks mõne ekraani puhul kauem. Tumeda teema ajakava lülitatakse sisse siis, kui ekraan on väljas."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tume teema järgib praegu teie magamamineku režiimi ajakava"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Magamamineku režiimi seaded"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Ekraani ajalõpp"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Pärast <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> tegevusetust"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Määramata"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Taustapilt"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Taustapilt ja stiil"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Avakuva, lukustuskuva"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Muutke taustapilti"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Isikupärastage ekraani"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Taustapildi valimine:"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Telefoni kohandamine"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Proovige eri stiile, taustapilte ja muud"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Ekraanisäästja"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"ekraanisäästja"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Pole saadaval, kuna uneajarežiim on sees"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Kasuta ekraanisäästjat"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Laadimise ajal või dokis"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Kui on dokitud ja laeb"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Laadimise ajal"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Kui on dokitud"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Mitte kunagi"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Sees / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Välja"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Alustamise aeg"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Tõstke äratamiseks"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Säästlik ekraan"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Millal kuvada?"</string>
    <string name="doze_title" msgid="1523090408230862316">"Ekraani äratamine märguanneteks"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Kui ekraan on välja lülitatud, lülitatakse see uute märguannete puhul sisse"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Alati aja ja teabe kuvamine"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Suurem akukasutus"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Paks tekst"</string>
    <string name="title_font_size" msgid="570613010306330622">"Fondi suurus"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Muutke tekst suuremaks või väiksemaks"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"SIM-luku seaded"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"SIM-lukk"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"SIM-i lukustamine"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Muuda SIM-kaardi PIN-koodi"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"SIM-kaardi PIN-kood"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Lukustage SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Avage SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"SIM-kaardi vana PIN-kood"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"SIM-kaardi uus PIN-kood"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Sisestage uus PIN-kood uuesti"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"SIM-kaardi PIN-kood"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Sisestage 4–8-numbriline PIN-kood"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN-koodid ei kattu"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"SIM-i PIN-koodi muutmine õnnestus"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"PIN-koodi ei saa keelata."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"PIN-koodi ei saa lubada."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Tühista"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Kas kasutada <xliff:g id="CARRIER">%1$s</xliff:g> andmesidet?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Kasutate operaatori <xliff:g id="CARRIER2_0">%2$s</xliff:g> mobiilset andmesidet. Kui aktiveerite operaatori <xliff:g id="CARRIER1">%1$s</xliff:g>, ei kasutata enam operaatori <xliff:g id="CARRIER2_1">%2$s</xliff:g> mobiilset andmesidet."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Kasuta operaatorit <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Kas värsk. eelistatud SIM-i?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> on ainuke seadmes olev SIM-kaart. Kas soovite mobiilse andmeside, kõnede ja SMS-sõnumite puhul kasutada seda SIM-kaarti?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Kas täiustada mobiilside levi?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Lubage telefonil automaatselt lülituda operaatori <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> mobiilsele andmesidele, kui see on paremini kättesaadav."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Kõned, sõnumid ja võrguliiklus võivad teie organisatsioonile nähtavad olla."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Vale SIM-i PIN-kood, seadme avamiseks peate nüüd ühendust võtma oma operaatoriga."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{SIM-i vale PIN-kood. Teil on veel # katse, enne kui peate seadme avamiseks operaatoriga ühendust võtma.}other{SIM-i vale PIN-kood. Teil on veel # katset.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Vale SIM-i PIN-kood, teil on jäänud veel 1 katse, enne kui peate seadme avamiseks operaatoriga ühendust võtma."</string>
    <string name="pin_failed" msgid="3726505565797352255">"SIM-i PIN-koodi toiming ebaõnnestus."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Süsteemivärskendused"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Androidi versioon"</string>
    <string name="security_patch" msgid="4071756145347865382">"Androidi turvavärskendus"</string>
    <string name="model_info" msgid="8997566254717810904">"Mudel"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Riistvara versioon"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Tootmise aasta"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Seadme ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Põhiribaversioon"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Tuuma versioon"</string>
    <string name="build_number" msgid="9009733242117579826">"Järgunumber"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play süsteemivärskendus"</string>
    <string name="battery_info" msgid="7873528123969546728">"Akuteave"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Pole saadaval"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Mäluruum"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Salvestusruum ja vahemälu"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Mäluruumi seaded"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (SIM-kaardi pesa <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (SIM-kaardi pesa <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (SIM-kaardi pesa <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (peamine)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Vaatamiseks valige salvestatud võrk"</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">"PRL-versioon"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (SIM-kaardi pesa <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (SIM-kaardi pesa <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (peamine)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Sees"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Väljas"</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">"Mobiilse andmesidevõrgu tüüp"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Mobiilse häälvõrgu tüüp"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Operaatori teave"</string>
    <string name="status_data_state" msgid="525196229491743487">"Mobiilsidevõrgu olek"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Teenuse olek"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signaali tugevus"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Rändlus"</string>
    <string name="status_operator" msgid="4335640583552058491">"Võrk"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"WiFi MAC-aadress"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Seadme WiFi MAC-aadress"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetoothi aadress"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Seerianumber"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Talitlusaeg"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Tootmiskuupäev"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Esmakordse kasutamise kuupäev"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Tsüklite arv"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Pole saadaval"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Arvutamine ..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Nimeta ümber"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Ühendamine"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Eemalda"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"SD-kaardi teisald. salvestusruumiks vormindamine"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Vorminda kaart"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Vormindamine kaasaskantavana"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Vorminda"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Vii andmed üle"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Unustamine"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Seadistus"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Ruumi vabastamine"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Salvestusruumi haldamine"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Ruumi vabastamine"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Ruumi haldamiseks ja vabastamiseks minge rakendusse Failid"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Teised kasutajad"</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">"Üksus <xliff:g id="NAME">%1$s</xliff:g> ühendati"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Üksust <xliff:g id="NAME">%1$s</xliff:g> ei saanud ühendada"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Üksus <xliff:g id="NAME">%1$s</xliff:g> eemaldati ohutult"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Üksust <xliff:g id="NAME">%1$s</xliff:g> ei saanud ohutult eemaldada"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Salvestusruumi ümbernimetamine"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Üksus <xliff:g id="NAME_0">^1</xliff:g> on rikutud. \n\nÜksuse <xliff:g id="NAME_1">^1</xliff:g> kasutamiseks peate selle esmalt seadistama."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Võite selle SD-kaardi vormindada, et salvestada fotosid, videoid, muusikat ja muud ning nendele teistes seadmetes juurde pääseda. \n\n"<b>"Kõik sellel SD-kaardil olevad andmed kustutatakse."</b>" \n\n"<b>"Enne vormindamist"</b>" \n\n"<b>"Varundage fotod ja muu meedia"</b>" \nTeisaldage oma meediafailid selle seadme muule salvestusruumile või kandke need USB-kaabli abil üle arvutisse. \n\n"<b>"Varundage rakendused"</b>" \n Kõik sellele meediumile (<xliff:g id="NAME">^1</xliff:g>) salvestatud rakendused desinstallitakse ja nende andmed kustutatakse. Rakenduste alleshoidmiseks teisaldage need selle seadme muule salvestusruumile."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Kui üksuse <xliff:g id="NAME_0">^1</xliff:g> eemaldate, lõpetavad sellesse salvestatud rakendused töö ja selles olevad meediafailid pole saadaval, kuni selle uuesti sisestate."</b>\n\n"Üksus <xliff:g id="NAME_1">^1</xliff:g> on vormindatud ainult selles seadmes töötamiseks. See ei tööta teistes seadmetes."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Seadmes <xliff:g id="NAME">^1</xliff:g> olevate rakenduste, fotode või andmete kasutamiseks sisestage see uuesti. \n\nKui seade pole saadaval, võite selle salvestusruumi ka unustada. \n\nKui otsustate selle unustada, kaotate kõik seadmes olevad andmed jäädavalt. \n\nSaate rakendused hiljem uuesti installida, kuid nende sellesse seadmesse salvestatud andmed lähevad kaotsi."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Kas unustada <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Kõik üksusele <xliff:g id="NAME">^1</xliff:g> salvestatud rakendused, fotod ja andmed kaovad jäädavalt."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Jaotis Süsteem hõlmab Androidi versiooni <xliff:g id="VERSION">%s</xliff:g> käitamiseks vajalikke faile"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Külalisrež. kasutajad ei saa SD-kaarte vormindada"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Üksuse <xliff:g id="NAME">^1</xliff:g> vormindamine …"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Ärge eemaldage üksust <xliff:g id="NAME">^1</xliff:g> vormindamise ajal."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> on vormindatud"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Teisalda rakendus <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Rakenduse <xliff:g id="APP">^1</xliff:g> ja selle andmete teisaldamine üksusesse <xliff:g id="NAME_0">^2</xliff:g> võtab vaid mõne hetke. Te ei saa rakendust kasutada enne, kui teisaldamine on lõpetatud. \n\nTeisaldamise ajal ärge eemaldage üksust <xliff:g id="NAME_1">^2</xliff:g>."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Andmete teisaldamiseks peate avama kasutaja <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Rakenduse <xliff:g id="APP">^1</xliff:g> teisaldamine …"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Ärge eemaldage teisaldamise ajal üksust <xliff:g id="NAME">^1</xliff:g>. \n\nRakendus <xliff:g id="APP">^2</xliff:g> pole seadmes saadaval enne, kui teisaldamine on lõpetatud."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Kuidas seadet <xliff:g id="NAME">^1</xliff:g> kasutate?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Või"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"SD-kaardi teisald. salvestusruumiks vormindamine"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Salvestage fotosid, videoid, muusikat ja muud ning pääsege nendele teistes seadmetes juurde. &lt;a href=https://support.google.com/android/answer/12153449&gt;Lisateave SD-kaardi seadistamise kohta&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Vorminda"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Seadista hiljem"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Kas vormindada seade <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"<xliff:g id="NAME_0">^1</xliff:g> tuleb vormindada, et rakendusi, faile ja meediat salvestada. \n\nVormindamisel kustutatakse kogu meediumil <xliff:g id="NAME_1">^2</xliff:g> olev sisu. Sisu kaotsimineku vältimiseks varundage see teise meediumisse (nt <xliff:g id="NAME_2">^3</xliff:g>) või mõnda muusse seadmesse."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"<xliff:g id="NAME_0">^1</xliff:g> tuleb fotode, videote, muusika ja muu salvestamiseks vormindada. \n\nVormindamisega kustutatakse meediumil <xliff:g id="NAME_1">^2</xliff:g> olemasolev sisu. Sisu kaotsimineku vältimiseks varundage see teisele meediumile (näiteks <xliff:g id="NAME_2">^3</xliff:g>) või mõnda muusse seadmesse."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Vorminda seade <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Kas teisaldada sisu seadmesse <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Teisaldamise ajal pidage silmas järgmist."</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Ärge eemaldage seadet <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Mõni rakendus ei pruugi töötada"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Teisalda sisu"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Teisalda sisu hiljem"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Sisu teisaldamine …"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Aeglane seade <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Võite seadet <xliff:g id="NAME_0">^1</xliff:g> siiski kasutada, kuid see võib olla aeglane. \n\nSeadmesse <xliff:g id="NAME_1">^2</xliff:g> salvestatud rakendused ei pruugi õigesti töötada ja sisu teisaldamine võib kaua aega võtta. \n\nKasutage kiiremat seadet <xliff:g id="NAME_2">^3</xliff:g> või selle asemel seda seadet <xliff:g id="NAME_3">^4</xliff:g> kaasaskantava salvestusruumina."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Alusta uuesti"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Jätka"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"<xliff:g id="NAME">^1</xliff:g> on kasutamiseks valmis"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"<xliff:g id="NAME">^1</xliff:g> on kasutamiseks valmis"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"<xliff:g id="NAME">^1</xliff:g> on kasutamiseks valmis"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Aku olek"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Aku tase"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Ühised"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Ühised seaded"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Pääsupunktid (APN-id)"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Pääsupunkti muutmine"</string>
    <!-- no translation found for apn_add (9069613192201630934) -->
    <skip />
    <string name="apn_not_set" msgid="8246646433109750293">"Määramata"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Määramata"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nimi"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Pääsupunkti nimi"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Puhverserver"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Kasutajanimi"</string>
    <string name="apn_password" msgid="7435086635953953029">"Parool"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS-i puhverserver"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS-port"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Autentimise tüüp"</string>
    <string name="apn_type" msgid="1835573305077788773">"APN-i tüüp"</string>
    <string name="apn_protocol" msgid="181529867160380010">"APN-i protokoll"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"APN-i rändlusprotokoll"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Luba/keela APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN on lubatud"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN on keelatud"</string>
    <string name="bearer" msgid="3231443241639159358">"Kandja"</string>
    <string name="network_type" msgid="748590707422733595">"Võrgu tüüp"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Määramata"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO tüüp"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO väärtus"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Kustuta pääsupunktinimi"</string>
    <string name="menu_new" msgid="6571230342655509006">"Uus pääsupunkt"</string>
    <string name="menu_save" msgid="6611465355127483100">"Salvesta"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Tühista"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Nimeväli ei tohi tühi olla."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN ei saa olla tühi."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC-väli peab olema kolmekohaline."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC-väli peab olema kahe- või kolmekohaline."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operaator ei luba tüübiga %s APN-ide lisamist."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"APN-i vaikeseadete taastamine."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Lähtesta vaikeseadetele"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"APN-i vaikeseadete lähtestamine on lõpule viidud."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Lähtestamise valikud"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Mobiilsidevõrgu seadete lähtestamine"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"See lähtestab kõik mobiilsidevõrgu seaded"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Kas lähtestada mobiilsidevõrgu seaded?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Bluetoothi ja WiFi lähtestamine"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"See lähtestab kõik WiFi ja Bluetoothi seaded. Seda toimingut ei saa tagasi võtta."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Lähtesta"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth ja WiFi on lähtestatud"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"eSIM-ide kustutamine"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"See ei tühista mobiilsideteenuse pakette. Asendus-SIM-ide allalaadimiseks võtke ühendust operaatoriga."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Lähtesta seaded"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Kas soovite kõik võrguseaded lähtestada? Seda toimingut ei saa tagasi võtta."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Kas lähtestada kõik võrguseaded ja kustutada eSIM-id? Seda toimingut ei saa tagasi võtta."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Lähtesta seaded"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Kas lähtestada?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Võrguseadete lähtestamine pole selle kasutaja puhul saadaval"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Võrguseaded lähtestati"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"SIM-kaarte ei saa kustutada"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"eSIM-e ei saa vea tõttu kustutada.\n\nTaaskäivitage seade ja proovige uuesti."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Kõigi andmete kustutamine (tehaseseaded)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Kõigi andmete kustutamine (tehaseseaded)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Muusika"</li>\n<li>"Fotod"</li>\n<li>"Muud kasutajaandmed"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM-id"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"See ei tühista teie mobiilsideteenuse paketti."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Kõik teie isiklikud andmed ja allalaaditud rakendused kustutatakse. Seda toimingut ei saa tagasi võtta."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Kõik teie isiklikud andmed, sealhulgas allalaaditud rakendused ja SIM-kaardid kustutatakse. Seda toimingut ei saa tagasi võtta."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Kas kustutada kõik andmed?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Tehaseseadetele lähtestamine pole selle kasutaja puhul saadaval"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Kustutamine"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Oodake …"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Kõneseaded"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Seadista kõnepost, kõne edastamine, ootel kõne, helistaja ID"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Jagamine USB-ga"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Mobiilne kuumkoht"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Jagamine Bluetoothiga"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Jagamine"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Kuumkoht ja jagamine"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Kuumkoht on sees, jagamine"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Kuumkoht on sees"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Jagamine"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Kui andmemahu säästja on sisse lülitatud, siis ei saa jagada ega kasutada teisaldatavat kuumkohta"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Ainult kuumkoht"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Ainult USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Ainult Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Ainult Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Kuumkoht, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Kuumkoht, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Kuumkoht, 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">"Kuumkoht, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Kuumkoht, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Kuumkoht, 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">"Kuumkoht, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internetiühendust ei jagata teiste seadmetega"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Väljas"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Jagamine"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Ära kasuta WiFi-kuumkohta"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Jaga internetti ainult USB kaudu"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Jaga internetti ainult Bluetoothi kaudu"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Jaga internetti ainult Etherneti kaudu"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Jaga internetti ainult USB või Bluetoothi kaudu"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Jaga internetti ainult USB ja Etherneti kaudu"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Jaga internetti ainult Bluetoothi ja Etherneti kaudu"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Jaga internetti ainult USB, Bluetoothi ja Etherneti kaudu"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Jagamine USB-ga"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Jagamine Bluetoothiga"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Jagamine Ethernetiga"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Teistele seadmetele mobiilse andmesidevõrgu kaudu Interneti-ühenduse pakkumiseks kasutage kuumkohta ja ühenduse jagamist. Samuti saavad kuumkoha luua rakendused, et jagada sisu läheduses olevate seadmetega."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Teistele seadmetele WiFi- või mobiilse andmesidevõrgu kaudu internetiühenduse pakkumiseks kasutage kuumkohta ja ühenduse jagamist. Samuti saavad kuumkoha luua rakendused, et jagada sisu läheduses olevate seadmetega."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Abi"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobiilsidevõrk"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobiilipakett"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS-rakendus"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Kas muuta SMS-i rakendust?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Kas kasutada SMS-i rakendusena rakenduse <xliff:g id="NEW_APP">%1$s</xliff:g> asemel rakendust <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Kas kasutada SMS-i rakendusena rakendust <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Kas muuta WiFi Assistanti?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Kas kasutada võrguühenduste haldamiseks rakenduse <xliff:g id="CURRENT_APP">%2$s</xliff:g> asemel rakendust <xliff:g id="NEW_APP">%1$s</xliff:g>?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Kas kasutada võrguühenduste haldamiseks rakendust <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Tundmatu SIM-kaardi operaator"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"Operaatoril <xliff:g id="OPERATOR">%1$s</xliff:g> pole ettevalmistuse veebisaite"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Sisestage SIM-kaart ja taaskäivitage"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Looge Interneti-ühendus"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Hiljutised asukohapäringud"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Tööprofiili asukohaluba"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Asukohale juurdepääsu load"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Asukoht on välja lülitatud"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# rakendusel {total}-st on asukohale juurdepääs}other{# rakendusel {total}-st on asukohale juurdepääs}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Hiljutine juurdepääs"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Kuva kõik"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Kuva üksikasjad"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Ükski rakendus pole hiljuti asukohateavet küsinud"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Ükski rakendus ei ole hiljuti asukohale juurde pääsenud"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Suur akukasutus"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Madala tarbimisega akukasutus"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"WiFi-skannimine"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Lubage rakendustel ja teenustel alati otsida WiFi-võrke, isegi kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetoothi skannimine"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Lubage rakendustel ja teenustel alati otsida läheduses olevaid seadmeid, isegi kui Bluetooth on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Asukohateenused"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Asukohateenused"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Kasuta asukohta"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Ei saa ajavööndit automaatselt määrata"</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">"Asukoht või asukohateenused on välja lülitatud"</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">"Seadme asukoht on vajalik"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Selleks et ajavöönd kasutaks teie asukohta, lülitage sisse asukoht ja värskendage ajavööndi seadeid"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Asukohaseaded"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Paranda see"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Tühista"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automaatne ajavöönd on välja lülitatud"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Asukohapõhine ajavööndi tuvastamine on keelatud"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Asukohapõhine ajavööndi tuvastamine pole toetatud"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Asukohapõhise ajavööndi tuvastamise muudatused pole lubatud"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Ajavööndi määramiseks võidakse kasutada asukohta"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Vaadake juriidilist teavet, olekut, tarkvara versiooni"</string>
    <string name="legal_information" msgid="7509900979811934843">"Juriidiline teave"</string>
    <string name="manual" msgid="3651593989906084868">"Käsitsi"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulatiivsildid"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Ohutus- ja regulatiivjuhend"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autoriõigus"</string>
    <string name="license_title" msgid="8745742085916617540">"Litsents"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Google Play süsteemivärskenduste litsentsid"</string>
    <string name="terms_title" msgid="2071742973672326073">"Nõuded ja tingimused"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Süsteemi WebView\' litsents"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Taustapildi autor"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Satelliitpiltide pakkujad:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Käsitsi"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Juhendi laadimisel ilmnes probleem."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Kolmanda osapoole litsentsid"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Litsentside laadimisega on probleem."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Laadimine ..."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Laadimine ..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Määrake parool"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Määrake tööprofiili parool"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Määrake PIN-kood"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Määrake tööprofiili PIN-kood"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Määrake muster"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Turvalisuse huvides seadistage seadme avamiseks muster."</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Määrake tööprofiili muster"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Sõrmejälje kasutamiseks määrake parool"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Sõrmejälje kasutamiseks määrake muster"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Turvalisuse huvides määrake PIN-kood"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Sõrmejälje kasutamiseks määrake PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Sisestage oma parool uuesti"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Sisestage tööprofiili parool uuesti"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Sisestage tööprofiili parool"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Sisestage tööprofiili muster"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Sisestage oma PIN-kood uuesti"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Sisestage tööprofiili PIN-kood uuesti"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Sisestage tööprofiili PIN-kood"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Paroolid ei ühti"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN-koodid ei ühti"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Joonistage oma muster uuesti"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Lukust avamise meetod"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Parool on määratud"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN-kood on määratud"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Muster on määratud"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Looge näoga avamise kasutamiseks parool"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Looge näoga avamise kasutamiseks muster"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Looge näoga avamise kasutamiseks PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Näo või sõrmejälje kasutamiseks seadistage parool"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Näo või sõrmejälje kasutamiseks seadistage muster"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Näo või sõrmejälje kasutamiseks seadistage PIN-kood"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Kas unustasite parooli?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Kas unustasite mustri?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Kas unustasite PIN-koodi?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Jätkamiseks joonistage oma muster"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Jätkamiseks sisestage oma PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Jätkamiseks sisestage oma parool"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Jätkamiseks joonistage oma tööprofiili muster"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Jätkamiseks sisestage oma tööprofiili PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Jätkamiseks sisestage oma tööprofiili parool"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Lisaturvalisuse jaoks kasutage seadme mustrit"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Lisaturvalisuse jaoks sisestage oma seadme PIN-kood"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Lisaturvalisuse jaoks sisestage oma seadme parool"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Lisaturvalisuse jaoks kasutage oma tööprofiili mustrit"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Lisaturvalisuse jaoks sisestage oma tööprofiili PIN-kood"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Lisaturvalisuse jaoks sisestage oma tööprofiili parool"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"PIN-koodi kinnitamine"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Parooli kinnitamine"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Isiku kinnitamine"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Google\'i kontode, seadete ja muu ülekandmiseks sisestage oma teise seadme muster. Teie muster on krüpteeritud."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Google\'i kontode, seadete ja muu ülekandmiseks sisestage oma teise seadme PIN-kood. Teie PIN-kood on krüpteeritud."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Google\'i kontode, seadete ja muu ülekandmiseks sisestage oma teise seadme parool. Teie parool on krüpteeritud."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Kasuta mustrit ka selle seadme avamiseks"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Kasuta PIN-koodi ka selle seadme avamiseks"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Kasuta parooli ka selle seadme avamiseks"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"PIN-koodi kinnitamine"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Parooli kinnitamine"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Jätkamiseks kasutage seadme mustrit"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Jätkamiseks sisestage seadme PIN-kood"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Jätkamiseks sisestage seadme parool"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Vale PIN-kood"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Vale parool"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Vale muster"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Hädaabi"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Seadme turvalisus"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Muuda avamismustrit"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Muuda avamise PIN-koodi"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Joonistage avamismuster"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Abi saamiseks vajutage valikut Menüü."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Kui olete valmis, siis tõstke sõrm"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Ühendage vähemalt <xliff:g id="NUMBER">%d</xliff:g> punkti. Proovige uuesti."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Muster on salvestatud"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Joonistage muster kinnitamiseks uuesti"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Teie uus avamismuster"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Kinnita"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Koosta uuesti"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Kustuta"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Jätka"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Avamismuster"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Mustri nõudmine"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Ekraani avamiseks tuleb koostada muster"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Tee muster nähtavaks"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"PIN-koodi täiustatud privaatsus"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Keela animatsioonid PIN-koodi sisestamise ajal"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Muuda profiilimuster nähtavaks"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibreeri puudutamisel"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Lukustamine toitenupuga"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> hoiab seadet avatuna"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Määra avamismuster"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Muuda avamismustrit"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kuidas joonistada avamismustrit"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Liiga palju valesid katseid. Proovige uuesti <xliff:g id="NUMBER">%d</xliff:g> sekundi pärast."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Rakendus pole teie telefoni installitud."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Tööprofiili turvalisus"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Tööprofiili ekraanilukk"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Kasuta ühte lukku"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Kasuta tööprofiili ja seadme ekraani puhul ühte lukku"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Kas kasutada ühte lukku?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Seade kasutab teie tööprofiili ekraanilukku. Mõlema luku puhul kehtivad tööreeglid."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Teie tööprofiili lukk ei vasta teie organisatsiooni turvanõuetele. Seadme ekraani ja tööprofiili puhul saate kasutada sama lukku, kuid selle puhul kehtivad tööprofiili luku eeskirjad."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Kasuta ühte lukku"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Kasuta ühte lukku"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Sama mis seadme ekraanilukk"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Halda rakendusi"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Rakenduse teave"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Rakenduse seaded"</string>
    <string name="install_applications" msgid="3921609656584369901">"Tundmatud allikad"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Luba kõik rakenduse allikad"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Hiljuti avatud rakendused"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Kuva kõik rakendused}other{Kuva kõik # rakendust}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Võtke ühendust IT-administraatoriga"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Need aitavad teil lähtestada PIN-koodi, mustri või parooli"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Täpsemad seaded"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Luba rohkem seadete valikuid"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Rakenduse teave"</string>
    <string name="storage_label" msgid="2522307545547515733">"Mäluruum"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Avamine vaikimisi"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Vaikeseaded"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Ekraani ühilduvus"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Load"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Vahemälu"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Tühjenda vahemälu"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Vahemälu"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 üksus}other{# üksust}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Tühista juurdepääs"</string>
    <string name="controls_label" msgid="8671492254263626383">"Juhtnupud"</string>
    <string name="force_stop" msgid="2681771622136916280">"Sunni peatuma"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Kokku"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Rakenduse suurus"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Rakendus USB-mäluseadmel"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Kasutajaandmed"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Desinstalli"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Kõikidelt kasutajatelt desinstallimine"</string>
    <string name="install_text" msgid="4558333621516996473">"Installi"</string>
    <string name="disable_text" msgid="5146002260857428005">"Keela"</string>
    <string name="enable_text" msgid="8570798764647110430">"Luba"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Tühjenda salvestusruum"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Desinstalli värskendused"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Piiratud seadete lubamine"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Mõni teie valitud tegevus avaneb selles rakenduses vaikimisi."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Olete lubanud sellel rakendusel vidinaid luua ja nende andmetele juurde pääseda."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Vaike-eelistusi pole määratud."</string>
    <string name="clear_activities" msgid="488089228657585700">"Tühista vaike-eelistused"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"See rakendus ei pruugi teie ekraanile sobida. Sobivust saate kontrollida siin."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Küsi käivitamisel"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Skaleeri rakendus"</string>
    <string name="unknown" msgid="8192160131923461175">"Tundmatu"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Sordi nime alusel"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Sordi suuruse järgi"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Kõige hiljutisemad"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Kõige sagedasemad"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Kuva töötavad teenused"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Kuva vahemällu salvestatud protsessid"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Hädaabirakendus"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Rakenduste eelistuste lähtestamine"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Lähtestada rakenduste eelistused?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"See lähtestab kõik järgmised eelistused.\n\n"<li>"Keelatud rakendused"</li>\n<li>"Keelatud rakenduste märguanded"</li>\n<li>"Toimingute vaikerakendused"</li>\n<li>"Rakenduste taustaandmete piirangud"</li>\n<li>"Igasugused lubade piirangud"</li>\n<li>"Akukasutuse seaded"</li>\n\n"Rakenduste andmed säilivad."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Lähtesta rakendused"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Filtrivalikute valimine"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Kõik rakendused"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Keelatud rakendused"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Allalaaditud"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Töös"</string>
    <string name="not_installed" msgid="5074606858798519449">"Pole selle kasutaja jaoks installitud"</string>
    <string name="installed" msgid="2837449358488825884">"Installitud"</string>
    <string name="no_applications" msgid="985069304755391640">"Rakendusi pole."</string>
    <string name="internal_storage" msgid="999496851424448809">"Sisemälu"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Suuruse ümberarvutamine ..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Kas kustutada rakenduse andmed?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Selle rakenduse andmed, sh failid ja seaded, kustutatakse sellest seadmest jäädavalt."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Tühista"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Kustuta"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Rakendust ei leitud installitud rakenduste loendist."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Rakenduse salvestusruumi ei õnnestunud tühjendada."</string>
    <string name="computing_size" msgid="4915310659841174866">"Arvutamine ..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Paketi suurust ei saanud arvutada."</string>
    <string name="version_text" msgid="7628938665256107608">"versioon <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Teisalda"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Teine üleviimine on juba pooleli."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Ei ole piisavalt ruumi."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Rakendust ei ole olemas."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Installimise asukoht ei ole kehtiv."</string>
    <string name="system_package" msgid="7559476279008519360">"Süsteemivärskendusi ei saa installida välisele kandjale."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Seadme administraatori rakendust ei saa installida välisele andmekandjale"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Kas peatada sunniviisiliselt?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Kui sunnite rakenduse peatuma, võib see toimida valesti."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Keela rakendus"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Selle rakenduse keelamisel ei pruugi Android ja muud rakendused enam ootuspäraselt töötada. Pange tähele, et seda rakendust ei saa kustutada, kuna see on seadmesse eelinstallitud. Rakenduse keelamisel lülitatakse see välja ja peidetakse seadmes."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Pood"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Rakenduse üksikasjad"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Rakendus installiti poest <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Lisateavet leiate teenusest <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Töötab"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Pole kasutatud)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Kasutatud mälu"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Taaskäivitamine"</string>
    <string name="cached" msgid="5379485147573438201">"Vahemällu salvestatud taustaprotsess"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Midagi ei esitata"</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Käivitas rakendus"</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> vaba"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> kasutusel"</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">"Kasutaja: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Eemaldatud kasutaja"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsess ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenus"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsess ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenust"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsessi ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenus"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsessi ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenust"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Seadme mälu"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Rakenduse RAM-i kasutus"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Süsteem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Rakendused"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Vaba"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Kasutati"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Vahemälus"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-i"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Käitatav rakendus"</string>
    <string name="no_services" msgid="3898812785511572899">"Pole aktiivne"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Teenused"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Protsessid"</string>
    <string name="service_stop" msgid="5712522600201308795">"Peata"</string>
    <string name="service_manage" msgid="3896322986828332075">"Seaded"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Selle teenuse käivitas tema rakendus. Selle peatamine võib põhjustada rakenduse sulgemise."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Seda rakendust ei saa ohutult peatada. Peatamisel võite kaotada osa oma praegusest tööst."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"See on vana rakenduse protsess, mida igaks juhuks ikka veel käitatakse. Selle peatamiseks pole tavaliselt põhjust."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: praegu kasutusel. Puudutage selle juhtimiseks valikut Seaded."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Peamine protsess on kasutusel."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Teenus <xliff:g id="COMP_NAME">%1$s</xliff:g> on kasutusel."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Teenusepakkuja <xliff:g id="COMP_NAME">%1$s</xliff:g> on kasutusel."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Kas peatada süsteemi teenus?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Keeled, sisestus ja liigutused"</string>
    <string name="language_settings" msgid="8700174277543875046">"Keeled ja sisend"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Keeled"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Klaviatuur"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Teil pole luba seadme keele muutmiseks."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Keeled ja sisend"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Tööriistad"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Klaviatuur ja sisestusmeetodid"</string>
    <string name="system_language" msgid="1146762166579643257">"Süsteemi keeled"</string>
    <string name="phone_language" msgid="5986939176239963826">"Keeled"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automaatne asendamine"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Paranda valesti sisestatud sõnad"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Autom. suurtähtede kasut."</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Lausete alguses suurtähtede kasutamine"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automaatsed kirjavahemärgid"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Füüsilise klaviatuuri seaded"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Vajutage kaks korda tühikuklahvi, et sisestada „.”"</string>
    <string name="show_password" msgid="7101900779571040117">"Kuva paroolid"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Sisestamisel kuvatakse hetkeks tähemärgid"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"See õigekirjakontrollija võib koguda kogu sisestatava teksti, sh isiklikud andmed (nt paroolid ja krediitkaardinumbrid). See pärineb rakendusest <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Kas soovite seda õigekirjakontrolli kasutada?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Seaded"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Keel"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Klaviatuurid"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Ekraanil kuvatav klaviatuur"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Saadaolev ekraanil kuvatav klaviatuur"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Ekraanil kuvatavate klaviatuuride haldamine"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Valikud"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Füüsiline klaviatuur"</string>
    <string name="show_ime" msgid="4334255501724746849">"Kasuta ekraaniklaviatuuri"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Hoia seda ekraanil, kui füüsiline klaviatuur on aktiivne"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klaviatuuri otseteed"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Kuva otseteede loend"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tööprofiili klaviatuurid ja tööriistad"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Ekraanil kuvatav klaviatuur tööks"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Vaikeseade"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Puuteplaat"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Puuteplaat ja hiir"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Kursori kiirus, liigutused"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Klõpsamiseks puudutamine"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Puuteplaadi liigutused"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Kohandage individuaalseid puuteplaadi navigeerimisliigutusi"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Tagurpidi kerimine"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Allakerimisel liigub sisu üles"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Parema alaosa puudutamine"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Lisavalikute nägemiseks puudutage puuteplaadi paremat alaosa"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Kursori kiirus"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Õppige puuteplaadi liigutusi"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Avalehele liikumine"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Pühkige puuteplaadil kolme sõrmega üles"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Tagasiliikumine"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Pühkige kolme sõrmega vasakult või paremalt"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Hiljutiste rakenduste kuvamine"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Pühkige kolme sõrmega üles, hoidke ja vabastage siis"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Märguannete ja kiirseadete kuvamine"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Pühkige avakuval kolme sõrmega alla"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Rakenduste vahetamine"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Pühkige nelja sõrmega vasakule või paremale"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Jäta vahele"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Järgmine"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Taaskäivita"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Valmis"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Mine tagasi"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Pühkige kolme sõrmega vasakule või paremale"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Avakuvale"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Pühkige kolme sõrmega üles"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Hiljutised rakendused"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Pühkige kolme sõrmega üles ja hoidke"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Märguanded"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Pühkige kolme sõrmega alla"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Rakenduste vahetamine"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Pühkige nelja sõrmega vasakule või paremale"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Muuteklahvid"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Klahvide käitumise muutmine"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Lähtesta kõik"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Vaikeseade"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Kas soovite kindlasti kõik muuteklahvid vaikeseadetele lähtestada?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Valmis"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Tühista"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Lähtesta"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Muuteklahvi valimine"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Valige muuteklahvi <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g> jaoks uus klahv:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Vaikeseade"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Kõne"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Kursori kiirus"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Mängukontroller"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Vibreerimise ümbersuunamine"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Saadab vibreerimise mängukontrollerisse, kui see on ühendatud"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Klaviatuuri paigutuse valimine"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Seadista klaviatuuri paigutus"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Vahetamiseks vajutage Ctrl+tühikut"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Vaikepaigutus"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Klaviatuuri paigutused"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Füüsilise klaviatuuri paigutused"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Isiklik sõnaraamat"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Isiklik kataloog töö jaoks"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Lisage sõnu, mida kasutada sellistes rakendustes nagu Õigekirjakontroll"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Lisa"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Sõnastikku lisamine"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fraas"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Rohkem valikuid"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Vähem valikuid"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Sõna:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Otsetee:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Keel:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Sisestage sõna"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Valikuline otsetee"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Muuda sõna"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Muuda"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Kustuta"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Kasutaja sõnaraamatus ei ole ühtki sõna. Sõna lisamiseks puudutage nuppu Lisa (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Kõikides keeltes"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Rohkem keeli ..."</string>
    <string name="testing" msgid="6294172343766732037">"Testimine"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Ekraanil kuvatav klaviatuur, tööriistad"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Ekraanil kuvatav klaviatuur, füüsiline klaviatuur, tööriistad"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Füüsiline klaviatuur"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Paigutus"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Valige vidin"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Valige vidin"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Kas luua vidin ja lubada juurdepääs?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Pärast vidina loomist pääseb rakendus juurde kõigele, mis on kuvatud.\n\nRakendus: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nVidin: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Luba rakendusel <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> alati vidinaid luua ja nende andmetele juurdepääs hankida"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Kasutusstatistika"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Sordi kasutusaja järgi"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Sordi viimatise kasutuse järgi"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Sordi rakenduse nime järgi"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Viimane kasutamine"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Kasutusaeg"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Juurdepääsetavus"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Juurdepääsetavuse seaded"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Ekraan, interaktsioon, heli"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Nägemisseaded"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Seadet saab kohandada vastavalt oma vajadustele. Neid juurdepääsetavuse funktsioone saab hiljem muuta menüüs Seaded."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Muutke fondi suurust"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekraanilugeja"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Subtiitrid"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Heli"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Üldine"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Ekraan"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Värvid ja liigutused"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekraanikuva muutmine tumedamaks"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktsiooni juhtnupud"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Ajastuse juhtelemendid"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Süsteemi juhtelemendid"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Allalaaditud rakendused"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Katseline"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Funktsiooni märgistamised"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Bluetooth HCI jälgimise logi filtreerimine"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Filtrite määramine"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Muudatuste jõustumiseks keelake ja lubage Bluetooth"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Bluetooth HCI jälgimise logi filtreerimise PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Bluetooth HCI jälgimise logi filtreerimise MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Filtreerimisrežiimi määramine. (Muudatuste jõustumiseks keelake ja lubage Bluetooth)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Selle valiku muutmiseks määrake Bluetoothi HCI jälgimise logi režiim valikule Luba filtreeritud"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Peamiselt pimedatele ja halva nägemisega inimestele mõeldud ekraanilugeja"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Ekraanil olevate üksuste ettelugemise kuulmiseks puudutage neid."</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Subtiitrite eelistused"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Subtiitrite eelistuste teave"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Lisateave subtiitrite eelistuste kohta"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Suurendus"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Suurenduse otsetee"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Luubiga sisestus"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Luup liigub teksti sisestamisel tekstiga kaasa"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Jäta rakenduste vahetamise ajal sisselülitatuks"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Luup jääb sisselülitatuks ja suumib välja, kui vahetate rakendusi"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Juhtkang"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Aktiveerige ja liigutage luupi ekraanikuval oleva juhtkangiga. Puudutage pikalt, seejärel lohistage juhtkangi, et luupi juhtida. Puudutage ja lohistage, et juhtkangi ennast liigutada."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Suurenduse teave"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Lisateave suurenduse kohta"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Suurendamise viis"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Suurendage täisekraani, konkreetset ala või vahetage mõlema võimaluse vahel"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Täisekraan"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Ekraani osa"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Täisekraani ja ekraani osa vahel vahetamine"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Valige suurendamise viis"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Täisekraani suurendamine"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Ekraanikuva osa suurendamine"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Täisekraani ja ekraani osa vahel vahetamine"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Mõlema valiku vahel vahetamiseks puudutage lülitusnuppu"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Kas lülitada juurdepääsetavuse nupule?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Kolmikpuudutuse kasutamine ekraanikuva teatud osa suurendamiseks põhjustab teksti sisestamisel ja muudel juhtudel viiteid.\n\nJuurdepääsetavuse nupp hõljub ekraanikuval teiste rakenduste kohal. Suurendamiseks puudutage seda."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Lülita juurdepääsetavuse nupule"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Kasuta kolmikpuudutust"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"See võib teie klaviatuuri tööd aeglustada"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Kui kasutate ekraanikuva teatud osa suurendamiseks kolmikpuudutust, võite märgata klaviatuuri peal probleeme.\n\nSelle vältimiseks võite muuta suurenduse otseteed, kasutades kolmikpuudutuse asemel mõnda muud valikut.\n"<annotation id="link">"Muutke seadet"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Jätka ikkagi"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Tühista"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Suurendamisseaded"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Otsetee abil suurendamine"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Otsetee ja kolmikpuudutusega suurendamine"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Teave funktsiooni <xliff:g id="SERVICE">%1$s</xliff:g> kohta"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Kuvamissuurus ja tekst"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Muutke teksti kuvamise viisi"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Teema: kuumaõhupalli kujundused"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Saatja: Toomas"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Tere hommikust!\n\nSoovisin lihtsalt uurida, kuidas joonised edenevad. Kas need saavad selleks ajaks valmis, kui me hakkame uusi õhupalle ehitama?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Lähtesta seaded"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Kuvamissuuruse ja teksti seaded on lähtestatud"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Kas lähtestada kuvamissuurus ja tekst?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Lähtesta"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Mida nädalavahetusel teed?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Lähen randa. Kas tahad kaasa tulla?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Valikud"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Suumige ekraanil sisse"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Suumimiseks puudutage kolm korda"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Suumimiseks puudutage nuppu"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Suumige ekraanil kiiresti sisse, et sisu suuremalt kuvada"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Sissesuumimiseks toimige järgmiselt.&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Kasutage suurendamise alustamiseks otseteed.&lt;br/&gt; {1,number,integer}. Puudutage ekraani.&lt;br/&gt; {2,number,integer}. Ekraanikuval liikumiseks lohistage kahe sõrmega.&lt;br/&gt; {3,number,integer}. Suumi kohandamiseks liigutage ekraanil kaht sõrme kokku-lahku.&lt;br/&gt; {4,number,integer}. Kasutage suurendamise lõpetamiseks otseteed.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Ajutiseks sissesuumimiseks toimige järgmiselt.&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Veenduge, et suurendamise tüübiks oleks valitud täisekraan.&lt;br/&gt; {1,number,integer}. Kasutage suurendamise alustamiseks otseteed.&lt;br/&gt; {2,number,integer}. Hoidke sõrme kus tahes ekraanikuval.&lt;br/&gt; {3,number,integer}. Lohistage ekraanikuval liikumiseks sõrme.&lt;br/&gt; {4,number,integer}. Suurendamise lõpetamiseks tõstke sõrm ekraanikuvalt."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Kui suurendusfunktsioon on sisse lülitatud, saate oma ekraanikuval sisse suumida.\n\n"<b>"Suumimiseks"</b>" käivitage suurendusfunktsioon ja puudutage siis ekraanikuval mis tahes kohta.\n"<ul><li>"Kerimiseks lohistage kahe või enama sõrmega."</li>\n<li>"Suumi kohandamiseks pigistage kahte või enamat sõrme kokku."</li></ul>\n\n<b>"Ajutiseks suumimiseks"</b>" käivitage suurendusfunktsioon ja puudutage siis ekraanikuval pikalt mis tahes kohta.\n"<ul><li>"Ekraanikuval teisaldamiseks lohistage sõrme."</li>\n<li>"Väljasuumimiseks tõstke sõrm ekraanilt."</li></ul>\n\n"Klaviatuuril ega navigeerimisribal ei saa sisse suumida."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"<xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. leht <xliff:g id="NUM_PAGES">%2$d</xliff:g>-st"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Avamiseks juurdepääsetavuse nupu kasutamine"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Avamiseks hoidke helitugevuse klahve all"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Avamiseks puudutage ekraani kolm korda"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_triple" msgid="1090593773487065541">"Avamiseks ekraani kahe sõrmega kolmekordne puudutamine"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Kasutage avamiseks liigutust"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Juurdepääsuliigutuse kasutamine"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Selle funktsiooni kasutamiseks puudutage ekraanikuva allosas juurdepääsetavuse nuppu <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nFunktsioonide vahel vahetamiseks puudutage juurdepääsetavuse nuppu pikalt."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Selle funktsiooni kasutamiseks puudutage ekraanikuval juurdepääsetavuse nuppu."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Selle funktsiooni kasutamiseks vajutage pikalt mõlemat helitugevuse klahvi."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Suurenduse käivitamiseks ja peatamiseks puudutage ekraani kolm korda."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="6205072282308562361">"Suurenduse käivitamiseks ja peatamiseks puudutage ekraani kahe sõrmega kolm korda."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Selle funktsiooni kasutamiseks pühkige ekraanikuva allosast kahe sõrmega üles.\n\nFunktsioonide vahel vahetamiseks pühkige kahe sõrmega üles ja hoidke sõrmi ekraanil."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Selle funktsiooni kasutamiseks pühkige ekraanikuva allosast kolme sõrmega üles.\n\nFunktsioonide vahel vahetamiseks pühkige kolme sõrmega üles ja hoidke sõrmi ekraanil."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Juurdepääsufunktsiooni kasutamiseks pühkige ekraanikuva allosast kahe sõrmega üles.\n\nFunktsioonide vahel vahetamiseks pühkige kahe sõrmega üles ja hoidke sõrmi ekraanil."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Juurdepääsufunktsiooni kasutamiseks pühkige ekraanikuva allosast kolme sõrmega üles.\n\nFunktsioonide vahel vahetamiseks pühkige kolme sõrmega üles ja hoidke sõrmi ekraanil."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Selge"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Nupu seaded"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Funktsiooni <xliff:g id="SERVICE">%1$s</xliff:g> otsetee"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Juurdepääsetavuse nupp"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Juurdepääsuliigutus"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Pühkige kahe sõrmega üles"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Pühkige kolme sõrmega üles"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Juurdepääsetavuse nupu puudutamine"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Juurdepääsuliigutuse kasutamine"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Puudutage ekraanikuva allosas olevat juurdepääsetavuse nuppu <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nFunktsioonide vahel vahetamiseks vajutage juurdepääsetavuse nuppu pikalt."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Pühkige kahe sõrmega ekraanikuva allosast üles.\n\nFunktsioonide vahel vahetamiseks pühkige kahe sõrmega üles ja hoidke."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Pühkige kolme sõrmega ekraanikuva allosast üles.\n\nFunktsioonide vahel vahetamiseks pühkige kolme sõrmega üles ja hoidke."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Rohkem valikuid"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Lisateave: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Helitugevuse klahvide allhoidmine"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"helitugevuse klahvide allhoidmine"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Hoidke all mõlemat helitugevuse klahvi"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_triple_tap" msgid="6687765191490040899">"Ekraani kahe sõrmega kolmekordne puudutamine"</string>
    <string name="accessibility_shortcut_two_finger_triple_tap_keyword" msgid="4200744613585702430">"ekraani kahe sõrmega kolmekordne puudutamine"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_triple_tap" msgid="2631127444247448793">"Puudutage kahe sõrmega hetkeks ekraani {0,number,integer} korda"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Ekraani kolmikpuudutamine"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"ekraani kolmikpuudutamine"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Puudutage ekraani kiiresti {0,number,integer} korda. See otsetee võib teie seadme tööd aeglustada."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Täpsemad"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Juurdepääsetavuse nupu jaoks on valitud seade <xliff:g id="SERVICE">%1$s</xliff:g>. Suurenduse kasutamiseks puudutage ja hoidke juurdepääsetavuse nuppu ning seejärel valige suurendus."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"See juurdepääsetavuse liigutus on määratud teenusele <xliff:g id="SERVICE">%1$s</xliff:g>. Suurenduse kasutamiseks pühkige kahe sõrmega ekraanikuva allosast üles ja hoidke sõrmi ekraanil. Seejärel tehke valik Suurendus."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Helitugevuse nupu otsetee"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Otsetee seaded"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Otsetee lukustuskuval"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Lukustuskuval sisselülitamiseks lubage funktsiooni otsetee. Hoidke mõlemat helitugevuse klahvi mõni sekund all."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Juurdepääsetavuse nupp"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Juurdepääsetavuse nupp ja liigutus"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Pääsege juurdepääsufunktsioonidele kiiresti ligi igalt kuvalt"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Juurdepääsetavuse nupu teave"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Juurdepääsetavuse nupu ja liigutuse teave"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Lisateave juurdepääsetavuse nupu ja liigutuse kohta"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Juurdepääsetavuse nupu kasutamine. Liigutus ei ole kolme nupuga navigeerimise puhul saadaval."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Kiirjuurdepääs juurdepääsufunktsioonidele"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Alustamiseks toimige järgmiselt.&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Avage juurdepääsetavuse seaded.&lt;br/&gt; {1,number,integer}. Valige funktsioon ja puudutage otseteed.&lt;br/&gt; {2,number,integer}. Valige, kas soovite funktsioonile juurdepääsemiseks kasutada nuppu või liigutust.&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Alustamiseks toimige järgmiselt.&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Avage juurdepääsetavuse seaded.&lt;br/&gt; {1,number,integer}. Valige funktsioon ja puudutage otseteed.&lt;br/&gt; {2,number,integer}. Valige nupp, millega funktsioonile juurde pääseda.&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Nupu või liigutuse kasutamine"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Asukoht"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Suurus"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Hajuta, kui seda ei kasutata"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Hajub mõne sekundi pärast, et kuva oleks hõlpsam näha"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Läbipaistvus, kui nuppu ei kasutata"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Läbipaistev"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Läbipaistmatu"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Suure kontrastsusega tekst"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Muutke tekst mustaks või valgeks. Maksimeerib kontrasti taustaga."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ekraanisuurenduse värskendus"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ekraanisuurenduse kasutus rakenduste vahetamisel"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Toitenupp lõpetab kõne"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Suur hiirekursor"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Muutke hiirekursor paremini nähtavaks"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Animatsioonide eemaldamine"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Ekraanikuval liikumise vähendamine"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Monoheli"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Kanalite ühendamine heli esitamisel"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Heli tasakaal"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Vasak"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Parem"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Vaikeseade"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekundit"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekundit"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minut"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minutit"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Aeg toimingu tegemiseks (juurdepääsu ajalõpp)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Aeg toimingu tegemiseks (juurdepääsu ajalõpp)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Lisateave toimingu tegemiseks antud aja (juurdepääsu ajalõpu) kohta"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Aeg toimingu tegemiseks"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Seda ajastamiseelistust kõikides rakendustes ei toetata"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Valige, kui kaua kuvatakse ajutisi sõnumeid, milles teil palutakse midagi teha"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Puute ja hoidmise viide"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Värvide ümberpööramine"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Kasuta värvide ümberpööramist"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Värvide ümberpööramise otsetee"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Värvide ümberpööramine muudab heledad ekraanikuvad tumedaks. Samuti muudab see tumedad ekraanikuvad heledaks."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Pidage meeles&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Meedia ja piltide värvid muutuvad&lt;/li&gt; &lt;li&gt; Värvide ümberpööramine töötab kõigis rakendustes&lt;/li&gt; &lt;li&gt; Tumeda tausta kuvamiseks võib selle asemel kasutada tumedat teemat&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"sisenege seadetesse"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automaatklikk (peatumisaeg)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Automaatne klikk (peatumisaeg)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Lisateave automaatse kliki (peatumisaja) kohta"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Võite ühendatud hiire seadistada nii, et see klõpsaks automaatselt, kui kursor pole teatud aja jooksul liikunud"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Automaatklikist võib abi olla, kui hiire klõpsamine on raskendatud"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automaatklikk on väljas"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Lühike"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekundit"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Keskmine"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundit"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Pikk"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekund"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Kohandatud"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Lühem"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Pikem"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Automaatse kliki aeg"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibreerimine ja värintagasiside"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Vibratsiooni tugevuse juhtimine eri kasutusviiside puhul"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Sees"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Väljas"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Seade on keelatud, kuna seade on vaigistatud"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Kõned"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Märguanded ja alarmid"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktiivne värintagasiside"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Vibreerimise ja värintagasiside kasutamine"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Äratuse vibreerimine"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Meedia vibreerimine"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Klaviatuuri vibreerimine"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Helin koos vibreerimisega"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Märguanne koos vibreerimisega"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Puudutuste tagasiside"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Kasuta funktsiooni <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Ava <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> lisati kiirseadetesse. Selle sisse- või väljalülitamiseks tõmmake millal tahes sõrmega alla."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Saate rakenduse <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> kiirseadetesse lisada ka oma ekraanikuva ülaosast"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Värvide korrigeerimine lisati kiirseadetesse. Selle sisse- või väljalülitamiseks tõmmake millal tahes sõrmega alla."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Saate värvide korrigeerimise kiirseadetesse lisada ka oma ekraanikuva ülaosast"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Värvide ümberpööramine lisati kiirseadetesse. Selle sisse- või väljalülitamiseks tõmmake millal tahes sõrmega alla."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Saate värvide ümberpööramise kiirseadetesse lisada ka oma ekraanikuva ülaosast"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Eriti tume režiim lisati kiirseadetesse. Selle sisse- või väljalülitamiseks tõmmake millal tahes sõrmega alla."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Saate eriti tumeda režiimi kiirseadetesse lisada ka oma ekraanikuva ülaosast"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Ühekäerežiim lisati kiirseadetesse. Selle sisse- või väljalülitamiseks tõmmake millal tahes sõrmega alla."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Saate ühekäerežiimi kiirseadetesse lisada ka oma ekraanikuva ülaosast"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Fondi suurus on lisatud Kiirseadetesse. Fondi suuruse muutmiseks pühkige mis tahes ajal alla."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Loobu"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Kasuta värvide korrigeerimist"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Värvide korrigeerimise otsetee"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Värviparanduse teave"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Lisateave värvide korrigeerimise kohta"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Värvide ümberpööramise teave"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Lisateave värvide ümberpööramise kohta"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Kuva subtiitrid"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Ainult toetatud rakendustes"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Subtiitrite suurus ja stiil"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"<xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g> teksti suurus"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Rohkem valikuid"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Kohandage subtiitrite suurust ja stiili, et neid oleks lihtsam lugeda"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Kõik meediarakendused ei toeta neid subtiitrite eelistusi"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Juurdepääsetavuse nupp"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Kahe sõrmega alt üles pühkimine"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Helitugevuse klahvide allhoidmine"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Kolmikpuudutuse ekraanikuva"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Jätka"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Kuuldeseadmed"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Saate kasutada oma telefoniga kuuldeaparaate, kõrvaimplantaate ja muid võimendusseadmeid"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ühtegi kuuldeseadet pole ühendatud"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Lisa kuuldeaparaate"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Kuuldeaparaatide sidumine"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Puudutage järgmisel kuval oma kuuldeaparaate. Võib juhtuda, et peate vasaku ja parema kõrva eraldi siduma.\n\nVeenduge, et kuuldeaparaadid oleksid sisse lülitatud ja sidumiseks valmis."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> on aktiivne"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, ainult vasak"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, ainult parem"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, vasak ja parem"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ja veel üks"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Uue seadme sidumine"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Teave uue seadme sidumise kohta"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Kuuldeseadmed"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Salvestatud seadmed"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Kuuldeseadme juhtimisvidinad"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Kuuldeseadme otsetee"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Ühilduvus kuuldeaparaatidega"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Parandab ühilduvust induktiivsidestitega (telecoils) ja vähendab soovimatut müra"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Teave kuuldeseade kohta"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Veenduge, et teie kuuldeseade oleks sisse lülitatud ja sidumiseks valmis"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Kuuldeseadme sidumine"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Saadaval kuuldeseadmed"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Kas te ei näe oma kuuldeseadet?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Kuva rohkem seadmeid"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Heli kohandamine"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Häälkirjeldus"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Kuulete toetatud filmides ja sarjades kirjeldust ekraanil toimuvast"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"häälkirjeldus, heli, kirjeldus, vaegnägijatele,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Otsetee on sees"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Väljas"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Sees"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Väljas"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Ei tööta. Puudutage teabe nägemiseks."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Selle teenuse töös esineb häireid."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Juurdepääsetavuse otseteed"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Kuva kiirseadetes"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Punane-roheline"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Punane-roheline"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Sinine-kollane"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Halltoonid"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Rohelise vähenenud tajumine, deuteranomaalia"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Punase vähenenud tajumine, protanomaalia"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomaalia"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Eriti tume"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Ekraanikuva eriti tumedaks muutmine"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Eriti tumeda režiimi otsetee"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Eriti tumeda režiimi teave"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Muutke ekraanikuva tumedamaks, et seda oleks mugavam lugeda"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensiivsus"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Tuhmim"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Heledam"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Hoia pärast seadme taaskäivitumist sisselülitatuna"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Lühike ({time} sekund)}other{Lühike ({time} sekundit)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Keskmine ({time} sekund)}other{Keskmine ({time} sekundit)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Pikk ({time} sekund)}other{Pikk ({time} sekundit)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekund}other{{time} sekundit}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Seaded"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Sees"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Väljas"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Eelvaade"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardvalikud"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Keel"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Teksti suurus"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Subtiitri stiil"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Kohandatud valikud"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Tausta värv"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Tausta läbipaistvus"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Tiitrite akna värv"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Tiitrite akna läbipaistvus"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Teksti värv"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Teksti läbipaistvus"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Serva värv"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Serva tüüp"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Fondi perekond"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Subtiitrid näevad välja sellised"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Vaikeseade"</string>
    <string name="color_title" msgid="2511586788643787427">"Värv"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Vaikevärv"</string>
    <string name="color_none" msgid="3703632796520710651">"Puudub"</string>
    <string name="color_white" msgid="1896703263492828323">"Valge"</string>
    <string name="color_gray" msgid="8554077329905747877">"Hall"</string>
    <string name="color_black" msgid="9006830401670410387">"Must"</string>
    <string name="color_red" msgid="5210756997426500693">"Punane"</string>
    <string name="color_green" msgid="4400462091250882271">"Roheline"</string>
    <string name="color_blue" msgid="4997784644979140261">"Sinine"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Tsüaan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Kollane"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Fuksia"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Kas anda teenusele <xliff:g id="SERVICE">%1$s</xliff:g> teie seadme üle täielik kontroll?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> teeb järgmist:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Seaded ei saa teie vastust kinnitada, sest rakendus varjab loataotlust."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> taotleb seadme täielikku haldusõigust. Teenus saab juurdepääsufunktsioone vajavate kasutajate nimel ekraani lugeda ja tegutseda. See haldusõiguse tase ei ole enamiku rakenduste puhul sobilik."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Täielik kontroll sobib rakendustele, mis pakuvad juurdepääsufunktsioone. Enamiku rakenduste puhul seda ei soovitata."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Ekraanikuva vaatamine ja haldamine"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"See saab lugeda kogu ekraanil kuvatud sisu ja kuvada sisu rakenduste peal."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Toimingute vaatamine ja tegemine"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"See saab jälgida teie suhtlust rakenduse või riistvaraanduriga ja teie eest rakendustega suhelda."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Luba"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Keela"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Peata"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Tühista"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Kas peatan teenuse <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Nupu <xliff:g id="STOP">%1$s</xliff:g> puudutamisel teenus <xliff:g id="SERVICE">%2$s</xliff:g> peatatakse."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Ühtki teenust pole installitud"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Ükski teenus ei ole valitud"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Kirjeldust ei ole sisestatud."</string>
    <string name="settings_button" msgid="2195468788019730377">"Seaded"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"valgustundlikkus, fotofoobia, tume teema, migreen, peavalu, lugemisrežiim, öörežiim, ereduse vähendamine, valge punkt"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"nägemine, kuulmine, pime, kurt, kurtus, motoorika, peenmotoorika, abi, abistav, kasutusmugavus, lihtne juurdepääs, käsi"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Akna suurendaja, suum, suurendamine, halb nähtavus, suurendus, suuremaks muutmine"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Subtiitrid, reaalajas transkriptsioon, kuulmislangus, kuulmiskadu, CART, kõnesüntees"</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">"ekraani suurus, suur ekraan"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Kõrge kontrastsus, halb nähtavus, paks font, paks esiletõst"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"värvide korrigeerimine"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"ekraanikuva tumendamine, ekraanikuva helendamine"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"värvikontrastsus"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"motoorika, hiir, väline hiir, peahiir, adaptiivne hiir, ratastool, juhtkang"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"kuuldeaparaadid, kuulmislangus, kuulmiskadu, kõrvaimplantaadid, võimendusseadmed, heliprotsessorid, isiklik helivõimendi, PSAP"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"kuulmislangus, kuulmiskadu, subtiitrid, teletaip, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"kolm nuppu"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"peenmotoorika, motoorika, eakas, artriit, liigesepõletik, ülekoormusvigastused, ülekoormushaigus, treemor, insult, rabandus, multiipelskleroos, hulgiskleroos, hulgikoldekõvastumus, ajuhalvatus, tserebraalparalüüs, värisemine, värin, värinad, käsi"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"viide, peenmotoorika, eakas"</string>
    <string name="print_settings" msgid="8519810615863882491">"Printimine"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Väljas"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 printimisteenus on sees}other{# printimisteenust on sees}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 prinditöö}other{# prinditööd}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Printimisteenused"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Ühtki teenust pole installitud"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Printereid ei leitud"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Seaded"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Printerite lisamine"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Sees"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Väljas"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Lisa teenus"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Lisa printer"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Otsing"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Printerite otsimine"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Teenus on keelatud"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Prinditööd"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Prinditöö"</string>
    <string name="print_restart" msgid="4424096106141083945">"Taaskäivita"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Tühista"</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">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> seadistamine"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> printimine"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> tühistamine"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Printeri viga: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printer blokeeris töö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Otsingukast on kuvatud"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Otsingukast on peidetud"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Lisateave selle printeri kohta"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Aku"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Mis on akut kasutanud"</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">"Jäänud on <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> laadimise lõpuni"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Ekraaniaeg"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Taustal veedetud aeg"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Akutase on madal"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Lubatakse rakenduse taustal käitamine"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Kas piirata taustal tegevust?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Kui piirate rakenduse tegevust taustal, võib rakendus toimida valesti."</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Kuna rak. pole aku optimeerimine seadistatud, ei saa te seda piirata.\n\nRak. piiramiseks lülit. esmalt sisse aku optimeerimine."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Akukasutuse haldamine"</string>
    <!-- no translation found for manager_battery_usage_allow_background_usage_title (6294649996820358852) -->
    <skip />
    <!-- no translation found for manager_battery_usage_allow_background_usage_summary (8021153755201340819) -->
    <skip />
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Piiranguteta"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimeeritud"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Piiratud"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Akukasutus taustal lubatakse ilma piiranguteta. See võib kasutada rohkem akut."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimeerimine kasutuse järgi. Soovitatav enamiku rakenduste puhul."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Taustal töötades piiratakse akukasutust. Rakendus ei pruugi töötada ootuspäraselt. Märguanded võivad viibida."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Rakenduse akukasutuse muutmine võib mõjutada rakenduse toimivust."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"See rakendus nõuab akukasutust järgmises ulatuses: <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"piiranguteta"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimeeritud"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Lisateave akukasutuse valikute kohta"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Ekraani kasutus alates täislaadimisest"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Akukasutus"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Ajaloo üksikasjad"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Akukasutus"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Kasutus viimase 24 tunni jooksul"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Kasutamine pärast viimast täislaadimist"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Rakenduse akukasutus"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Kasuta detaile"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Reguleerige energiakasutust"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Kaasnevad paketid"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Rakendused töötavad tavapäraselt"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Akutase on madal"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Lülitage aku tööea pikendamiseks sisse akusäästja"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Pikendage aku tööiga"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Lülitage sisse akuhaldur"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Lülitage akusäästja sisse"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Aku võib tavapärasest kiiremini tühjaks saada"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Akusäästja on sees"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Lisateave akusäästja kohta"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Mõned funktsioonid võivad olla piiratud"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Suur akukasutus"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Vaadake suurima akukasutusega rakendusi"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Laadimine on aku kaitsmiseks optimeeritud"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Laadimine on optimeeritud, et pikendada teie aku tööiga"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Laadimine on aku kaitsmiseks optimeeritud"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Aku tööea pikendamiseks on laadimine dokitud olekus optimeeritud"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Laadimine on aku kaitsmiseks optimeeritud"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Aku tööea pikendamiseks on laadimine dokitud olekus optimeeritud"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Laaditakse täissaamiseni"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Järgmisel korral, kui teie tahvelarvuti on dokitud, on laadimine aku kaitsmiseks optimeeritud"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Lisateave peatatud laadimise kohta"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Jätka laadimist"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Hõlmab akut koormavaid taustategevusi"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Piira # rakendus}other{Piira # rakendust}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} on hiljuti piiratud}other{# rakendust on hiljuti piiratud}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} kasutab taustal palju akut}other{# rakendust kasutavad taustal palju akut}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Seda rakendust ei saa taustal käitada}other{Neid rakendusi ei saa taustal käitada}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Kas soovite rakendust piirata?}other{Kas soovite # rakendust piirata?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Aku säästmiseks peatage rakenduse <xliff:g id="APP">%1$s</xliff:g> jaoks taustal aku kasutamine. See rakendus ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Aku säästmiseks peatage nende rakenduste jaoks taustal aku kasutamine. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida.\n\nRakendused:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Aku säästmiseks peatage nende rakenduste jaoks taustal aku kasutamine. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida.\n\nRakendused:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Piira"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Kas eemaldada piirang?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"See rakendus saab taustal akut kasutada. Aku võib oodatust varem tühjaks saada."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Eemalda"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Tühista"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Laadi täissaamiseni"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Probleem laadimistarvikuga"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Lisateave ühildumatu laadimise kohta"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Akuhaldur"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Halda rakendusi automaatselt"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Kui akuhaldur tuvastab, et rakendused kurnavad akut, on teil võimalik nende rakenduste tööd piirata. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Piiratud rakendused"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Piiratakse # rakenduse akukasutust}other{Piiratakse # rakenduse akukasutust}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Piiratud <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Need rakendused ei saa taustal akut kasutada. Need ei pruugi töötada oodatud viisil ja märguanded võivad viibida."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Akuhalduri kasutamine"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Tuvasta, kui rakendused kurnavad akut"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Tuvastatakse, kui rakendused kurnavad akut"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Tuvastatakse, kui rakendused kurnavad akut"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# rakendus on piiratud}other{# rakendust on piiratud}}"</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">"Probleem akumõõdiku lugemisel."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Puudutage, et näha selle vea kohta lisateavet"</string>
    <string name="power_screen" msgid="4596900105850963806">"Ekraan"</string>
    <string name="power_cpu" msgid="1820472721627148746">"Protsessor"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Taskulamp"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kaamera"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"WiFi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobiilsidevõrk"</string>
    <string name="power_phone" msgid="2768396619208561670">"Tavakõned"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Ekraanikasutus: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="APP">%2$s</xliff:g> kasutab <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> kogu akumahust"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Üksikasjalik teave alates viimasest täislaadimisest"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Viimane täislaadimine"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Täislaaditud seade kestab umbes"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Aku järelejäänud tööaeg on ligikaudne ja võib sõltuvalt kasutusest muutuda."</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Akukasutus"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Pole pärast viimast täislaadimist kasutatud"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Pole viimase 24 tunni jooksul kasutatud"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"alates viimasest täislaadimisest"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Süsteemirakendused"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Desinstallitud rakendused"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Muu"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Hinnanguline järelejäänud aeg"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Täislaadimiseni"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Prognoos võib olenevalt kasutusest muutuda"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Meediumiserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Rakenduse optimeerimine"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Jagamine"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Eemaldatud rakendused"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Akusäästja"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Lülita automaatselt sisse"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Ajakava puudub"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Põhineb teie rutiinil"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Lülitub sisse teie rutiini põhjal"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Põhineb protsendil"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Akusäästja lülitub sisse, kui teie aku saab enne tavapärast laadimisaega tõenäoliselt tühjaks"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Lülitub sisse <xliff:g id="PERCENT">%1$s</xliff:g> juures"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Ajakava määramine"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Aku tööea pikendamine"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Lülita välja, kui aku on täis laetud"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Lülita välja <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> juures"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Akusäästja lülitub välja, kui aku laetuse tase on <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">"Lülita sisse"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Kasuta akusäästjat"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Automaatne sisselülitamine"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Mitte kunagi"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"aku taseme <xliff:g id="PERCENT">%1$s</xliff:g> juures"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Aku laetuse protsent"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Olekuribal kuvatakse aku laetuse protsent"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Akutase pärast viimast täislaadimist"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Akutase viimase 24 h jooksul"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Rakenduse kasutus pärast viimast täislaadimist"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Rakenduste kasutus viimase 24 h jooksul"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Süsteemi kasutus pärast viimast täislaadimist"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Süsteemi kasutus viimase 24 h jooksul"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Süsteemi kasutus: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Rakenduse kasutus: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Süsteemi kasutus pärast viimast täislaadimist <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Rakenduse kasutus pärast viimast täislaadimist <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Kokku: vähem kui minut"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Taustal: vähem kui minut"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Ekraaniaeg: vähem kui minut"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Vähem kui minut"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Kokku: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Taustal: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Ekraaniaeg: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Akukasutuse andmed on saadaval mõne tunni pärast, kui aku on täielikult laetud."</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"praegu"</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_chart" msgid="4114747521432440017">"Akukasutuse diagramm"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Aku päevapõhise kasutuse diagramm"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Aku tunnipõhise kasutuse diagramm"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Akukasutus pärast viimast täislaadimist"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Akukasutus: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Ekraaniaeg pärast viimast täislaadimist"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Ekraaniaeg: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Kuva rakenduste kaupa"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Kuva süsteemide kaupa"</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">"Enne tarnet tehtud kvaliteedikontrolli tõttu ei pruugi tsüklite arv esmakordsel kasutamisel olla null."</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Protsessi statistika"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Tehnilised üksikasjad protsesside käitamise kohta"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Mälu kasutamine"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Viimase <xliff:g id="TIMEDURATION">%3$s</xliff:g> jooksul on kasutatud <xliff:g id="USEDRAM">%1$s</xliff:g> <xliff:g id="TOTALRAM">%2$s</xliff:g>-st"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="TIMEDURATION">%2$s</xliff:g> jooksul kasutati <xliff:g id="PERCENT">%1$s</xliff:g> RAM-i"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Taust"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Esiplaan"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Vahemälus"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Omaprotsessid"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Tuum"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Vahemälud"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM-i kasutus"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM-i kasutus (taustal)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Tööaeg"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Protsessid"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Teenused"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Kestus"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Mälu üksikasjad"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 tundi"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 tundi"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 tundi"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 päev"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Kuva süsteem"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Peida süsteem"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Kuva protsendid"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"USS-i kasutamine"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistika tüüp"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Taust"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Esiplaan"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Vahemälus"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Kõnesisend ja -väljund"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Kõnesisendi ja -väljundi seaded"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Häälotsing"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Androidi klaviatuur"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Häälsisendi seaded"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Häälsisend"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Häälsisendi teenused"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Täielik otsetee sõna ja interaktsioon"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Lihtne kõnesüntees"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"See häälsisendi teenus suudab pakkuda alati sisse lülitatud hääle jälgimisteenust ja juhtida teie nimel rakendusi, kus on lubatud häälefunktsioon. See pärineb rakendusest <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Kas lubada teenuse kasutamine?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Seadmepõhise tuvastuse seaded"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Seadmepõhine tuvastus"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Seadmepõhine kõnetuvastus"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Eelistatud kõnesünteesi mootor"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Kõnesünteesi mootori seaded"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Kõne kiirus ja helikõrgus"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Kõnesünteesi mootor"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Hääled"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Hääle keel"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Häälte installimine"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Häälte installimiseks avage rakendus <xliff:g id="TTS_APP_NAME">%s</xliff:g>"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Ava rakendus"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Tühista"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Lähtesta"</string>
    <string name="tts_play" msgid="2945513377250757221">"Esita"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Pole turvaline"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> pole turvaline"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> pole turvaline"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Kohanduv ühenduvus"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Pikendab aku tööiga ja täiustab seadme toimivust, hallates automaatselt teie võrguühendusi"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Sees"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Väljas"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Kasuta adaptiivset ühenduvust"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Mandaatide salvestusruum"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Sertifikaadi installimine"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Mandaatide kustutamine"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Kõikide sertifikaatide eemaldamine"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Usaldusväärsed mandaadid"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Usaldusväärsete CA-sertifikaatide kuvamine"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Kasutaja mandaadid"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Salvestatud mandaatide vaatamine ja muutmine"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Täpsemad"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Mandaadid pole selle kasutaja jaoks saadaval"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Installitud VPN-i ja rakenduste jaoks"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Installitud WiFi jaoks"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Installitud WiFi jaoks (kasutuses)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Kas eemaldada kogu sisu?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Mandaatide mälu kustutatakse."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Mand. mälu ei saanud kustut."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Kasutusjuurdepääsuga rakend."</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA-sertifikaat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN ja rak. kasutaja sertifikaat"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"WiFi-sertifikaat"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Teie andmed ei ole privaatsed"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA-sertifikaate kasutavad krüpteerimiseks veebisaidid, rakendused ja VPN-id. Installige CA-sertifikaate ainult usaldusväärsetelt ettevõtetelt. \n\nKui installite CA-sertifikaadi, pääseb sertifikaadi omanik teie külastatud veebisaitidel või kasutatud rakendustes teie andmetele (nt paroolidele, sõnumitele või krediitkaardi üksikasjadele) juurde isegi siis, kui teie andmed on krüpteeritud."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Ära installi"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Installi ikkagi"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Sertifikaat on installimata"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Kas lubada rakendusel "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" sellesse seadmesse sertifikaate installida?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Need sertifikaadid aitavad teid tuvastada, jagades teie seadme kordumatut ID-d allolevate rakenduste ja URL-idega"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Ära luba"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Luba"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Kuva rohkem"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Sertifikaadihalduse rakendus"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Pole"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Sertifikaadid aitavad teid tuvastada, kui kasutate allolevaid rakendusi ja URL-e"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Desinstalli sertifikaadid"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Eemalda rakendus"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Kas eemaldada see rakendus?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"See rakendus ei halda sertifikaate, kuid see jääb teie seadmesse. Kõik rakenduse installitud sertifikaadid desinstallitakse."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}other{# URL-i}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Hädaabikõne signaal"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Määra käitumine hädaabikõne korral"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Varundamine"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Sees"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Väljas"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Varundamine ja taastamine"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Isikuandmed"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Minu andmete varundamine"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Varundage rakenduse andmed, WiFi-paroolid ja muud seaded Google\'i serverites"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Varunduskonto"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Varundamiskonto haldamine"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Kaasa rakenduse andmed"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automaatne taastamine"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Rakenduse uuesti installimisel taasta varundatud seaded ja andmed"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Varundusteenus ei ole aktiivne"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Ühelegi kontole ei ole praegu salvestatud varundatud andmeid"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Kas soovite WiFi-paroolide, järjehoidjate, muude seadete ja rakenduse andmete varundamise lõpetada ja kõik Google\'i serverites olevad koopiad kustutada?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Kas soovite peatada seadme andmete (nt WiFi-paroolid ja kõneajalugu) ning rakenduse andmete (nt seaded ja rakenduste salvestatud failid) varundamise ning kustutada kõik kaugserverites olevad koopiad?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Varundage seadme andmed (nt WiFi-paroolid ja kõneajalugu) ning rakenduse andmed (nt seaded ja rakenduste salvestatud failid) kaugjuhtimisega automaatselt.\n\nKui lülitate automaatse varundamise sisse, salvestatakse seadme ja rakenduse andmed regulaarselt kaugjuhtimisega. Rakenduse andmed võivad olla mis tahes andmed, mille rakendus on salvestanud (arendaja seadete põhjal), sh potentsiaalselt tundlikud andmed, nagu kontaktid, sõnumid ja fotod."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Seadme administraatori seaded"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Seadme administraatori rakendus"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Inaktiveeri seadme administraatori rakendus"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Desinstalli rakendus"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Inaktiveeri ja desinstalli"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Seadme admin. rakendused"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Saadaval ei ole ühtki seadme administraatori rakendust"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Saadaval pole ühtegi usaldusväärset agenti"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Kas aktiveerida admin. rakendus?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktiveeri seadme administraatori rakendus"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Seadme administraator"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Selle administraatori rakenduse aktiveerimisel lubatakse rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid."</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Seda seadet haldab ja jälgib rakendus <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"See administraatori rakendus on aktiivne ja lubab rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid."</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Kas aktiveerida profiilihaldur?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Kas lubada järelevalve?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Kui jätkate, haldab teie kasutajat edaspidi administraator, kes saab võib-olla talletada peale teie isiklike andmete ka seotud andmeid.\n\nTeie administraator saab jälgida ja hallata selle kasutajaga seotud seadeid, juurdepääsu, rakendusi ja andmeid, sealhulgas veebitegevusi ja seadme asukohateavet."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Administraator on muud valikud keelanud."</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Lisateave"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Märguannete logi"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Märguannete ajalugu"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Viimased %d tundi"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Edasi lükatud"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Hiljuti loobutud"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# märguanne}other{# märguannet}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Kõne helin ja vibreerimine"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Võrgu üksikasjad"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sünkroonimine lubatud"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sünkroonimine keelatud"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Kohe sünkroonimine"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Sünkroonimise viga"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sünkroonimine ebaõnnestus"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sünkroonimine on aktiivne"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sünkroonimine"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Sünkroonimisega on praegu probleeme. See on varsti tagasi."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Lisa konto"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Tööprofiil ei ole veel saadaval"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Töörakendused"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Eemalda tööprofiil"</string>
    <string name="background_data" msgid="321903213000101158">"Andmeside kasutus taustal"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Rakendused saavad andmeid sünkroonida, saata ja vastu võtta"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Keel. taustaandmed?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Taustaandmete keelamine pikendab aku kestvust ja vähendab andmekasutust. Mõned rakendused võivad siiski andmesideühendusi taustal kasutada."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sünkroonim. on SEES"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sünkroonimine VÄLJAS"</string>
    <string name="sync_error" msgid="846923369794727644">"Sünkroonimise viga"</string>
    <string name="last_synced" msgid="1527008461298110443">"Viimati sünkroonitud: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sünkroonimine ..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Varunda seaded"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Minu seadete varundamine"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sünkrooni kohe"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Loobu sünkroonimisest"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Puudutage kohe sünkroonimiseks<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">"Kalender"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontaktid"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Rakenduse sünkroonimisseaded"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Andmed ja sünkroonimine"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Parooli muutmine"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Konto seaded"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Eemalda konto"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Konto lisamine"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Kas eemaldada konto?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Administraator on selle muudatuse keelanud"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Ei saa käsitsi sünkroonida"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Selle üksuse sünkroonimine on praegu keelatud. Seade muutmiseks lülitage ajutiselt sisse taustaandmed ja automaatne sünkroonimine."</string>
    <string name="delete" msgid="8330605554706263775">"Kustuta"</string>
    <string name="select_all" msgid="7898929601615536401">"Vali kõik"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Andmeside kasutus"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobiilne andmeside, WiFi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Isiklike andmete autom. sünk."</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Tööandmete autom. sünkroon."</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Privaatandmete autom. sünkr."</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Tsükli muutmine ..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Kuupäev andmekasutustsükli lähtestamiseks:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Sel perioodil ei kasut. andmeid ükski rakendus."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Esiplaanil"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Taustal"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"piiratud"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Kas lülitada mobiilne andmeside välja?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Seadke mobiilandmeside piirang"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Määrake 4G andmemahupiirang"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Määrake 2G-3G andmemahupiirang"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Määra WiFi andmepiirang"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"WiFi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobiil"</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">"Mobiilne"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Mitte ükski"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobiilne andmeside"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G–3G-andmeside"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G-andmeside"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Rändlusteenus"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Esiplaanil:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Taustal:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Rakenduse seaded"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Andmeside kasutus taustal"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Luba mobiilse andmeside kasutus taustal"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Rakend. taustandm. piiramiseks määrake mob. andmeside piirang."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Kas soovite taustandmeid piirata?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Funktsiooni tõttu võivad taustaandmetel põhinev rakendus töötamast lakata, kui saadaval on ainult mobiilsidevõrgud.\n\nAndmekasutuse täpsemad juhtelemendid leiate rakenduse seadetest."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Taustandmete piiramine on võimalik vaid juhul, kui olete määranud mobiilse andmeside piirangu."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Kas lülitan andmete automaatse sünkroonimise sisse?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Kas lülitan andmete automaatse sünkroonimise välja?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"See säästab andmesidemahu ja aku kasutust, kuid teil tuleb hiljutise teabe hankimiseks sünkroonida iga konto eraldi ja värskenduste ilmumisel ei kuvata märguandeid."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Kasutustsükli lähtestuskuupäev"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Igakuine kuupäev:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Määra"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Andmekasutuse hoiatuse määramine"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Andmekasutuse piirangu määramine"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Andmekasutuse piiramine"</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">"hoiatus"</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">"piir"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Eemaldatud rakendused"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Eemaldatud rakendused ja kasutajad"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Võrgukasutus"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Mahupõhine"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nimi"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tüüp"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Serveri aadress"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP krüpteerimine (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"L2TP saladus"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSeci tunnus"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"IPSeci eeljagatud võti"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSeci kasutaja sertifikaat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSeci CA-sertifikaat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Serveri IPSeci sertifikaat"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Kuva täpsemad valikud"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"DNS-i otsingudomeenid"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"DNS-serverid (nt 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Edastamismarsruudid (nt 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Kasutajanimi"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Parool"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Salvesta kontoteave"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ei kasutata)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ära kinnita serverit)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(serverist saadud)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Seda tüüpi VPN ei saa olla alati ühendatud"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Alati sisselülitatud VPN toetab ainult numbritest koosnevaid serveriaadresse"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Alati sisselülitatud VPN-i puhul peab olema määratud DNS-server"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Alati sisselülitatud VPN-i puhul peab DNS-serveri aadress koosnema numbritest"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Sisestatud teave ei toeta alati sisselülitatud VPN-i"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Tühista"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Loobu"</string>
    <string name="vpn_save" msgid="683868204634860888">"Salvesta"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Ühenda"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Asenda"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"VPN-profiili muutmine"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Unusta"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Profiiliga <xliff:g id="PROFILE">%s</xliff:g> ühendamine"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Kas soovite katkestada ühenduse selle VPN-iga?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Katkesta ühendus"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versioon"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Unusta VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Kas asendada olemasolev VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Kas määrata alati sisselülitatud VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Kui see seade on sisse lülitatud, pole teil Interneti-ühendust, kuni VPN-iga ühenduse loomine õnnestub"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Teie olemasolev VPN asendatakse ja teil pole Interneti-ühendust, kuni VPN-iga ühenduse loomine õnnestub"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Teil juba on ühendus alati sisselülitatud VPN-iga. Kui jätkate mõne teisega, asendatakse teie olemasolev VPN ja alati sisselülitatud režiim lülitatakse välja."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Teil juba on ühendus VPN-iga. Kui jätkate mõne teisega, asendatakse teie olemasolev VPN."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Lülita sisse"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> ei saa ühendust luua"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"See rakendus ei toeta alati sisselülitatud VPN-i"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"VPN-profiili lisamine"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Muuda profiili"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Kustuta profiil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Alati sees VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Ühtegi VPN-i pole lisatud"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Säilita alati ühendus VPN-iga"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Rakendus ei toeta seda"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Alati sees"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Pole turvaline"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"VPN-ita ühenduste blokeerimine"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Kas vajate VPN-i ühendust?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Pole turvaline. Värskendage versioonile IKEv2 VPN."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Valige VPN-i profiil, millega olla alati ühendatud. Võrguliiklus on lubatud ainult siis, kui olete ühendatud selle VPN-iga."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Puudub"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Alati sees VPN-i jaoks on vaja IP-aadressi nii serverile kui ka DNS-ile."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Võrguühendus puudub. Proovige hiljem uuesti."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Ühendus VPN-iga katkestati"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Puudub"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Sertifikaat puudub. Proovige profiili muuta."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Süsteem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Kasutaja"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Keela"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Luba"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Desinstalli"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Usalda"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Kas lubada süsteemi CA-sertifikaat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Kas keelata süsteemi CA-sertifikaat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Kas eemaldada kasutaja CA-sertifikaat jäädavalt?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Kasutab:"</string>
    <string name="credential_contains" msgid="3146519680449595771">"See kirje sisaldab:"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 kasutaja võti"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 kasutaja sertifikaat"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA-sertifikaat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA-sertifikaati"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Mandaadi üksikasjad"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Mandaat eemaldati: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Ühtegi kasutaja mandaati ei ole installitud"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Õigekirjakontroll"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Õigekirjakontroll töö jaoks"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Sisestage oma täieliku varunduse praegune parool siia"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Sisestage täielike varunduste uus parool siia"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Sisestage siia uuesti oma täieliku varunduse uus parool"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Määra varundusparool"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Tühista"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Süsteemi lisavärskendused"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Võrku võidakse jälgida"</string>
    <string name="done_button" msgid="6269449526248267">"Valmis"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Sertifikaadi usaldamine või eemaldamine}other{Sertifikaatide usaldamine või eemaldamine}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} installis teie seadmesse sertifikaadi volituse, mis võib lubada sellel jälgida tegevusi teie seadme võrgus (sh meilid, rakendused ja turvalised veebisaidid).\n\nSelle sertifikaadi kohta lisateabe saamiseks võtke ühendust administraatoriga.}other{{orgName} installis teie seadmesse sertifikaadi volitused, mis võivad lubada sellel jälgida tegevusi teie seadme võrgus (sh meilid, rakendused ja turvalised veebisaidid).\n\nNende sertifikaatide kohta lisateabe saamiseks võtke ühendust administraatoriga.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} installis teie tööprofiilile sertifikaadi volituse, mis võib lubada sellel jälgida tegevusi töökoha võrgus (sh meilid, rakendused ja turvalised veebisaidid).\n\nSelle sertifikaadi kohta lisateabe saamiseks võtke ühendust administraatoriga.}other{{orgName} installis teie tööprofiilile sertifikaadi volitused, mis võivad lubada sellel jälgida tegevusi töökoha võrgus (sh meilid, rakendused ja turvalised veebisaidid).\n\nNende sertifikaatide kohta lisateabe saamiseks võtke ühendust administraatoriga.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Kolmas osapool saab jälgida teie tegevust võrgus, sh meile, rakendusi ja turvalisi veebisaite.\n\nSeda võimaldab teie seadmesse installitud usaldusväärne mandaat."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Kontrollige sertifikaati}other{Kontrollige sertifikaate}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Mitu kasutajat"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Kasutajad ja profiilid"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Lisa kasutaja või profiil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Piiratud profiil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Pole seadistatud"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Pole seadistatud – piiratud profiil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Seadistamata – tööprofiil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administraator"</string>
    <string name="user_you" msgid="3070562015202859996">"Teie (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Rohkem kasutajaid ei saa lisada. Uue lisamiseks eemaldage mõni kasutaja."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Piiratud profiilid ei saa kontosid lisada"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Kustuta seadmest <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Lukustuskuva seaded"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Kasutajate lisamine lukustuskuval"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Vaheta dokkimisel admin.-õigustega kasutajale"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Kas soovite kustutada iseenda?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Kas kustutada kasutaja?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Kas eemaldada profiil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Kas eemaldada tööprofiil?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Kõik rakendused ja andmed kustutatakse."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Kui jätkate, kustutatakse kõik selle profiili rakendused ja andmed."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Kõik rakendused ja andmed kustutatakse."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Uue kasutaja lisamine ..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Kasutaja kustutamine"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Kustuta"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Seansi kõik rakendused ja andmed kustutatakse."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Eemalda"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Külaline (teie)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Kasutajad"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Teised kasutajad"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Kustuta külalise tegevus"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Kustuta külalisrežiimist väljumisel kõik külalise rakendused ja andmed"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Kas kustutada külalise tegevus?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Selle külastajaseansi rakendused ja andmed kustutatakse kohe ning kõik tulevased külastajate tegevused kustutatakse külalisrežiimist väljumisel."</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"kustuta, kustutamine, külaline, tegevus, tegevuse, eemalda, eemaldamine, kõrvalda, külalise"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Luba külalistel helistada"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Külalisest kasutajaga jagatakse kõneajalugu"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Lülita telefonikõned ja SMS-id sisse"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Määra see kasutaja administraatoriks"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Kustuta kasutaja"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Kas lülitada telefonikõned ja SMS-id sisse?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Selle kasutajaga jagatakse kõne- ja SMS-ajalugu."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Kas eemaldada administraatoriõigused?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Kui eemaldate selle kasutaja administraatoriõigused, saate teie või teine administraator need hiljem tagasi anda."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Hädaabiteave"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Kasutaja <xliff:g id="USER_NAME">%1$s</xliff:g> teave ja kontaktid"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Ava <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Rakenduste ja sisu lubamine"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Piirangutega rakendused"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Laienda rakenduste seadeid"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Valige rakendused, mis installida"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Installige saadaolevad rakendused"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Viipemaksed"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Vaikemakserakendus"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Kui soovite makserakendusega makset teha, hoidke seadme tagakülge makseterminali vastas"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Lisateave"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Määrata töörakendus vaikemakserakenduseks?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Töörakendusega makse tegemiseks:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"peab tööprofiil olema sisse lülitatud."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"peate sisestama tööprofiili PIN-koodi, mustri või parooli, kui see on olemas."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Kuidas see toimib?"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Makske poes oma telefoniga"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Vaikemakseviis"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Määramata"</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">"Vaikemakserakenduse kasutamine"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Vaikemakserakenduse kasutamine"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Alati"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"V.a siis, kui mõni teine makserakendus on avatud"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Kontaktivabas terminalis maksate rakendusega:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Terminali kaudu maksmine"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Seadistage makserakendus. Seejärel peate oma telefoni tagakülge hoidma lihtsalt mis tahes terminali lähedal, millel on kontaktivaba makse sümbol."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Selge"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Rohkem …"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Määrake vaikemakserakenduseks"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Värskendage vaikemakserakendust"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Kontaktivabas terminalis maksate rakendusega <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Kontaktivabas terminalis maksate rakendusega <xliff:g id="APP_0">%1$s</xliff:g>.\n\nSee määrab uueks vaikemakserakenduseks rakenduse <xliff:g id="APP_1">%2$s</xliff:g>."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Määra vaikeseadeks"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Värskenda"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Töö"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Piirangud"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Eemalda piirangud"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Muuda PIN-koodi"</string>
    <string name="help_label" msgid="2896538416436125883">"Abi ja tagasiside"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Sisu konto"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Foto ID"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Väga ohtlikud olukorrad"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Häirete vastuvõtmine, kui ilmneb väga tõsine oht elule ja varale"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ohtlikud olukorrad"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Häirete vastuvõtmine, kui ilmneb tõsine oht elule ja varale"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Lasteröövi märguanded"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Teadaannete vastuvõtmine lasteröövide kohta"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Kordamine"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Eriolukorra raadiosideteatised"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Võrguoperaatorid"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Pääsupunktide nimed"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Täiustatud helistamine"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G-helistamine"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Kasuta häälkõnede kvaliteedi parandamiseks LTE-teenuseid (soovitatav)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Kasuta häälkõnede kvaliteedi parandamiseks 4G-teenuseid (soovitatav)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Kasuta häälkõnede puhul 5G-d"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Kontaktide saatmine operaatorile"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Saatke oma kontaktide telefoninumbrid, et pakkuda täiustatud funktsioone"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Kas saata kontaktid operaatorile <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Kas saata kontaktid operaatorile?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Teie kontaktide telefoninumbrid saadetakse perioodiliselt operaatorile <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Selle teabe abil tuvastatakse, kas kontaktid saavad kasutada teatud funktsioone, nagu videokõned või mõned sõnumsidefunktsioonid."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Teie kontaktide telefoninumbrid saadetakse perioodiliselt teie operaatorile.<xliff:g id="EMPTY_LINE">

</xliff:g>Selle teabe abil tuvastatakse, kas kontaktid saavad kasutada teatud funktsioone, nagu videokõned või mõned sõnumsidefunktsioonid."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Eelistatud võrgutüüp"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (soovitatav)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS-sõnumid"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Saatmine ja vastuvõtmine, kui mobiilne andmeside on väljas"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Mobiilandmeside operaatori automaatne vahetamine"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Kasuta seda võrku, kui see on paremini kättesaadav"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Töökoha SIM-kaart"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Juurdepääs rakendusele ja sisule"</string>
    <string name="user_rename" msgid="8735940847878484249">"NIMETA ÜMBER"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Rakendusele piirangute määramine"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Juhib: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"See rakendus pääseb teie kontode juurde"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Sellel rakendusel on juurdepääs teie kontodele. Juhib: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"WiFi ja mobiilne andmeside"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"WiFi, mobiilside ja Bluetoothi lähtestamine"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Bluetoothi sidumiste ja seadete muutmise lubamine"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Asukoht"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Rakendustel asukohateabe kasutamise lubamine"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Tagasi"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Järgmine"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Muul viisil vormindamine"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM-id"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobiilne andmeside pole saadaval"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Puudutage andmeside SIM-kaardi valimiseks"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Kasuta helistamiseks alati seda"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Valige mobiilse andmeside jaoks SIM"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Valige SMS-i jaoks SIM-kaart"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Andmete SIM-kaardi vahetamine, selleks võib kuluda kuni üks minut …"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Kas kasutada mobiil. andmesideks SIM-i <xliff:g id="NEW_SIM">%1$s</xliff:g>?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Kui lülitute SIM-ile <xliff:g id="NEW_SIM">%1$s</xliff:g>, ei kasutata mobiilse andmeside jaoks enam SIM-i <xliff:g id="OLD_SIM">%2$s</xliff:g>."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Kasuta: <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Helistamine SIM-kaardiga"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Sisestage SIM-kaardi nimi"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM-kaardi pesa %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranž"</string>
    <string name="color_purple" msgid="6603701972079904843">"Lilla"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"SIM-i olek"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"SIM-kaardi olek (SIM-kaardi pesa %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="2819551384383504031">"SIM-id on muudetud."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Puudutage seadistamiseks"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Küsi iga kord"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Valik on tegemata"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"SIM-kaardi valik"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Seaded"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Võrk ja internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobiilne andmeside, WiFi, kuumkoht"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"WiFi, kuumkoht"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Ühendatud seadmed"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, sidumine"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, sõidurežiim, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, sõidurežiim"</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, sõidurežiim, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, sõidurežiim"</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">"Pole saadaval, kuna NFC on väljas"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Kasutamiseks installige esmalt makserakendus"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Hiljutised rakendused, vaikerakendused"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Tööprofiilil pole märguannete juurdepääs rakenduste puhul saadaval."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Paroolid ja kontod"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Salvestatud paroolid, automaattäide ja sünkroonitud kontod"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Vaikerakendused"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Kloonitud rakendused"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Looge rakenduse teine eksemplar, et saaksite korraga kahte kontot kasutada."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Rakendused, mida saab kloonida."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> kloonitud, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> saadaval kloonimiseks"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Kõigi rakenduse kloonide kustutamine"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Rakenduse kloonide kustutamine nurjus"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Loomine …"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Kloonitud"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Luuakse rakenduse <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> kloon"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Loodi rakenduse <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> kloon"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Keeled, liigutused, kellaaeg, varundamine"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Süsteemi keeled, rakenduste keeled, piirkondlikud eelistused, kõne"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, võrguühendus, internet, juhtmeta, andmed, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"WiFi märguanne, wifi märguanne"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"andmekasutus"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Kasuta 24-tunni vormingut"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Ava rakendusega"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Rakendused"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"ajavöönd"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Vestlusmull, süsteem, teatis, aken, dialoog, kuvamine, muude rakenduste peal, joonistamine"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Taskulamp, valgus, lamp"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, WiFi, lüliti, juhtimine"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobiilne, mobiil, mobiilioperaator, juhtmeta, andmed, 4g,3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, kõne, helistamine"</string>
    <string name="keywords_display" msgid="874738809280751745">"ekraan, puuteekraan"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"ekraani hämardamine, puuteekraan, aku, ere"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"ekraani hämardamine, öö, toon, öörežiim, eredus, ekraanikuva värv, värv"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"taust, isikupärastamine, ekraani kohandamine"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"teksti suurus"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projekt, ülekandmine, ekraani peegeldamine, ekraani jagamine, peegeldamine, kuva jagamine, ekraani ülekandmine"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"ruum, ketas, kõvaketas, seadme kasutus"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"energiakasutus, laadimine"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"akukasutuse vaatamine, akukasutus, toitekasutus"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"akusäästja, toitesäästja, säästja"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"kohanduvad eelistused, kohanduv akuhaldur"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"õigekiri, sõnastik, õigekirjakontroll, automaatne korrigeerimine"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"tuvastaja, sisend, kõne, rääkima, keel, käed vabad, vabakäe, tuvastamine, solvav, sõna, heli, ajalugu, bluetoothi peakomplekt"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"hinda, keel, vaikimisi, kõnele, kõnelemine, TTS, juurdepääsetavus, ekraanilugeja, pime"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"24-tunnine kell"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"lähtesta, taasta, tehaseseaded"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"pühkimine, kustutamine, taastamine, tühjendamine, eemaldamine, tehaseseadetele lähtestamine"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printer"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"kõlari piiks, kõlar, helitugevus, vaigistamine, vaikus, heli, muusika, värintagasiside, vibratsioon, vibreerimine"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"mitte segada, katkesta, katkestus, paus"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"läheduses, asukoht, ajalugu, aruandlus, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"konto, konto lisamine, tööprofiil, lisa konto, eemalda, kustuta"</string>
    <string name="keywords_users" msgid="3497517660077620843">"piirang, piira, piiratud"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"tekstiparandus, paranda, heli, vibreeri, automaatne, keel, liigutus, soovita, soovitus, teema, solvav, sõna, tüüp, emotikon, rahvusvaheline"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"lähtestamine, eelistused, vaikeseade"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"rakendused, allalaadimine, rakendused, süsteem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"rakendused, load, turvalisus"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"rakendused, vaikimisi"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"optimeerimiste ignoreerimine, Doze, rakenduse ooterežiim"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"ere, RGB, SRGB, värv, loomulik, tavaline"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, eraldusvõime, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"värvitemperatuur, D65, D73, valge, kollane, sinine, soe, külm"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"libista avamiseks, parool, muster, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"ekraanikuva kinnitamine"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"töö väljakutse, töö, profiil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"tööprofiil, hallatud profiil, ühenda, ühendamine, töö, profiil"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"ärata, magama, ära lukusta, ära lukusta voltimisel, voldi, sulgemine, voltimine, sulge, ekraan välja"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"liigutused"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"Wallet"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"maksa, puuduta, maksed"</string>
    <string name="keywords_backup" msgid="707735920706667685">"varukoopia, varundamine"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"nägu, avamine, autentimine, sisselogimine"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"nägu, avamine, autentimine, sisselogimine, sõrmejälg, biomeetria"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl-i versioon, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"võrk, mobiilsidevõrgu olek, teenuse olek, signaali tugevus, mobiilsidevõrgu tüüp, rändlus"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"võrk, mobiilsidevõrgu olek, teenuse olek, signaali tugevus, mobiilsidevõrgu tüüp, rändlus, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"võrk, mobiilsidevõrgu olek, teenuse olek, signaali tugevus, mobiilsidevõrgu tüüp, rändlus, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"võrk, mobiilsidevõrgu olek, teenuse olek, signaali tugevus, mobiilsidevõrgu tüüp, rändlus, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"seerianumber, riistvaraversioon"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"aku teave, tootmiskuupäev, tsüklite arv, esmakordne kasutamine"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"androidi turvapaiga tase, põhiribaversioon, tuuma versioon"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"teema, hele, tume, režiim, valgustundlikkus, fotofoobia, tumedamaks muutmine, tumendamine, tume režiim, migreen"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tume teema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"viga"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Säästlik ekraan, lukustuskuva ekraan"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"lukustuskuva märguanne, märguanded"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"nägu"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"sõrmejälg, sõrmejälje lisamine"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"nägu, sõrmejälg, sõrmejälje lisamine"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"kellaga avamine, kellaga avamise lisamine"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"ekraani hämardamine, puuteekraan, aku, nutikas heledus, dünaamiline heledus, automaatne heledus"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"nutikas, ekraani hämardamine, unerežiim, aku, ajalõpp, tuvastus, ekraan, ekraanikuva, tegevusetus"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kaamera, nutikas, automaatne pööramine, pöörama, vahetamine, pööramine, vertikaalpaigutus, horisontaalpaigutus, suund, vertikaalne, horisontaalne"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"versiooniuuendus, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, ajakava, märguanded, blokeerimine, vaikus, vibreerimine, unerežiim, töö, keskendumine, heli, vaigistamine, päev, tööpäev, nädalalõpp, öö nädala sees, sündmus"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"kuva, lukustusaeg, ajalõpp, lukustuskuva"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"mälu, vahemälu, andmed, kustutamine, tühjendamine, vaba, ruum"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"ühendatud, seade, kõrvaklapid, peakomplekt, kõlar, juhtmeta, sidumine, nööpkõrvaklapid, muusika, meedia"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"taust, teema, ruudustik, kohandamine, isikupärastamine"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikoon, aktsent, värv, avakuva, lukustuskuva, otsetee, kella suurus"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"vaikimisi, assistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"makse, vaikeseade"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"sissetulev märguanne"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb jagamine, bluetoothi jagamine, wifi-pääsupunkt"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"värintagasiside, vibreeri, vibreerimine"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"puutepõhine, vibreerimine, kuva, tundlikkus"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"puutepõhine, vibreerimine, telefon, kõne, tundlikkus, helin"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"puutepõhine, vibreerimine, telefon, kõne, helin, järk-järgult"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"puutepõhine, vibreerimine, tundlikkus, märguanne"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"puutepõhine, vibreerimine, tundlikkus, äratus"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"puutepõhine, vibreerimine, tundlikkus, meedia"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"värintagasiside, vibreeri, vibreerimine"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"akusäästja, kinnitatav, pidev, aku säästmine, aku"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutiin, ajakava, akusäästja, toite säästmine, aku, automaatne, protsent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, täiustatud helistamine, 4g-kõned"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, täiustatud helistamine, 5g-kõned"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"lisa keel, keele lisamine"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"teksti suurus, suur tekst, suur font, halb nähtavus, teksti suuremaks muutmine, fondi suurendaja, fondi suurendamine"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"alati sisse lülitatud taustakuva, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, kiip, lugeja"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"klaviatuur, värintagasiside, vibreerimine,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Helitugevus, vibreerimine, režiim Mitte segada"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Meedia helitugevus"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Ülekantava sisu helitugevus"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Kõne helitugevus"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Äratuse helitugevus"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Helina ja märguannete helitugevus"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Helina helitugevus"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Märguande helitugevus"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Hääletu telefonihelin"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Vibreeriv telefonihelin"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Märguannete helitugevus on vaigistatud, märguanded vibreerivad"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> on vaigistatud"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Pole saadaval, kuna helin on vaigistatud"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Telefoni helin"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Märguande vaikeheli"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Rakenduse esitatud heli"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Märguande vaikeheli"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Äratuse vaikeheli"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibreeri ja siis helise valjenedes"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Ruumiline heli"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Valimisklahvistiku toonid"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Ekraanikuva lukustamise heli"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Laadimishelid ja vibreerimine"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Dokkimise helid"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Puute- ja klõpsamishelid"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Kuva vibratsioonirežiimis alati ikoon"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Kõlari dokkimise heli"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Kogu heli"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Ainult meedia heli"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Vaikus"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Toonid"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibratsioonid"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Sisselülitamise helid"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Reaalajas subtiitrid"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Meediasisu automaatsed subtiitrid"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Juhtmega kõrvaklapid"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Ühilduva meedia heli muutub ruumilisemaks"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Väljas"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Sees / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Sees / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> + <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Võite ruumilise heli lülitada sisse ka Bluetooth-seadmete jaoks."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Ühendatud seadmete seaded"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Puudub}=1{1 ajakava on määratud}other{# ajakava on määratud}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Mitte segada"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Ainult oluliste inimeste ja rakendustega seotud märguanded"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Katkestuste piiramine"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Valiku Mitte segada sisselülitamine"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarmid ja meediahelid saavad katkestada"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Ajakavad"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Ajakavade kustutamine"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Kustuta"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Muuda"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Ajakavad"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Ajakava"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Ajastamine"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Telefoni vaigistamine teatud ajal"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Režiimi Mitte segada reeglite määramine"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Ajastamine"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Kasuta ajakava"</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">"Helimärguandega katkestuste lubamine"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Visuaalsete häirimiste blok."</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Luba visuaalsed signaalid"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Peidetud märguannete kuvamisvalikud"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kui funktsioon Mitte segada on sisse lülitatud"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Hääletud märguanded"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Näete ekraanil märguandeid"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Teie telefon ei helise ega vibreeri märguannete saabumisel."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Te ei kuule ega näe märguandeid"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Teie telefon ei vibreeri ega helise uute ega olemasolevate märguannete puhul ega kuva neid. Pidage meeles, et kriitilised märguanded seadme tegevuste ja oleku kohta kuvatakse siiski.\n\nKui funktsiooni Mitte segada välja lülitate, leiate nägemata märguanded ekraani ülaosast alla pühkides."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Kohandatud"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Kohandatud seade lubamine"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Kohandatud seade eemaldamine"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Hääletud märguanded"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Osaliselt peidetud"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Kohandatud piirangud"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Kui ekraan on sees"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kui ekraan on väljas"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Vaigista heli ja vibreerimine"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Ära lülita ekraani sisse"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Ära vilguta tuld"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Ära kuva märguandeid ekraanil"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Peida ülaosas olekuriba ikoonid"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Peida märguandetäpid ikoonidel"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ära ärata märguannete puhul"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Peida allatõmmatavas menüüs"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Mitte kunagi"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kui ekraan on väljas"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kui ekraan on sees"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Heli ja vibreerimine"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Märguannete heli, vibreerimine ja mõned visuaalsed märgid"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Märguannete heli, vibreerimine ja visuaalsed märgid"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Märguandeid, mis on vajalikud seadme põhitoiminguteks ja oleku kuvamiseks, ei peideta kunagi."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Puudub"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"muud valikud"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Lisa"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Lülita sisse"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Lülita kohe sisse"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Lülita kohe välja"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Funktsioon Mitte segada on sees kuni <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Funktsioon Mitte segada on sees seni, kuni selle välja lülitate"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Ajakava (<xliff:g id="RULE_NAME">%s</xliff:g>) lülitas funktsiooni Mitte segada automaatselt sisse"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Rakendus (<xliff:g id="APP_NAME">%s</xliff:g>) lülitas funktsiooni Mitte segada automaatselt sisse"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Funktsioon Mitte segada on reeglite <xliff:g id="RULE_NAMES">%s</xliff:g> puhul sisse lülitatud koos kohandatud seadetega."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Kuva kohandatud seaded"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Ainult prioriteetsed"</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">"Sees / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Sees"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Küsi iga kord"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Kuni välja lülitate"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 tund}other{# tundi}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minut}other{# minutit}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Väljas}=1{Väljas / 1 ajakava saab automaatselt sisse lülitada}other{Väljas / # ajakava saavad automaatselt sisse lülitada}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Mis saavad režiimi Mitte segada katkestada?"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Inimesed"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Rakendused"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmid ja muud katkestused"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Ajakavad"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Kiirseadete kestus"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Üldine"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Kui funktsioon Mitte segada on sisse lülitatud, vaigistatakse heli ja vibreerimine (v.a ülal lubatud üksuste puhul)."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Kohandatud seaded"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Vaadake ajakava üle"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Selge"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Märguanded"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Kestus"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Sõnumid, sündmused ja meeldetuletused"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Kui funktsioon Mitte segada on sisse lülitatud, vaigistatakse sõnumid, meeldetuletused ja sündmused, välja arvatud teie ülal lubatud üksuste puhul. Võite sõnumite seadeid kohandada, et lubada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Valmis"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Seaded"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Hääletud märguanded"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Te ei kuule ega näe märguandeid. Tärniga tähistatud kontaktidelt ja korduvatelt helistajatelt pärit kõned on lubatud."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(praegune seade)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Kas soovite režiimi Mitte segada märguandeseadeid muuta?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Tööprofiili helid"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Kasuta isikliku profiili helisid"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Kasutage samu helisid, mida kasutate oma isikliku profiiliga"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Töötelefoni helin"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Töömärguande vaikeheli"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Tööäratuse vaikeheli"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Sama mis isiklikul profiilil"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Kas kasutada isikliku profiili helisid?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Kinnita"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Teie tööprofiil kasutab teie isikliku profiiliga samu helisid"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Märguanded"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Märguannete ajalugu, vestlused"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Vestlus"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Haldamine"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Rakenduste märguanded"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Individuaalsete rakenduste märguannete haldamine"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Üldine"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Töö märguanded"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Tööprofiil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Kohanduvate märguannete prioriteet"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Madalama prioriteediga märguanded määratakse automaatselt leebeteks märguanneteks"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Märguannete kohanduv järjestamine"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Järjesta märguanded automaatselt asjakohasuse järgi"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Kohanduvate märguannete tagasiside"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Näitab, kuidas on märguandeid kohandatud. Samuti näitab valikut süsteemile tagasiside andmiseks."</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Märguande olulisuse lähtestamine"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Kasutaja muudetud olulisuse seadete lähtestamine ja märguannete assistendil prioriseerimise lubamine"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Soovitatud toimingud ja vastused"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Kuva soovitatud toimingud ja vastused automaatselt"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Kuva hiljutisi ja edasilükatud märguandeid"</string>
    <string name="notification_history" msgid="8663811361243456201">"Märguannete ajalugu"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Kasuta märguannete ajalugu"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Märguannete ajalugu on välja lülitatud"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Hiljutiste ja edasilükatud märguannete nägemiseks lülitage märguannete ajalugu sisse"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Hiljutisi märguandeid ei ole"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Teie hiljutised ja edasilükatud märguanded kuvatakse siin"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"kuva märguandeseaded"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"ava märguanne"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Luba märguandeid edasi lükata"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Märguandetäpp rakenduse ikoonil"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Mullid"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Mullid"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Kuva see vestlus mullis"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Kuva rakenduste peal hõljuv ikoon"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Kas lülitada mullid seadmes sisse?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Kui lülitate mullid selle rakenduse puhul sisse, lülitatakse mullid sisse ka teie seadmes.\n\nSee mõjutab teisi rakendusi või vestlusi, millel on luba mullis kuvamiseks."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Lülita sisse"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Tühista"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Sees / vestlused kuvatakse hõljuvate ikoonidena"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Luba rakendustel mulle kuvada"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Mõned vestlused kuvatakse hõljuvate ikoonidena teiste rakenduste peal"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Kõik vestlused saab mullina kuvada"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Valitud vestlused saab mullina kuvada"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Mitte midagi ei saa mullina kuvada"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Vestlused"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Kõik vestlused saab kuvada mullis, v.a"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Lülitage mullid selle vestluse puhul välja"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Lülitage mullid selle vestluse puhul sisse"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Loobumiseks pühkige paremale, menüü kuvamiseks vasakule"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Loobumiseks pühkige vasakule, menüü kuvamiseks paremale"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Peida vaiksed märguanded olekuribal"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Vilkuv tuli"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privaatsus"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Jäta lukustuskuva vahele"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Pärast avamist avaneb viimati kasutatud ekraanikuva. Märguandeid lukustuskuval ei kuvata. Nende nägemiseks pühkige ülaosast alla."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Lukustuskuva, lukustuskuva, vahelejätmine, mittekasutamine"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kui tööprofiil on lukustatud"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Kuva lukustuskuval ainult uued märguanded"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Eemalda varem vaadatud märguanded lukustuskuvalt automaatselt"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Märguanded lukustuskuval"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Kuva vestluse, vaike- ja hääletud märguanded"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Kuva vestluse, vaike- ja hääletud märguanded"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Peida hääletud vestlused ja märguanded"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ära kuva märguandeid"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Tundlikud märguanded"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Kuva lukustatuna tundlik sisu"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Tööprofiili tundlikud märguanded"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Kuva lukustatuna tööprofiili tundlik sisu"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Kuva kogu märguande sisu"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Kuva tundlik sisu ainult avatuna"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Ära kuva märguandeid üldse"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Kuidas soovite lukustuskuva kuvada?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Lukustuskuva"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Kuva tööprofiili märguannete kogu sisu"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Peida tundlik töösisu"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kuidas tuleks profiili märguanded kuvada siis, kui seade on lukus?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profiili märguanded"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Märguanded"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Rakenduste märguanded"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Märguannete kategooria"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Käitumine"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Vestlused"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Vestluste jaotis"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Rakendusel lubatakse kasutada vestluste jaotist"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Pole vestlus"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Eemalda vestluste jaotisest"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"See on vestlus"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Lisa vestluste jaotisse"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Prioriteetseid vestlusi pole"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioriteetne vestlus}other{# prioriteetset vestlust}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioriteetsed vestlused"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Kuvatakse vestluste jaotise kohal hõljuvate mullidena"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Kuva vestluste jaotise kohal"</string>
    <string name="other_conversations" msgid="551178916855139870">"Vähemtähtsad vestlused"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Vestlused, milles olete muudatusi teinud"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Hiljutised vestlused"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Kustuta hiljutised vestlused"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Hiljutine vestlus eemaldati"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Vestlus eemaldati"</string>
    <string name="clear" msgid="5092178335409471100">"Kustuta"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Prioriteetsed ja muudetud vestlused kuvatakse siin"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Kui märgite vestluse prioriteetseks või teete vestluses teisi muudatusi, kuvatakse need siin. \n\nVestluse seadete muutmine: \npühkige ekraani ülaosast alla, et avada allatõmmatav ala. Seejärel puudutage pikalt vestlust."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimeeri"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Tõsta märguanne esile"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Hääletu"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Vaikeseade"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Katkestuste lubamine"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Rakendusel lubatakse heli esitada, vibreerida ja/või ekraanil hüpikmärguandeid kuvada"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioriteetne"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Kuvatakse vestluste jaotise ülaosas hõljuva mullina ja lukustuskuval kuvatakse profiilipilt"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> ei toeta enamikku vestlusfunktsioone. Te ei saa vestluse prioriteeti määrata ja vestluseid ei kuvata hõljuvate mullidena."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Allatõmmatavas loendis ahendatakse märguanded ühele reale"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Ilma heli ja vibreerimiseta"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Ilma heli ja vibreerimiseta, kuvatakse vestluste jaotises allpool"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Võib seadme seadete põhjal heliseda või vibreerida"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kui seade on avatud, kuvatakse märguanded bännerina ekraanikuva ülaosas"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Kõik tüüpi „<xliff:g id="APP_NAME">%1$s</xliff:g>” märguanded"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Kõik rakenduse <xliff:g id="APP_NAME">%1$s</xliff:g> märguanded"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Ligikaudu # märguanne päevas}other{Ligikaudu # märguannet päevas}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Ligikaudu # märguanne nädalas}other{Ligikaudu # märguannet nädalas}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Mitte kunagi"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Seadmete ja rakenduste märguanded"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Hallake, millised rakendused ja seadmed saavad märguandeid lugeda"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Juurdepääs tööprofiili märguannetele on blokeeritud"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Täiustatud märguanded"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Hankige soovitatud toiminguid, vastuseid ja muud"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Puudub"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Ükski installitud rakendus pole taotlenud juurdepääsu märguannetele."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Luba juurdepääs märguannetele"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Androidi versioonis 12 asendasid täiustatud märguanded Androidi kohanduvad märguanded. See funktsioon näitab soovitatud toiminguid ja vastuseid ning korrastab teie märguandeid. \n\nTäiustatud märguanded pääsevad juurde märguande sisule, sh isiklikule teabele, nagu kontaktide nimed ja sõnumid. Samuti saab selle funktsiooni abil märguannetest loobuda või neile vastata (nt vastata telefonikõnedele ja juhtida funktsiooni Mitte segada)."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Kas <xliff:g id="SERVICE">%1$s</xliff:g> pääseb märguannetele juurde?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Rakendus <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> saab lugeda kõiki märguandeid, sh isikuandmeid, näiteks kontaktide nimesid, fotosid ja teile saadetud tekstsõnumeid. Rakendus saab ka märguandeid edasi lükata või neist loobuda või aktiveerida märguannetes olevaid toimingunuppe, sealhulgas vastata telefonikõnedele. \n\nSee võimaldab rakendusel ka lülitada sisse või välja funktsiooni Mitte segada ja muuta sellega seotud seadeid."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Rakendus <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> saab teha järgmist:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Märguannete lugemine"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"See saab lugeda teie märguandeid, sealhulgas isiklikku teavet, näiteks kontakte, sõnumeid ja fotosid."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Sõnumitele vastamine"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"See saab vastata sõnumitele ja aktiveerida märguannetes olevaid toimingunuppe, sealhulgas märguandeid edasi lükata või nendest loobuda ja kõnedele vastata."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Seadete muutmine"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"See saab funktsiooni Mitte segada sisse või välja lülitada ja muuta seotud seadeid."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Kui lülitate teenuse <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> jaoks juurdepääsu märguannetele välja, võidakse välja lülitada ka juurdepääs funktsioonile Mitte segada."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Lülita välja"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Tühista"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Reaalajas"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Käimasolev suhtlus kasutatavatest rakendustest, navigeerimine, telefonikõned ja muu"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Vestlused"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS-id, tekstsõnumid ja muud suhtlusviisid"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Märguanded"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Võivad seadete põhjal heliseda või vibreerida"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Hääletu"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Märguanded, mis ei tee kunagi häält ega vibreeri"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Lubatud"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Pole lubatud"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Kuva kõik rakendused"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Muutke seadeid iga rakenduse jaoks, mis saadab märguandeid"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Seadmes kuvatud rakendused"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"See rakendus ei toeta täiustatud seadeid"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Rohkem seadeid"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Selle rakenduse sees on saadaval rohkem seadeid"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Märguannete rahunemine"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Rahunemise rakendamine kõigile märguannetele"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Vähendab järk-järgult märguannete helitugevust, kui saate samast rakendusest mitu järjestikust teavitust"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Rahunemise rakendamine vestlustele"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Vähendab järk-järgult märguannete helitugevust, kui saate samast vestlusest mitu järjestikust teavitust"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Ära kasuta märguannete rahunemist"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Ei vähenda kunagi märguannete helitugevust, olenemata sama rakenduse järjestikuste märguannete arvust"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Avatuna vibreerimine"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Vibreerib ainult, kui ekraan on avatud"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Tööprofiilidele rakendamine"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Rakendab märguannete rahunemise seaded teie isiklikult profiililt teie tööprofiilile"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"VR-abilise teenused"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Ükski installitud rakendus pole taotlenud VR-abilise teenusena käitamist."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Kas lubada VR-teenuse juurdepääs teenusele <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"Teenust <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> saab käitada, kui kasutate rakendusi virtuaalreaalsuse režiimis."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Kui seade on VR-režiimis"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Vähenda hägusust (soovitatav)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Vähenda värelemist"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Pilt pildis"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Ükski installitud rakendus ei toeta funktsiooni Pilt pildis"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip pildis"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Pilt pildis"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Luba režiim Pilt pildis"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Lubage rakendusel luua pilt pildis aken ajal, mil rakendus on avatud, või pärast sellest väljumist (näiteks video vaatamise jätkamiseks). Aken kuvatakse muude kasutatavate rakenduste peal."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Ühendatud töö- ja isiklikud rakendused"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Ühendatud"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Ühendamata"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Ühtegi rakendust pole ühendatud"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"profiiliülene ühendatud rakendus rakendused töö ja isiklik"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Ühendatud"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Ühenda need rakendused"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Ühendatud rakendused kasutavad ühiseid lube ja neil on juurdepääs teineteise andmetele."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Ühendage rakendused ainult siis, kui olete kindel, et need ei jaga teie isiklikke andmeid IT-administraatoriga."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Rakenduste ühenduse saate seadme privaatsusseadetes igal ajal katkestada."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Kas usaldate töörakendust <xliff:g id="NAME">%1$s</xliff:g> ja lubate sellel oma isiklikele andmetele juurde pääseda?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Ühendage rakendused ainult siis, kui olete kindel, et need ei jaga teie isiklikke andmeid IT-administraatoriga."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Rakenduse andmed"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Rakendusel on juurdepääs teie isikliku rakenduse <xliff:g id="NAME">%1$s</xliff:g> andmetele."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Load"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"See rakendus võib kasutada teie isikliku rakenduse <xliff:g id="NAME">%1$s</xliff:g> lube, nagu juurdepääs asukohale, salvestusruumile või kontaktidele."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Ühtegi rakendust pole ühendatud"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# rakendus on ühendatud}other{# rakendust on ühendatud}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Nende rakenduste ühendamiseks installige <xliff:g id="NAME">%1$s</xliff:g> oma tööprofiilile"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Nende rakenduste ühendamiseks installige <xliff:g id="NAME">%1$s</xliff:g> oma isiklikule profiilile"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Puudutage rakenduse hankimiseks"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Mitte segada juurdepääs"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Luba funktsioon Mitte segada"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Ükski installitud rakendus pole palunud juurdepääsu funktsioonile Mitte segada"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Te pole selle rakenduse märguandeid lubanud"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Teie taotluse kohaselt blokeerib Android selle märguandekategooria kuvamise selles seadmes"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Teie taotluse kohaselt blokeerib Android selle märguandegrupi kuvamise selles seadmes"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"See rakendus ei saada märguandeid"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategooriad"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Muu"</string>
    <string name="no_channels" msgid="4716199078612071915">"See rakendus pole postitanud ühtegi märguannet"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Lisaseaded rakenduses"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# kategooria kustutati}other{# kategooriat kustutati}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokeeri kõik"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Ära kunagi näita neid märguandeid"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Kuva märguanded"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Ära kuva märguandeid kunagi märguandealal ega välisseadmetes"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Kogu ekraani katvate märguannete lubamine"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Lubage kuvada kogu ekraani katvaid märguandeid, kui seade on lukustatud"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Luba märguandetäpp"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Kuva märguandetäpp"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Funktsiooni Mitte segada alistamine"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Nendel märguannetel lubatakse teid jätkuvalt katkestada, kui funktsioon Mitte segada on sisse lülitatud"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Lukustuskuva"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Valmis"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Vilkuv tuli"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibreerimine"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Heli"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioriteetne"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Ajakava nimi"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Sisestage ajakava nimi"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Ajakava nimi on juba kasutuses"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Lisa veel"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Sündmuse ajakava lisamine"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Ajakava lisamine"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Valige ajakava tüüp"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Kas kustutada reegel „<xliff:g id="RULE">%1$s</xliff:g>”?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Kustuta"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Neid seadeid ei saa praegu muuta. Rakendus (<xliff:g id="APP_NAME">%1$s</xliff:g>) on funktsiooni Mitte segada koos kohandatud käitumisega automaatselt sisse lülitanud."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Neid seadeid ei saa praegu muuta. Rakendus on funktsiooni Mitte segada koos kohandatud käitumisega automaatselt sisse lülitanud."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Neid seadeid ei saa praegu muuta. Funktsioon Mitte segada koos kohandatud käitumisega lülitati käsitsi sisse."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Aeg"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Sündmus"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Sündmuste ajal:"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Mis tahes kalender"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Kui vastus on:"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Jah, Võib-olla või Pole vastanud"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Jah või Võib-olla"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Jah"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Reeglit ei leitud."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Sees / <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">"Päevad"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Puudub"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Äratus alistab lõppaja"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Ajakava lülitub äratuse kõlamisel välja"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Funktsiooni Mitte segada käitumine"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Kasuta vaikeseadeid"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Ajakavale kohandatud seadete määramine"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” jaoks"</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">"Vestlused"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Kõik vestlused"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioriteetsed vestlused"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioriteetsed vestlused"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Mitte ükski"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Puudub}=1{1 vestlus}other{# vestlust}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kes saavad katkestada?"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Isegi kui sõnumside- või helistamisrakendused teid teavitada ei saa, saavad teie siin valitud inimesed teiega nende rakenduste kaudu siiski ühendust võtta."</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Kõned"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Kõned"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"kõned"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Kõned, mis saavad katkestada"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Selleks et telefon lubatud kõnede puhul heliseks, kontrollige, kas helinarežiim on aktiveeritud."</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” puhul on sissetulevad kõned blokeeritud. Võite seadeid kohandada, et võimaldada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Tärniga kontaktid"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Puudub}=1{{contact_1}}=2{{contact_1} ja {contact_2}}=3{{contact_1}, {contact_2} ja {contact_3}}other{{contact_1}, {contact_2} ja veel #}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Nimi puudub)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Sõnumid"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"sõnumid"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Sõnumid"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Sõnumid, mis saavad katkestada"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Selleks et telefon lubatud sõnumite puhul heliseks, kontrollige, kas helinarežiim on aktiveeritud."</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” puhul on sissetulevad sõnumid blokeeritud Võite seadeid kohandada, et võimaldada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Kõik sõnumid jõuavad teieni"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Kõik kõned jõuavad teieni"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Puudub}=1{1 kontakt}other{# kontakti}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Kõik"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontaktid"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Tärniga kontaktid"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Mitte ükski"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Mitte ükski"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmid"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Taimeritelt, äratustelt, turvasüsteemidelt ja muudelt rakendustelt"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"äratused"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Äratused"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Meediahelid"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Videote, mängude ja muu meediasisu heli"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"meedia"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Meedia"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Puutehelid"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Klaviatuuri ja muude nuppude helid"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"puutehelid"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Puutehelid"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Meeldetuletused"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Ülesannetelt ja meeldetuletustelt"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"meeldetuletused"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Meeldetuletused"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Kalendrisündmused"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Tulevastelt kalendrisündmustelt"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"sündmused"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Sündmused"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Luba rakendustel alistada"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Rakendused, mis saavad katkestada"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Valige rohkem rakendusi"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Rakendusi pole valitud"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Mitte ükski rakendus ei saa katkestada"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Rakenduste lisamine"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Kõik märguanded"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Mõned märguanded"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Valitud inimesed saavad teiega ühendust võtta, isegi kui te ei luba rakendustel end segada"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Mitte ükski rakendus ei saa katkestada}=1{{app_1} saab katkestada}=2{{app_1} ja {app_2} saavad katkestada}=3{{app_1}, {app_2} ja {app_3} saavad katkestada}other{{app_1}, {app_2} ja veel # saavad katkestada}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Rakendused"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Märguanded, mis saavad katkestada"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Luba kõik märguanded"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Mitte miski ei saa katkestada}=1{{sound_category_1} saab katkestada}=2{{sound_category_1} ja {sound_category_2} saavad katkestada}=3{{sound_category_1}, {sound_category_2} ja {sound_category_3} saavad katkestada}other{{sound_category_1}, {sound_category_2} ja veel # saavad katkestada}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Mitte miski ei saa katkestada"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Mitte keegi ei saa katkestada"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Mõned inimesed saavad katkestada"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Kõik inimesed saavad katkestada"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Korduvad helistajad"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Luba korduvad helistajad"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"igaüks"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontaktid"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"tärniga kontaktid"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"korduvad helistajad"</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> ja <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Kui sama inimene helistab teile <xliff:g id="MINUTES">%d</xliff:g> minuti jooksul teist korda"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Algusaeg"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Lõppaeg"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> järgmisel päeval"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Muudetakse määramata ajaks valikule Ainult alarmid"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Muudetakse valikule Ainult äratused 1 minutiks kuni {time}}other{Muudetakse valikule Ainult äratused # minutiks (kuni {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Muudetakse valikule Ainult äratused 1 tunniks kuni {time}}other{Muudetakse valikule Ainult äratused # tunniks kuni {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Muudetakse valikule Ainult alarmid kuni kella <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Muudetakse valikule Katkesta alati"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Hoiatus"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Sule"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Seadme kohta tagasiside saatmine"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Sisestage administraatori PIN-kood"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Sees"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Väljas"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Sees"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Väljas"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Sees"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Väljas"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Rakenduse kinnitamine"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Rakenduse kinnitamise abil saate hoida praeguse rakenduse kuval seni, kuni selle vabastate. Seda funktsiooni saab kasutada näiteks selleks, et lubada usaldusväärsel sõbral teatud mängu mängida."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Kui rakendus on kinnitatud, saab kinnitatud rakendus avada teisi rakendusi ja isiklikud andmed võivad olla juurdepääsetavad. \n\nRakenduse kinnitamise kasutamiseks: 	\n{0,number,integer}. Rakenduse kinnitamise sisselülitamiseks 	\n{1,number,integer}. Avage ülevaade 	\n{2,number,integer}. Puudutage ekraanikuva ülaosas rakenduse ikooni ja siis käsku Kinnita."</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Kui rakendus on kinnitatud, saab kinnitatud rakendus avada teisi rakendusi ja isiklikud andmed võivad olla juurdepääsetavad. \n\nKui soovite oma seadet kellegagi turvaliselt jagada, proovige selle asemel kasutada külaliskasutajat. \n\nRakenduse kinnitamise kasutamiseks: 	\n{0,number,integer}. Rakenduse kinnitamise sisselülitamiseks 	\n{1,number,integer}. Avage ülevaade 	\n{2,number,integer}. Puudutage ekraanikuva ülaosas rakenduse ikooni ja siis käsku Kinnita."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kui rakendus on kinnitatud: \n\n•		võivad isiklikud andmed (nt kontaktid\nja meilide sisu) olla juurdepääsetavad; \n•		kinnitatud rakendus võib avada teisi rakendusi. \n\nKasutage rakenduse kinnitamist ainult usaldusväärsete inimestega."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Enne vabastamist küsi avamismustrit"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Enne vabastamist küsi PIN-koodi"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Enne vabastamist küsi parooli"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Vabastamise korral lukusta seade"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"SIM-i kustutamise kinnitamine"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Enne eSIM-i kustutamist kinnitage oma isik"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Täiustatud mälukaitse (beeta)"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Täiustatud mälukaitse"</string>
    <string name="memtag_intro" msgid="579408691329568953">"See beetafunktsioon aitab teil oma seadet kaitsta vigade eest, mis võivad teie turvalisuse ohtu seada."</string>
    <string name="memtag_on" msgid="824938319141503923">"Sees"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Väljas"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Pärast taaskäivitamist sees"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Pärast taaskäivitamist väljas"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Pole praegu teie seadmes saadaval"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Teie seadmes alati sisse lülitatud"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Täiustatud mälukaitse sisse- või väljalülitamiseks peate oma seadme taaskäivitama. Kui see on sisse lülitatud, võib seade aeglasemini toimida."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Kas taaskäivitada seade?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Peate oma seadme taaskäivitama, et Täiustatud mälukaitse sisse lülitada."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Peate oma seadme taaskäivitama, et Täiustatud mälukaitse välja lülitada."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Taaskäivita"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Mitte praegu"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Vaadake Täiustatud mälukaitse kohta lisateavet."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Seda tööprofiili hallatakse rakendusega"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Haldab <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Vaikimisi avamine"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Toetatud linkide avamine"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Luba selles rakenduses avada veebilinke"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Rakenduses avatavad lingid"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Toetatud lingid"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Muud vaike-eelistused"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Lingi lisamine"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Rakendus saab lingid üle kontrollida, et need rakenduses automaatselt avada."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# kinnitatud link}other{# kinnitatud linki}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{See link on kinnitatud ja avaneb rakenduses automaatselt.}other{Need lingid on kinnitatud ja avanevad rakenduses automaatselt.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Kuva kinnitatud linkide loend"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Muude toetatud linkide otsimine …"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Loobu"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# toetatud link}other{# toetatud linki}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Lisa"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Avaneb rakenduses <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> kasutusel (<xliff:g id="STORAGE_TYPE">%2$s</xliff:g>)"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"sisemine salvestusruum"</string>
    <string name="storage_type_external" msgid="125078274000280821">"väline salvestusruum"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> kasut. alates <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Kasutatud salvestusruum"</string>
    <string name="change" msgid="273206077375322595">"Muuda"</string>
    <string name="change_storage" msgid="8773820275624113401">"Salvestusruumi muutmine"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Märguanded"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Sees"</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">"Väljas"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategooria on välja lülitatud}other{# kategooriat on välja lülitatud}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# lisaluba}other{# lisaluba}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Lube pole antud"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Lube pole taotletud"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Rakenduste puhul andmetele juurdepääsu haldamine"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Privaatsuse juhtpaneel"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Vaadake, millised rakendused hiljuti lube kasutasid"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Kasutamata rakendused"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# kasutamata rakendus}other{# kasutamata rakendust}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Kasutamata rakenduse seaded"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Tegevusetuna rakenduse tegevuste peatamine"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Eemaldatakse load, kustutatakse ajutised failid ja peatatakse märguanded"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Kõik rakendused"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Installitud rakendused"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Installimata avat. rakendused"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Välja lülitatud"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Täpsemad"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Lubade haldur"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Andmete jagamise värskendused asukoha puhul"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Vaadake üle rakendused, mis muutsid viisi, kuidas need võivad teie asukohaandmeid jagada"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Puudutusega äratamine"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Seadme äratamiseks topeltpuudutage ekraani"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Linkide avamine"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Toetatud linke ei avata"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Domeeni <xliff:g id="DOMAIN">%s</xliff:g> avamine"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Ava domeen <xliff:g id="DOMAIN">%s</xliff:g> ja muud URL-id"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Luba rakendusel avada toetatud lingid"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Küsi iga kord"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Ära luba rakendusel avada toetatud linke"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Rakendus käsitleb väidetavalt # linki}other{Rakendus käsitleb väidetavalt # linki}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Rakendus käsitleb väidetavalt järgmisi linke:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Abirakendus ja häälsisend"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digitaalse assistendi rakendus"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Digitaalse assistendi vaikerakendus"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Nõustu"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Brauserirakendus"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Telefonirakendus"</string>
    <string name="system_app" msgid="1863291702508355041">"(Süsteem)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Rakenduste salvestusruum"</string>
    <string name="usage_access" msgid="5487993885373893282">"Juurdepääs kasutusele"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Luba juurdepääs kasutusele"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Ekraaniaeg"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Juurdepääs kasutusele võimaldab rakendusel jälgida, milliseid teisi rakendusi (ja kui sageli), operaatorit ja keeleseadeid te kasutate, ning vaadata teisi üksikasju."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Mälu"</string>
    <string name="always_running" msgid="9012705720688200252">"Töötab alati (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Töötab vahel (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Töötab harva (<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">"Aku optimeerimine"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Pole optimeeritud"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Pole optimeeritud"</string>
    <string name="high_power_off" msgid="317000444619279018">"Akukasutuse optimeerimine"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Aku optimeerimine pole saadaval"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Kas soovite lubada rakendusel pidevalt taustal töötada?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Kui lubate rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> pidevalt taustal töötada, võib see lühendada aku tööiga. \n\nSaate seda hiljem muuta jaotises Seaded &gt; Rakendused."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Kasutus alates viimasest täislaadimisest on <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> kasutust viimase 24 tunni jooksul"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Akut pole pärast viimast täislaadimist kasutatud"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Kas jagada veaaruannet?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"IT-administraator taotles veaaruannet, mis aitaks seadmes vigu otsida. Rakendusi ja andmeid võidakse jagada."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"IT-administraator taotles veaaruannet, mis aitaks seadmes vigu otsida. Rakendusi ja andmeid võidakse jagada ning see võib ajutiselt teie seadet aeglustada."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Seda veaaruannet jagatakse IT-administraatoriga. Lisateabe saamiseks võtke temaga ühendust."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Jaga"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Keeldu"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Andmeedastus puudub"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Ühendatud seadme laadimine"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Failiedastus"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Veebikaamera"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konverdi videod AVC-vormingusse"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videoid saab esitada rohkemates meediapleierites, kuid kvaliteet võib olla halvem"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB kaudu jagamine"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"USB kasutusviis"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"USB-vaikeseadistus"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Kui teine seade on ühendatud ja teie telefon avatakse, rakendatakse need seaded. Looge ühendus ainult usaldusväärsete seadmetega."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Toitevalikud"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Failiedastuse valikud"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB eelistused"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB-liidest juhib"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Ühendatud seade"</string>
    <string name="usb_control_device" msgid="527916783743021577">"See seade"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Vahetamine …"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Ei õnnestunud vahetada"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Selle seadme laadimine"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Ühendatud seadme laadimine"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Failiedastus"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB kaudu jagamine"</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">"Veebikaamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Failiedastus ja toide"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB kaudu jagamine ja toide"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP ja toide"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI ja toide"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Veebikaamera ja toide"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Taustakontroll"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Ekraanil oleva teksti kasutamine"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Abirakendusele lubatakse ekraani sisule juurdepääs tekstina"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Ekraanipildi kasutamine"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Abirakendusele lubatakse juurdepääs ekraanipildile"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Ekraani vilkumine"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Kui abirakendus pääseb ekraanil olevale tekstile või ekraanipildile juurde, vilguvad ekraani servad"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Abirakendused saavad aidata teid kuvatud ekraaniteabe alusel. Mõned rakendused toetavad integreeritud abi pakkumisel nii käivitusprogrammi kui ka häälsisendi teenuseid."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Keskmine mälukasutus"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimaalne mälukasutus"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Mälukasutus"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Rakenduse kasutamine"</string>
    <string name="memory_details" msgid="6133226869214421347">"Üksikasjad"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Viimase 3 tunni jooksul kasutati mälu keskmiselt <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Viimase 3 tunni jooksul mälu ei kasutatud"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sordi keskmise kasutuse järgi"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sordi maksimaalse kasutuse järgi"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Jõudlus"</string>
    <string name="total_memory" msgid="5244174393008910567">"Kogu mälumaht"</string>
    <string name="average_used" msgid="690235917394070169">"Keskmine kasutus (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Vaba"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Rakenduste kasutatav mälu"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 rakendus kasutas viimase {time} jooksul mälu}other{# rakendust kasutasid viimase {time} jooksul mälu}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Sagedus"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimaalne kasutus"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Andmesidet pole kasutatud"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Rakenduse <xliff:g id="APP">%1$s</xliff:g> juurdepääs funktsioonile Mitte segada"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Rakendus saab funktsiooni Mitte segada sisse/välja lülitada ja muuta sellega seotud seadeid."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Peab jääma sisselülitatud asendisse, kuna juurdepääs märguannetele on sisse lülitatud"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Kas tühistada rakenduse <xliff:g id="APP">%1$s</xliff:g> juurdepääs režiimile Mitte segada?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Kõik selle rakenduse loodud režiimi Mitte segada reeglid eemaldatakse."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ära optimeeri"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimeeri"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Aku võib kiiremini tühjeneda. Rakendusel on nüüd lubatud taustal akut kasutada."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Soovitatav aku kasutusaja pikendamiseks"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Puudub"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Selle rakenduse puhul ei takista kasutuse juurdepääsu väljalülitamine administraatoril jälgida teie tööprofiilil olevate rakenduste andmekasutust."</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Muude rakenduste peal kuvamine"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Muude rakenduste peal kuvamine"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Luba muude rakenduste peal kuvamine"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Lubage seda rakendust kuvada muude kasutatavate rakenduste peal. See rakendus näeb, kus puudutate, või saab muuta seda, mis ekraanil kuvatakse."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Juurdepääs kõikidele failidele"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Luba juurdepääs kõikide failide haldamisele"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Sellel rakendusel lubatakse lugeda, muuta ja kustutada kõiki selles seadmes ning ühendatud andmekandjatel olevaid faile. Loa andmisel võib rakendus failidele juurde pääseda ilma teie teadmata."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Pääseb failidele juurde"</string>
    <!-- no translation found for voice_activation_apps_title (7130045161611529825) -->
    <skip />
    <!-- no translation found for permit_voice_activation_apps (9152780172988949319) -->
    <skip />
    <!-- no translation found for allow_voice_activation_apps_description (6369745626995060656) -->
    <skip />
    <string name="full_screen_intent_title" msgid="747270185715224130">"Kogu ekraani katvad märguanded"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Luba selle rakenduse kogu ekraani katvad märguanded"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Lubage sellel rakendusel kuvada kogu ekraani katvaid märguandeid, kui seade on lukustatud. Rakendused võivad selle abil tõsta esile alarme, sissetulevaid kõnesid või muid pakilisi märguandeid."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Meediahalduse rakendused"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Rakendusele meedia haldamise lubamine"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Kui lubate, saab see rakendus ilma teilt luba küsimata muuta või kustutada muude rakendustega loodud meediafaile. Rakendusel peab olema failidele ja meediale juurdepääsu luba."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"meedia, fail, haldus, haldur, haldamine, muutmine, redaktor, rakendus, programm"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"VR virtuaalreaalne kuulaja stereo abiline teenus"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Muude rakenduste peal kuvamine"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Loaga rakendused"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Lubatud"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Pole lubatud"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"rakenduste installimine tundmatutest allikatest"</string>
    <string name="write_settings" msgid="6864794401614425894">"Süsteemiseadete muutmine"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"kirjuta muuda süsteemiseaded"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Saab installida teisi rakendusi"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Saab muuta süsteemiseadeid"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Saab muuta süsteemiseadeid"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Süsteemiseadete muutmine"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Luba süsteemiseadete muutmine"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Luba võimaldab rakendusel muuta süsteemiseadeid."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Luba sellest allikast"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Pöörake kaks korda kaamera avamiseks"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Avage kaamerarakendus, pöörates rannet kaks korda"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Kuvamissuurus"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Muutke kõik suuremaks või väiksemaks"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"ekraani tihedus, ekraani suum, skaala, skaleerimine"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Eelvaade"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Vähendamine"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Suurendamine"</string>
    <string name="disconnected" msgid="3469373726996129247">"Pole ühendatud"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Ühendus puudub"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Installitud on <xliff:g id="COUNT">%1$d</xliff:g> rakendust"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> on kasutatud – <xliff:g id="FREE_SPACE">%2$s</xliff:g> on vaba"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tume teema, fondi suurus, eredus"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Keskmiselt on kasutusel <xliff:g id="USED_MEMORY">%1$s</xliff:g> mälu <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>-st"</string>
    <string name="users_summary" msgid="8473589474976307510">"Sisse logitud kasutajana <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Android värskendati versioonile <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Värskendus on saadaval"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Blokeeritud töökoha reegliga"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Helitugevust ei saa muuta"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Ei saa helistada"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"SMS-e ei saa saata"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Kaamerat ei saa kasutada"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Ekraanipilte ei saa jäädvustada"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Seda rakendust ei saa avada"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokeeris teie krediidipakkuja"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Vaja on vanema abi"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Anna telefon vanemale, et ta saaks selle seadistamist alustada"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Anna telefon vanemale, et ta saaks seda seadet muuta."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Lisateabe saamiseks võtke ühendust IT-administraatoriga"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Rohkem üksikasju"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Teie administraator saab jälgida ja hallata teie tööprofiiliga seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Teie administraator saab jälgida ja hallata selle kasutajaga seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Teie administraator saab jälgida ja hallata selle seadmega seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Teie seadme administraator võib pääseda juurde selle seadmega seostatud andmetele, hallata rakendusi ja muuta selle seadme seadeid."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Lülita välja"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Lülita sisse"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Kuva"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Peida"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Kuumkoht on aktiivne"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Lennurežiim on sees"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Võrgud pole saadaval"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Režiim Mitte segada on sees"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefon on vaigistatud"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Eranditega"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Akusäästja on sisse lülitatud"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funktsioonid on piiratud"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobiilne andmeside on väljas"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet on saadaval ainult WiFi kaudu"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Andmemahu säästja"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funktsioonid on piiratud"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Tööprofiil on välja lülitatud"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Rakenduste ja märguannete puhul"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Lülita heli sisse"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Telefonihelin on vaigistatud"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Kõnede ja märguannete puhul"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Ainult vibreerimine"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Kõnede ja märguannete puhul"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Öövalguse ajakava määramine"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Ekraani toon muutub igal õhtul automaatselt"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Öövalgus on sees"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Kollase tooniga ekraanikuva"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Halltoonid"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Ainult halli värviga kuvamine"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Ahenda"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Külm värvitemperatuur"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Kasutatakse külmemaid ekraanivärve"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Värvi muutmise rakendamiseks lülitage ekraan välja"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Kaamera laserandur"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automaatsed süsteemivärskendused"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Rakenda värskendused seadme taaskäivitamisel"</string>
    <string name="usage" msgid="287782903846013936">"Kasutus"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Mobiilse andmeside kasutus"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Rakenduste andmekasutus"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"WiFi-andmekasutus"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Operaatoriväline andmekasutus"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Etherneti andmekasutus"</string>
    <string name="wifi" msgid="2932584495223243842">"WiFi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobiilset andmesidet"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> WiFi-andmeid"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> Etherneti-andmeid"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Andmekasutuse hoiatus ja piirang"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Mobiilse andmeside kasutustsükkel"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu hoiatus"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu piirang"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu hoiatus / <xliff:g id="ID_2">^2</xliff:g> – andmemahu piirang"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Ei sisalda operaatorite võrkude kasutatavat andmemahtu"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> on kasutatud"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Andmekasutuse hoiatuse määramine"</string>
    <string name="data_warning" msgid="2925054658166062884">"Andmemahu hoiatus"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Andmemahu hoiatuse ja piirangu mõõdikut jälgib teie seade. See võib erineda teie operaatori andmetest."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Andmemahupiirangu määramine"</string>
    <string name="data_limit" msgid="8731731657513652363">"Andmemahu piirang"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"Vahemikus <xliff:g id="ID_2">%2$s</xliff:g> on kasutatud <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Seadistamine"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Muud kasutusandmetesse kaasatud rakendused"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 rakendusel on lubatud kasutada piiranguteta andmemahtu, kui andmemahu säästja on sisse lülitatud}other{# rakendusel on lubatud kasutada piiranguteta andmemahtu, kui andmemahu säästja on sisse lülitatud}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Peamine andmeside"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"WiFi-andmeside"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Kasutatud on <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> üle"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Jäänud on <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graafikus on kuvatud andmekasutus kuupäevavahemikus <xliff:g id="START_DATE">%1$s</xliff:g> kuni <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Selle kuupäevavahemiku kohta pole andmeid"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Jäänud on # päev}other{Jäänud on # päeva}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Rohkem aega pole jäänud"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Jäänud on vähem kui üks päev"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Operaator <xliff:g id="ID_1">^1</xliff:g> värskendas <xliff:g id="ID_2">^2</xliff:g> tagasi"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Värskendati <xliff:g id="ID_1">^2</xliff:g> tagasi"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Operaator <xliff:g id="ID_1">^1</xliff:g> värskendas äsja"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Värskendati äsja"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Kuva üksikasjad"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Andmemahu säästja"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Piiramata andmeside"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Taustaandmed on välja lülitatud"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Sees"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Väljas"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Andmemahu säästja kasutamine"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Piiranguteta andmekasutus"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Luba piiranguteta juurdepääs andmesidele, kui andmemahu säästja on sisse lülitatud"</string>
    <string name="home_app" msgid="6056850504746902747">"Avakuva rakendus"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Lisage veel üks sõrmejälg"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Teise sõrmega avamine"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Sees"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Lülitub sisse <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> juures"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Väljas"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Rakenduse akukasutus"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Rakenduste jaoks akukasutuse määramine"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Kuva seaded"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Kontrolli"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Selge"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Kas see sõnum on kasulik?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Akunõuannete hoiatusikoon"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Lülitage aku tööea pikendamiseks sisse kohanduv eredus"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Vähendage aku tööea pikendamiseks ekraani ajalõppu"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> kasutas rohkem akut"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> kasutas tavapärasest rohkem akut"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> kasutas taustal rohkem akut"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> kasutas taustal tavapärasest rohkem akut"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> kasutas esiplaanil rohkem akut"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> kasutas esiplaanil tavapärasest rohkem akut"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Suur akukasutus"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Suur akukasutus taustal"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Suur akukasutus esiplaanil"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Piiranguteta"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimeeritud"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Piiratud"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Vaikeõigekirjakontroll"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Õigekirjakontrolli valimine"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Kasuta õigekirjakontrolli"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Pole valitud"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"võti"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupp"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(kokkuvõte)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"avalik versioon"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"tähtsus"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"selgitus"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"saab kuvada märgi"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"kavatsus"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"kustuta kavatsus"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"täisekraani kavatsus"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"toimingud"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"pealkiri"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"kaugsisestused"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"kohandatud vaade"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"lisad"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikoon"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"paki suurus"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"märguandest teavitati"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Asetuse objekt puudub."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Asetuse objekt ei sisalda seda võtit."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Ekraani väljalõige"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"ekraani väljalõige, lõige"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Seadme vaikeseade"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Ülekatet ei õnnestunud rakendada"</string>
    <string name="special_access" msgid="1767980727423395147">"Rakenduse erijuurdepääs"</string>
    <string name="special_access_more" msgid="132919514147475846">"Kuva rohkem"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Pikaajalised taustaülesanded"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Luba pikaajalised taustaülesanded"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Pikaajalised taustaülesanded"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Lubage rakendusel käitada pikaajalisi taustaülesandeid. See võimaldab rakendusel käitada ülesandeid, mis võivad võtta kauem kui mõni minut (nt alla- ja üleslaadimised). \n\nKui seda luba ei anta, võib süsteem piirata, kui kaua tohib rakendus selliseid ülesandeid taustal teha."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"pikaajalised tööd, andmeedastus, taustaülesanded"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Teenuse ShortcutManager sageduse piiramise lähtestamine"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Teenuse ShortcutManager sageduse piiramine lähtestati"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrollige lukustuskuva teavet"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Märguande sisu kuvamine või peitmine"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Nõuanded ja tugi"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Kõige väiksem laius"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Ükski installitud rakendus pole taotlenud juurdepääsu tasuliste SMS-ide saatmiseks"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Tasuliste SMS-ide saatmisel võidakse teilt nõuda tasu, mis lisatakse operaatori esitatud arvele. Kui annate rakendusele loa, saate selle rakendusega tasulisi SMS-e saata."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Juurdepääs tasuliste SMS-ide saatmiseks"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Väljas"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Ühendatud seadmega <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Ühendatud mitme seadmega"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Süsteemi kasutajaliidese demorežiim"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tume teema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Akusäästja tõttu ajutiselt suletud"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Akusäästja tõttu ajutiselt keelatud"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Lülita akusäästja välja"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Akusäästja tõttu ajutiselt sisse lülitatud"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Proovige tumedat teemat"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Aitab pikendada aku tööiga"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Arendaja kiirseadete paanid"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Keela ADB volituse ajalõpp"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Keelake ADB volituste automaatne tühistamine süsteemides, mis ei loo uuesti ühendust vaikeaja (7 päeva) või kasutaja määratud aja (vähemalt 1 päev) jooksul."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Andurid on väljas"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Tööprofiili seaded"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Otsi isiklikes rakendustes töökataloogi kontakte"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"IT-administraator võib teie otsinguid ja sissetulevaid kõnesid näha"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Profiilideülene kalender"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Kuvab tööga seotud sündmused isiklikus kalendris"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Kui töörakendused on välja lülitatud, on need peatatud, neile ei pääse juurde ja need ei saada teile märguandeid."</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Salvestusruumi haldamine"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Salvestusruumi vabastamiseks eemaldab salvestusruumi haldur varundatud fotod ja videod teie seadmest."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Fotode ja videote eemaldamine"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Salvestusruumi haldur"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Kasuta salvestusruumi haldurit"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Liigutused"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Kaamera kiire avamine"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Kaamera kiireks avamiseks vajutage toitenuppu kaks korda. See töötab igast kuvast."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Selfi tegemiseks kaamera pööramine"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Navigeerimisrežiim"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Kahe nupuga navigeerimine"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Rakenduste vahetamiseks pühkige avakuva nupul üles. Kõigi rakenduste nägemiseks pühkige uuesti üles. Tagasiliikumiseks puudutage nuppu Tagasi."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Ohutus ja hädaolukorrad"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Hädaabikõne, meditsiiniline teave, hoiatused"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Liigutustega navigeerimine"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Avakuvale liikumiseks pühkige ekraani allservast üles. Rakenduste vahetamiseks pühkige allservast üles, hoidke sõrme paigal ja tõstke see üles. Tagasiliikumiseks pühkige ekraani vasakust või paremast servast."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Kolme nupuga navigeerimine"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Liikuge tagasi või avakuvale ja vahetage rakendusi ekraani allosas olevate nuppude abil."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"süsteemis navigeerimine, kahe nupuga navigeerimine, kolme nupuga navigeerimine, liigutustega navigeerimine, pühkimine"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitaalne assistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Assistendi käivitamiseks pühkimine"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Pühkige ekraanikuva alanurgast üles, et digitaalse assistendi rakendus käivitada."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Assistendi kasutamiseks nupu Avakuva allhoidmine"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Vajutage avakuva nuppu pikalt, et digitaalse assistendi rakendus käivitada."</string>
    <string name="low_label" msgid="6525629096999711220">"Väike"</string>
    <string name="high_label" msgid="357503396626018487">"Suur"</string>
    <string name="left_edge" msgid="1513576842959071849">"Vasak serv"</string>
    <string name="right_edge" msgid="1505309103265829121">"Parem serv"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Suurem tundlikkus võib ekraani servades mõne rakenduse liigutusega vastuolus olla."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Tagasiliigutuse tundlikkus"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Liigutustega navigeerimise tundlikkus"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Nupuga navigeerimine"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"liigutustega navigeerimine, tagasiliigutuse tundlikkus, tagasiliigutus"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigeerimine, avakuva nupp"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Ühekäerežiim"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Kasuta ühekäerežiimi"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Ühekäerežiimi otsetee"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"ühe käega kasutamine"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Pühkige alla, et teha järgmist"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Kasuta otseteed järgmiseks:"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Tõmmake ekraanikuva ülemine pool alla, et ühe käega oleks lihtsam ulatuda"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Kuidas kasutada ühekäerežiimi?"</b>\n" • Veenduge, et süsteemi navigeerimisseadetes oleks valitud liigutustega navigeerimine.\n • Pühkige ekraanikuva alumises servas alla."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Ekraanikuva tõmbamine ulatusse"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Ekraanikuva ülaosa teisaldatakse teie pöidla ulatusse."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Märguannete kuvamine"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Kuvatakse märguanded ja seaded."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Kellaaja, märguannete ja muu teabe vaatamiseks topeltpuudutage oma ekraani."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Ekraani äratamine"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Kellaaja, märguannete ja muu teabe vaatamiseks puudutage ekraani."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Hädaabikõne"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Hädaabikõne kasutamine"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Vajutage toitenuppu kiiresti viis või enam korda, et käivitada alltoodud toimingud"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Loendusalarmi esitamine"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Esita hädaabikõne alustamisel vali heli"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Teavitamine abi saamiseks"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Helistamine abi saamiseks"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Number abi kutsumiseks"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Puudutage muutmiseks."</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Kui sisestate numbri, mis pole hädaabinumber:\n • Teie telefon peab hädaabikõne tegemiseks olema avatud.\n • Teie kõnele ei pruugita vastata."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Märguannete kuvamiseks sõrmejälje pühkimine"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Sõrmejälje pühkimine"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Kiiresti märguannete vaatamine"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Sees"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Väljas"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Buudilaadur on juba avatud"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Looge Interneti-ühendus või võtke ühendust operaatoriga"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Ei ole operaatori lukustatud seadmetes saadaval"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Seadme kaitsefunktsiooni lubamiseks taaskäivitage seade."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Kokku vabastati <xliff:g id="SIZE">%1$s</xliff:g> ruumi\n\nViimati käitati kuupäeval <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Installimata avatavad rakendused"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Lingid avatakse rakendustes isegi siis, kui need pole installitud"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Installimata avatavad rakendused"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Installimata avatavate rakenduste eelistused"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Installitud rakendused"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Teie salvestusruumi haldab nüüd salvestusruumi haldur"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Kasutaja <xliff:g id="USER_NAME">%1$s</xliff:g> kontod"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Rakenduste andmete automaatne sünkroonimine"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Luba rakendustel andmeid automaatselt värskendada"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Konto sünkroonimine"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sünkroonimine on sisse lülitatud <xliff:g id="ID_1">%1$d</xliff:g> üksuse jaoks <xliff:g id="ID_2">%2$d</xliff:g>-st"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sünkroonimine on kõigi üksuste jaoks sisse lülitatud"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sünkroonimine on kõigi üksuste jaoks välja lülitatud"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Hallatava seadme teave"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Teie organisatsiooni hallatavad muudatused ja seaded"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Organisatsiooni <xliff:g id="ORGANIZATION_NAME">%s</xliff:g> hallatavad muudatused ja seaded"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Teie tööandmetele juurdepääsu andmiseks võib teie organisatsioon muuta seadeid ja installida seadmesse tarkvara. \n\nLisateabe saamiseks võtke ühendust organisatsiooni administraatoriga."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Teie organisatsiooni nähtava teabe tüübid"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Teie organisatsiooni administraatori tehtud muudatused"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Teie juurdepääs sellele seadmele"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Teie töökontoga seotud andmed, nt e-post ja kalender"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Teie seadmes olevate rakenduste loend"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Iga rakenduse kasutamise aeg ja kasutatud andmemaht"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Uusim võrguliikluse logi"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Kõige viimane veaaruanne"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Kõige viimane turvalogi"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Puudub"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Installitud rakendused"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Rakenduste arv on hinnanguline. See ei pruugi hõlmata muudest allikatest kui Play poest installitud rakendusi."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Vähemalt # rakendus}other{Vähemalt # rakendust}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Asukohale juurdepääsu load"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Mikrofoni load"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Kaamera load"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Vaikerakendused"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# rakendus}other{# rakendust}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Vaikeklaviatuur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Määratud valikule <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Alati sees VPN on sisse lülitatud"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Alati sees VPN on teie isiklikul profiilil sisse lülitatud"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Alati sees VPN on teie tööprofiilil sisse lülitatud"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Üldine HTTP-puhverserver on seadistatud"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Usaldusväärsed mandaadid"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Usaldusväärsed mandaadid teie isiklikul profiilil"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Usaldusväärsed mandaadid teie tööprofiilil"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Vähemalt # CA-sertifikaat}other{Vähemalt # CA-sertifikaati}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administraator saab seadme lukustada ja parooli lähtestada"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administraator saab kustutada kõik seadme andmed"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Parooli sisestamise ebaõnnestunud katsete arv enne seadmes olevate kõigi andmete kustutamist"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Parooli sisestamise ebaõnnestunud katsete arv enne tööprofiilil olevate andmete kustutamist"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# katse}other{# katset}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Seda seadet haldab teie organisatsioon."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Seda seadet haldab <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">"Lisateave"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Piiratud seade"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Piiratud seaded on rakenduse <xliff:g id="APP_NAME">%s</xliff:g> jaoks lubatud"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Teie turvalisuse huvides pole see seade praegu saadaval."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Järelmaksuga seadme teave"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Teie krediidipakkuja saab seadistamise ajal teie seadeid muuta ja seadmesse tarkvara installida.\n\nKui makse jääb tegemata, võib krediidipakkuja teie seadme lukustada ja selle seadeid muuta.\n\nLisateabe saamiseks võtke ühendust krediidipakkujaga."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Kui teie seadet rahastatakse, ei saa te teha järgmist."</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Rakenduste installimine väljastpoolt Play poodi"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Seadme taaskäivitamine turvarežiimis"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Seadmesse mitme kasutaja lisamine"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Kuupäeva, kellaaja ja ajavööndi muutmine"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Arendaja valikute kasutamine"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Krediidipakkuja saab teha järgmist."</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Juurdepääs teie IMEI-numbrile"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Seadme lähtestamine tehaseseadetele, kui midagi läheb valesti"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Kui seade on lukustatud, saate seda kasutada ainult järgmiseks."</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Hädaabikõnede tegemine"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Süsteemiteabe (nt kuupäeva, kellaaja, võrgu oleku ja aku taseme) vaatamine"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Seadme sisse- või väljalülitamine"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Märguannete ja tekstsõnumite vaatamine"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Juurdepääs rakendustele, mille krediidipakkuja on lubanud"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Kui maksate täissumma, toimub järgmine."</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Seadmest eemaldatakse kõik piirangud"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Saate krediidipakkuja rakenduse desinstallida"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Järelmaksuga seadme teave"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Kaamerarakendus}other{Kaamerarakendused}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalendrirakendus"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Rakendus Kontaktid"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{E-posti kliendi rakendus}other{E-posti kliendi rakendused}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Kaardirakendus"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Telefonirakendus}other{Telefonirakendused}}"</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">"See seade"</string>
    <string name="storage_games" msgid="1176568610086802469">"Mängud"</string>
    <string name="storage_files" msgid="7968460921272772299">"Failid"</string>
    <string name="storage_images" msgid="2055893015567979387">"Pildid"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videod"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Heli"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Rakendused"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumendid ja muu"</string>
    <string name="storage_system" msgid="8472410119822911844">"Süsteem"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Prügikast"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Kas tühjendada prügikast?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Prügikastis on <xliff:g id="TOTAL">%1$s</xliff:g> faili. Kõik üksused kustutatakse jäädavalt ja te ei saa neid taastada."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Prügikast on tühi"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Tühjenda prügikast"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Kasutatud on <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Kokku <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">"Kustuta rakendus"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Kas soovite selle installimata avatava rakenduse eemaldada?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Ava"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Mängud"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Kasutatav ruum"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(desinstall. kasutaja <xliff:g id="USER">%s</xliff:g> jaoks)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(keelatud kasutaja <xliff:g id="USER">%s</xliff:g> jaoks)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Automaattäite teenus"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Automaattäite vaiketeenus"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Paroolid"</string>
    <string name="credman_chosen_app_title" msgid="872524130208251505">"Paroolid, pääsuvõtmed ja andmesideteenused"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Lisapakkujad"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# parool}other{# parooli}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automaatne, täitmine, automaattäide, parool"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"andmesideteenus, pääsuvõti, parool"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automaatne, täitmine, automaattäide, andmed, pääsuvõti, parool"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Veenduge, et rakendus oleks usaldusväärne&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google\'i automaatne täitmine&gt;%1$s&lt;/xliff:g&gt; kasutab automaatse täitmise sisestuse määramiseks ekraanil kuvatut."</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; Uued paroolid, pääsuvõtmed ja muu teave salvestatakse edaspidi siia. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; võib kasutada teie ekraanil kuvatut, et otsustada, millise osa saab automaatselt täita."</string>
    <string name="credman_picker_title" msgid="8191267620665129205">"Paroolid, pääsuvõtmed ja andmesideteenused"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Kas lülitada %1$s välja?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Kas lülitada see teenus välja?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Salvestatud teavet, nagu paroolid, pääsuvõtmed, makseviisid ja muu teave, sisselogimisel ei täideta. Salvestatud teabe kasutamiseks valige üks paroolide, pääsuvõtmete või andmete talletamise teenus."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Kas kasutada teenust %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s kasutab ekraanil kuvatut, et otsustada, mida saab automaatselt täita."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Paroolide, pääsuvõtmete ja andmesideteenuste piirang"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"Korraga saavad aktiivsed olla kuni 5 parooli, pääsuvõtit ja andmesideteenust. Teenuse lisamiseks lülitage mõni olemasolev välja."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Lülita välja"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automaattäide"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Logimistase"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Max taotluste arv seansi kohta"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Max nähtavate andmekomplektide arv"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Vaikeväärtustele lähtestamine"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Arendaja automaattäite valikud on lähtestatud"</string>
    <string name="location_category" msgid="3496759112306219062">"Asukoht"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Olekuriba asukohanäidik"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Kuva kõikide asukohtade puhul (sh võrk ja ühenduvus)"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Jõusta GNSS-i täielikud mõõtmistulemused"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Jälgi kõiki GNSS-i radu ja sagedusi ilma töötsüklita"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Sisestusmeetod"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Elektronpliiatsiga kirjutamine"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Kui see on lubatud, saab praeguse sisestusmeetodiga kasutada elektronpliiatsi üksust MotionEvent, kui redaktor on esile tõstetud."</string>
    <string name="device_theme" msgid="5027604586494772471">"Seadme teema"</string>
    <string name="default_theme" msgid="4815428567082263639">"Vaikeseade"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Võrgu nimi"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Võrgu nimi kuvatakse olekuribal"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Installimata avatav rakendus"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Kas soovite salvestusruumi halduri välja lülitada?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Värskendage režiimi Mitte segada"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Keskendumiseks peatage märguanded"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funktsioon pole saadaval"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"See funktsioon on välja lülitatud, kuna see muudab teie telefoni aeglaseks"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Kuva alati kokkujooksmise dialoog"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Dialoog kuvatakse alati, kui rakendus kokku jookseb"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Valige rakendus, milles ANGLE on lubatud"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Seadistatud pole ühtegi rakendust, milles ANGLE on lubatud"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Rakendus, milles ANGLE on lubatud: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Graafikadraiveri eelistused"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Graafikadraiveri seadete muutmine"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kui graafikadraivereid on mitu, saate seadmesse installitud rakenduste puhul soovi korral kasutada värskendatud graafikadraiverit."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Luba kõigi rakenduste puhul"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Graafikadraiveri valimine"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Vaikeseade"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Mängudraiver"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Arendaja draiver"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Süsteemi graafikadraiver"</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">"Katseline: ANGLE-i lubamine"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Hoiatus: selle seadega lubate ANGLE-i OpenGL ES-i vaikedraiverina. See funktsioon on katseline ning ei pruugi mõne kaamera- ja videorakendusega ühilduda."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Süsteemi OpenGL ES-i draiveri muutmiseks on vajalik taaskäivitamine"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Rakenduste ühilduvuse muudatused"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Rakenduse ühilduvuse muudatuste lüliti"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Vaikimisi lubatud rakenduste muudatused"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Vaikimisi keelatud rakenduste muudatused"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Rakenduse ühilduvuse muudatusi saab muuta silutavate rakenduste puhul. Installige silutav rakendus ja proovige uuesti."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Oleneb teisest seadest"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Konto"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"%d kontot"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Seadme nimi"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Põhiteave"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Juriidiline ja regulatiivteave"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Seadme üksikasjad"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Seadme identifikaatorid"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"WiFi-seadete juhtimine"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Luba rakendusel juhtida WiFi-t"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Lubage sellel rakendusel WiFi sisse või välja lülitada, otsida WiFi-võrke ja nendega ühendus luua, võrke lisada või eemaldada või luua kohalik kuumkoht."</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Käivitamine NFC kaudu"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Luba käivitamine NFC skannimisel"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Lubage see rakendus käivitada, kui skannitakse NFC-kiip.\nKui see luba on sisse lülitatud, on rakendus kiibi tuvastamisel valikuna saadaval."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Meedia esitamise seade:"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Esita rakendust <xliff:g id="LABEL">%s</xliff:g> väljundis"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"See seade"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Pole kõnede ajal saadaval"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Vasta kõnele seadmes"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Seda APN-i ei saa muuta."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Helisemise vältimine"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Korraga toitenupu ja helitugevuse suurendamise nupu vajutamine:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Otsetee helisemise vältimiseks"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibreeri"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Vaigista"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibreerimine"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Vaigistamine"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Lubamiseks muutke esmalt toitemenüüs valikut „Toitenupu pikalt vajutamine“."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Võrgu üksikasjad"</string>
    <string name="devices_title" msgid="649715719278562515">"Seadmed"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Võrgu valimine"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Ühendus on katkestatud"</string>
    <string name="network_connected" msgid="7637745547242487795">"Ühendatud"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Ühendamine …"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Ühendust ei saanud luua"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Võrke ei leitud."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Võrke ei õnnestunud leida. Proovige uuesti."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(keelatud)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM-kaart"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"SIM-i pole"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Pole"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Ühendamiseks on vaja SIM-kaarti"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Ühendamiseks on vaja operaatori <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> SIM-kaarti"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Eelistatud võrgurežiim: eelistatud WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Eelistatud võrgurežiim: ainult GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Eelistatud võrgurežiim: ainult WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Eelistatud võrgurežiim: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Eelistatud võrgurežiim: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Eelistatud võrgurežiim: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Eelistatud võrgurežiim: ainult CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Eelistatud võrgurežiim: ainult EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Eelistatud võrgurežiim: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Eelistatud võrgurežiim: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Eelistatud võrgurežiim: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Eelistatud võrgurežiim: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Eelistatud võrgurežiim: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Eelistatud võrgurežiim: üldine"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Eelistatud võrgurežiim: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Eelistatud võrgurežiim: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Eelistatud võrgurežiim: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Eelistatud võrgurežiim: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Eelistatud võrgurežiim: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Eelistatud võrgurežiim: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Eelistatud võrgurežiim: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Eelistatud võrgurežiim: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Eelistatud võrgurežiim: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Eelistatud võrgurežiim: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Eelistatud võrgurežiim: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Eelistatud võrgurežiim: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Eelistatud võrgurežiim: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Eelistatud võrgurežiim: ainult NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Eelistatud võrgurežiim: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Eelistatud võrgurežiim: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Eelistatud võrgurežiim: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Eelistatud võrgurežiim: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Eelistatud võrgurežiim: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (soovitatav)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (soovitatav)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (soovitatav)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Vali võrk automaatselt"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Operaatori seaded"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Andmesideteenuse seadistamine"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobiilne andmeside"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Andmesideühendus mobiilsidevõrgu abil"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefon aktiveerib levialasse jõudmisel selle operaatori automaatselt"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Ühtegi SIM-i pole saadaval"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Kõnede eelistus"</string>
    <string name="sms_preference" msgid="7742964962568219351">"SMS-i eelistus"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Küsi iga kord"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Võrgu lisamine"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Kõnede puhul vaikeseade"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"SMS-ide puhul vaikeseade"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Kõnede ja SMS-ide puhul vaikeseade"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Mobiilse andmeside puhul vaikeseade"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobiilne andmeside on aktiivne"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobiilne andmeside on väljas"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Saadaval"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"SIM-i lisamine"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktiivne / SIM-kaart"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inaktiivne / SIM-kaart"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktiivne/eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Mitteaktiivne/eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"SIMi nimi ja värv"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Nimi"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Värv (kasutavad ühilduvad rakendused)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Salvesta"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Kasuta SIMi"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Väljas"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Selle SIM-i keelamiseks eemaldage SIM-kaart"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Puudutage operaatori <xliff:g id="CARRIER">%1$s</xliff:g> aktiveerimiseks"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Kustuta SIM-kaart"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Eelistatud võrgutüüp"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Võrgu töörežiimi muutmine"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Eelistatud võrgutüüp"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Operaatori seadete versioon"</string>
    <string name="call_category" msgid="641461844504128789">"Helistamine"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Operaatori videokõne"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Süsteemi valimine"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"CDMA-rändlusrežiimi muutmine"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Süsteemi valimine"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Võrk"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA-tellimus"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"RUIM/SIM-i ja NV vahetamine"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"tellimus"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automaatne registreerimine …"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Kas lubada andmesiderändlus?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Hinnakirja küsige oma võrguteenuse pakkujalt."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Rakenduste andmekasutus"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Võrgu režiim <xliff:g id="NETWORKMODEID">%1$d</xliff:g> on sobimatu. Eirake seda."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Pääsupunktide nimed"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Pole saadaval, kui on ühendus on loodud operaatoriga <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Kuva rohkem"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Kas lülitada operaator <xliff:g id="CARRIER_NAME">%1$s</xliff:g> sisse?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Kas lülitada SIM-kaart sisse?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Kas soovite aktiveerida operaatori <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Kas aktiveerida SIM-kaardi kasutamine?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Kas kasutada operaatorit <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Korraga saab aktiivne olla vaid üks SIM.\n\nOperaatori <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> aktiveerimisel ei tühistata operaatori <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> teenust."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Korraga saab aktiivne olla vaid üks eSIM.\n\nOperaatori <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> aktiveerimisel ei tühistata operaatori <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> teenust."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Korraga saab aktiivne olla vaid üks SIM.\n\nAktiveerimine ei tühista operaatori <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> teenust."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Saate korraga kasutada kahte SIM-i. Operaatori <xliff:g id="CARRIER_NAME">%1$s</xliff:g> kasutamiseks lülitage teine SIM välja."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Aktiveeri operaator <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">"Lülita <xliff:g id="CARRIER_NAME">%1$s</xliff:g> välja"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"SIM-i väljalülitamine ei tühista teenust"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Võrguga ühendamine …"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Kõnede ja sõnumite puhul lülitutakse operaatorile <xliff:g id="CARRIER_NAME">%1$s</xliff:g> …"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Operaatorit ei saa vahetada"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Operaatorit ei saa vea tõttu vahetada."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Kas lülitada <xliff:g id="CARRIER_NAME">%1$s</xliff:g> välja?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Kas lülitada SIM-kaart välja?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"SIM-kaardi väljalülitamine <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Operaatorit ei saa keelata"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Midagi läks valesti ja teie operaatorit ei saanud keelata."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Kas kasutada kahte SIMi?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Selles seadmes saavad korraga aktiivsed olla kaks SIMi. Korraga ühe SIMi kasutamise jätkamiseks puudutage valikut „Tänan, ei”."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Kas soovite seadme taaskäivitada?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Jah"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Taaskäivita"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Tänan, ei"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Loobu"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Vaheta"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Lülita välja"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"SIM-kaarti ei saa aktiveerida"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Lülitage SIM-kaart uuesti sisse. Kui probleem jätkub, taaskäivitage seade."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Võrgu aktiveerimine"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Operaatori vahetamine"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> on aktiivne"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Puudutage SIM-kaardi seadete värskendamiseks"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Lülituti operaatorile <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Lülituti teisele operaatorile"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Teie mobiilsidevõrku on muudetud"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Teise SIM-kaardi seadistamine"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Valige aktiivne SIM-kaart või kasutage korraga kahte SIM-kaarti"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Kasutatava numbri valimine"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Selles seadmes on saadaval 1 number, kuid korraga saab kasutada vaid üht}=2{Selles seadmes on saadaval 2 numbrit, kuid korraga saab kasutada vaid üht}other{Selles seadmes on saadaval # numbrit, kuid korraga saab kasutada vaid üht}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Aktiveerimine <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Praegu ei saa aktiveerida"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Kas kasutada operaatorit <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"Mobiilse andmeside, kõnede ja SMS-ide jaoks kasutatakse operaatorit <xliff:g id="CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Aktiivseid SIMe pole saadaval"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Avage oma võrguseaded, et hiljem mobiilset andmesidet, kõnefunktsioone ja SMS-e kasutada."</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Kas soovite selle eSIM-i kustutada?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"SIMi kustutamisel eemaldatakse seadmest operaatori <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> teenus.\n\nOperaatori <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> teenust ei tühistata."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Kustuta"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"SIM-kaardi kustutamine …"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"SIM-kaarti ei saa kustutada"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Seda SIM-kaarti ei saa vea tõttu kustutada.\n\nTaaskäivitage seade ja proovige uuesti."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Seadmega ühendamine"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Rakendus <xliff:g id="APPNAME">%1$s</xliff:g> soovib kasutada ajutist WiFi-võrku, et teie seadmega ühendus luua"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Seadmeid ei leitud. Veenduge, et seadmed oleksid sisse lülitatud ja ühendamiseks saadaval."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Proovi uuesti"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Midagi tuli vahele. Rakendus tühistas seadme valimise taotluse."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Ühendamine õnnestus"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Ühendamine ebaõnnestus"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Kuva kõik"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Seadme otsimine …"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Seadmega ühendamine …"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Vasak"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Parem"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Ümbris"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Seadete paneel"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Jõusta töölauarežiim"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Katselise töölauarežiimi jõustamine teisestel ekraanidel"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Luba fikseeritud suurus mitmes aknas"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Lubab fikseeritud suurusega rakenduste kuvamise mitmes aknas"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Alista funktsioon Sunnitud tume"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Alistab alaliselt sisselülitatud funktsiooni Sunnitud tume"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privaatsus"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Load, kontotegevused, isiklikud andmed"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Juhtelemendid"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Eemalda"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Säilita"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Kas eemaldada see soovitus?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Mäluruumi on vähe. <xliff:g id="PERCENTAGE">%1$s</xliff:g> kasutusel / <xliff:g id="FREE_SPACE">%2$s</xliff:g> vaba"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Saada tagasisidet"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Kas soovite selle soovituse kohta tagasisidet anda?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> on lõikelauale kopeeritud."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Juurdepääsetavuse kasutus"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 rakendusel on täielik juurdepääs teie seadmele}other{# rakendusel on täielik juurdepääs teie seadmele}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Oluline teave"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"JÄTKA"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"EI, TÄNAN"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Asukoht"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Kui kasutate seda teenust hädaabikõnedeks, võib operaator koguda teavet teie asukoha kohta.\n\nLisateavet leiate oma operaatori privaatsuseeskirjadest."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Järelejäänud aeg või andmemaht võib kaotsi minna. Enne eemaldamist pidage nõu operaatoriga."</string>
    <string name="content_capture" msgid="868372905432812238">"Rakenduse sisu"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Luba rakendustel Android-süsteemile sisu saata"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Süsteemi mälutõmmise jäädvustamine"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Mälu märgendamise laiend"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Mälu märgendamise laiend (MTE) hõlbustab teie rakenduses mäluturbega seotud probleemide leidmist ja muudab rakenduse omakoodi turvalisemaks."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"MTE sisselülitamine võib seadme toimivust aeglustada."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Lisateave MTE kohta"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Luba MTE kuni selle väljalülitamiseni"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"MTE sisselülitamiseks peate oma seadme taaskäivitama."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"MTE väljalülitamiseks peate oma seadme taaskäivitama."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Luba MTE ühe seansi puhul"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Süsteem taaskäivitub ja lubab katsetamise mälu märgendamise laiendiga (MTE). MTE võib süsteemi toimivusele ja stabiilsusele halvasti mõjuda. See lähtestatakse järgmisel taaskäivitamisel."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Taaskäivitage lubatud MTE-ga ühe seansi puhul"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE on juba lubatud"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Süsteemi mälutõmmise jäädvustamine"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Süsteemi mälutõmmist ei saanud jäädvustada"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Jäädvusta süsteemi mälutõmmised automaatselt"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Jäädvusta mälutõmmis automaatselt, kui Androidi süsteem kasutab liiga palju mälu"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Katkesta ühendus"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Hädaabikõned"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Teie operaator ei toeta hädaabikõnesid WiFi-kõnede kaudu.\nSeade lülitub hädaabikõne tegemiseks automaatselt mobiilsidevõrgule.\nHädaabikõned on võimalikud ainult mobiilsidevõrgu levialas."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Kvaliteedi parandamiseks kasutage kõnede puhul WiFi-t"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Sissetulev MMS-sõnum"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"MMS-i ei saa saata"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Puudutage, et lubada MMS-sõnumside operaatori <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> võrgus, kui mobiilne andmeside on välja lülitatud"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS-sõnum"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Probleem SIM-kombinatsiooniga"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Operaatorite <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> kasutamine võib piirata funktsionaalsust. Puudutage lisateabe saamiseks."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM-kombinatsioon"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Teie tööeeskirjade teave"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Seadeid haldab teie IT-administraator"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Veaaruannete töötleja"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Määrab, milline rakendus kasutab teie seadmes veaaruannete otseteed."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Isiklik"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Töö"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Süsteemi vaikeseade"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Pole"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"See valik ei kehti enam. Proovige uuesti."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Pikalt toitenupu vajutamine"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Juurdepääsemiseks vajutage pikalt toitenuppu"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Toitemenüü"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitaalne assistent"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Juurdepääs digitaalsele assistendile"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Juurdepääs toitemenüüle"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Kasutamiseks määrake kõigepealt ekraanilukk"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Toitemenüü:\nvajutage korraga toitenuppu ja helitugevuse suurendamise nuppu"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Helisemise vältimine:\notsetee kasutamiseks vajutage helitugevuse nuppu"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Allhoidmise kestus"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Tundlikkuse reguleerimiseks valige kui pikalt toitenuppu all hoida"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Lühike"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Pikk"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Kuva rahakott"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Rahakotile juurdepääsu lubamine lukustuskuvalt"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Kuva QR-koodi skanner"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Lubage lukustuskuval juurdepääs QR-koodi skannerile"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Kuva seadmete juhtimisvidinad"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Lukustuskuvalt"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Seadme juhtelementide kasutamine"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Kasutamiseks lülitage esmalt sisse valik „Kuva seadme juhtimisvidinad“"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Kella suurus muutub olenevalt lukustuskuva sisust"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dünaamiline kell"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Otseteed"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <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">"Kas lülitada VoLTE välja?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"See lülitab välja ka teie 5G-ühenduse.\nTe ei saa häälkõne ajal internetti kasutada ja mõni rakendus ei pruugi töötada."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Vahemälus olevate rakenduste täitmise peatamine"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Ei aegu kunagi."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Rentimine ei aegu kunagi."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Luba Seadetes ekraani ülekatted"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Lubage rakendustel, mida tohib kuvada teiste rakenduste peal, katta Seadete ekraanikuvasid"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Luba matkitud modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Lubab sellel seadmel käitada matkitud modemi teenust instrumentide testimiseks. Ärge lubage seda telefoni tavapärase kasutuse ajal."</string>
    <string name="media_controls_title" msgid="403271085636252597">"Meedia"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Meediapleieri kinnitamine"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Kiirelt taasesituse jätkamiseks jääb meediapleier kiirseadetes avatuks"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Kuva meedia lukustuskuval"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Kiirelt taasesituse jätkamiseks jääb meediapleier lukustuskuval avatuks"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Kuva meediasoovitusi"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Teie tegevuse põhjal"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Peida pleier"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Kuva pleier"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"meedia"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth lülitub sisse"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM-id"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Kõned ja SMS-id"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"WiFi-kõned"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Helistamine WiFi kaudu"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Kõned"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"eelistatud"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"eelistatud kõnede puhul"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"eelistatud SMS-ide puhul"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"pole saadaval"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Pole ajutiselt saadaval"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"SIM-i pole"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Võrgueelistused"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"võrguühendus, internet, juhtmeta, andmeside, wifi, wi-fi, wi fi, mobiilside, mobiilsideoperaator, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Kas lähtestada internetiühendus?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Internetiühenduse lähtestamine …"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Ühenduvuse parandamine"</string>
    <string name="networks_available" msgid="3299512933684383474">"Võrgud on saadaval"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Võrkude vahetamiseks katkestage Etherneti-ühendus"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+ ühendused"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Luba Google Fil kasutada W+ võrke, et kiirust ja katvust parandada"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+ võrk"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM-kaart"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIM-id"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Aktiivne"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Mitteaktiivne"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / vaikevalik üksus(t)e <xliff:g id="ID_1">%1$s</xliff:g> puhul"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"kõned"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobiilne andmeside"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Seadme kasutuskogemuse parandamiseks võivad rakendused ja teenused siiski alati otsida WiFi-võrke isegi siis, kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Seda saab muuta WiFi-skannimise seadetes."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Muutmine"</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">"Ühendatud"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Ajutiselt ühendatud"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Ajutiselt kasutatakse operaatorit <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Ühendus puudub"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobiilset andmesideühendust ei looda automaatselt"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Kas lülitada mobiilne andmeside välja?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Pärast seda pole teil operaatori <xliff:g id="CARRIER">%s</xliff:g> kaudu juurdepääsu andmesidele ega internetile. Internet on saadaval ainult WiFi kaudu."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"teie operaator"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Teie organisatsioon pole seda lubanud"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Pole saadaval, kuna uneaja režiim on sisse lülitatud"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Märguande olulisuse lähtestamine viidi lõpule."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Rakendused"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Seade soovib saada juurdepääsu teie sõnumitele. Puudutage üksikasjade nägemiseks."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Kas lubada juurdepääs sõnumitele?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Bluetooth-seade <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib saada juurdepääsu teie sõnumitele.\n\nTe pole seadmega <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> varem ühendust loonud."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Seade soovib juurdepääsu teie kontaktidele ja kõnelogile. Puudutage üksikasjade nägemiseks."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Kas lubada juurdepääs kontaktidele ja kõnelogile?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Bluetooth-seade <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib juurdepääsu teie kontaktidele ja kõnelogile. See hõlmab andmeid sissetulevate ja väljuvate kõnede kohta.\n\nTe pole seadmega <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> varem ühendust loonud."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Eredus"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Ekraanikuva lukustamine"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Ilme"</string>
    <string name="category_name_color" msgid="937514550918977151">"Värv"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Muud ekraanikuva juhtelemendid"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Üldine"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Kasuta tumedat teemat"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Bluetoothi kasutamine"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Helisemise vältimise kasutamine"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"WiFi-kuumkoha kasutamine"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Rakenduse kinnitamise kasutamine"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Kasuta arendaja valikuid"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Printimisteenuse kasutamine"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Luba mitu kasutajat"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"luba, lubamine, mitu, kasutaja, kasutajat"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Juhtmevaba silumise kasutamine"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Graafikadraiveri eelistuste kasutamine"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Kasuta öövalgust"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"NFC kasutamine"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Kasuta kohanduvat eredust"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"WiFi-kõnede kasutamine"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Kuva kõik rakendused"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Nutikas suunamine"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Nutikas suunamine on lubatud"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Nutikas suunamine on keelatud"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Kõne seaded"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Seadete värskendamine …"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Kõneseadete viga"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Võrgu või SIM-i viga."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM-kaart pole aktiveeritud."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Sisestage telefoninumbrid"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Sisestage telefoninumber"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Telefoninumber puudub."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Luba 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G on vähem turvaline, kuid võib mõnes asukohas parandada ühendust. Hädaabikõnede puhul on 2G alati lubatud."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> nõuab 2G-d"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Nõua krüpteerimist"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Krüpteerimine on turvalisem, kuid mõnes asukohas ei pruugi ühendamine olla võimalik, Hädaabikõnede jaoks ei nõuta krüpteerimist kunagi."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Kõik teenused"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Kuva juurdepääs lõikelauale"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Kui rakendused pääsevad juurde kopeeritud tekstile, piltidele või muule sisule, kuvatakse teade"</string>
    <string name="all_apps" msgid="3054120149509114789">"Kõik rakendused"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Ära luba"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ülilairibaühendus"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Aitab tuvastada läheduses olevate ülilairibaühendust kasutavate seadmete suhtelist asukohta"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Ülilairibaühenduse kasutamiseks lülitage lennukirežiim välja."</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB pole praeguses asukohas saadaval."</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Juurdepääs kaamerale"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Juurdepääs mikrofonile"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Rakenduste ja teenuste jaoks"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Rakenduste ja teenuste jaoks. Isegi kui see seade on välja lülitatud, võidakse mikrofoni andmeid siiski jagada hädaabinumbrile helistades."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Eelmine"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Järgmine"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Värvi eelvaade"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"SIM-ile juurdepääsemise taotlus"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Seade soovib teie SIM-ile juurde pääseda. Puudutage üksikasjade nägemiseks."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Kas lubada juurdepääs SIM-ile?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Bluetooth-seade <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib teie SIM-i andmetele juurde pääseda. Need andmed hõlmavad teie kontakte.\n\nKui seade <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> on ühendatud, saab sellega vastu võtta kõik kõned, mis tehakse numbrile <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Bluetooth-seade on saadaval"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Seade soovib ühendust luua. Puudutage üksikasjade nägemiseks."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Kas ühendada Bluetooth-seadmega?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib selle telefoniga ühendust luua.\n\nTe pole seadmega <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> varem ühendust loonud."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Ära ühenda"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Ühenda"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE seaded"</string>
    <string name="tare_on" msgid="2386073225978684535">"Sees"</string>
    <string name="tare_off" msgid="6305694402929756726">"Väljas"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Taasta vaikeseaded"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Taastati vaikeseaded."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Max täislaetud aku saldo"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldod"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Tarbimispiirangud"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Esialgne tarbimispiirang"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimaalne tarbimispiirang"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maksimaalne tarbimispiirang"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Muutujad"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Toimingud (tegemise hind)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Toimingud (baashind)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Preemiaid ühe sündmuse kohta"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Preemiaid sekundis sündmuse jooksul"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maksimaalne preemiate arv päevas"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Rakenduse installimine"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Tipptegevus"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Märguannet vaadati"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Märguannet vaadati 15 minuti jooksul"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Märguande interaktsioon"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Vidina interaktsioon"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Muu kasutaja interaktsioon"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Max prioriteediga töö käivitamine"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Max prioriteediga töö käitamine"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Kõrge prioriteediga töö käivitamine"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Kõrge prioriteediga töö käitamine"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Vaikeprioriteediga töö käivitamine"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Vaikeprioriteediga töö käitamine"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Madala prioriteediga töö käivitamine"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Madala prioriteediga töö käitamine"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Min prioriteediga töö käivitamine"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Min prioriteediga töö käitamine"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Töö ajalõpu karistus"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimaalne täislaetud aku saldo (välistatud)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimaalne täislaetud aku saldo (kasutajaliideseta süsteemirakendus)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimaalne täislaetud aku saldo (ülejäänud rakendused)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Minimaalne täislaetud aku saldo lisa (rakenduse värskendajad)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Laadimine"</item>
    <item msgid="658627268149681677">"Uinumine"</item>
    <item msgid="1599558140284643834">"Energiasäästurežiim"</item>
    <item msgid="588427840913221601">"Protsessi olek"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Kinnita"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Eelvaade"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Valige ekraanisäästja"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Kuva lisateave"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Ekraanisäästjal kuvatakse näiteks kellaaeg, ilmateade või muu teave"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Kuva kodu juhtelemendid"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Ekraanisäästja režiimis kuvatakse kodu juhtelementide nupp"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Rohkem seadeid"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Valige ekraanisäästja"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Valige, mida oma ekraanikuval näete, kui teie tahvelarvuti on dokitud. Kui kasutate ekraanisäästjat, võib teie seade rohkem energiat tarbida."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Kohanda"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Kohanda ekraanisäästjat <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Vabas vormis toe jaoks on vaja taaskäivitada."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Töölauarežiimi teisestele ekraanidele sundimiseks on vaja taaskäivitada."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Taaskäivita kohe"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Taaskäivita hiljem"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Ruumiline heli"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Ühilduva meedia heli muutub ruumilisemaks"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Pea jälgimine"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Heli muutub pead liigutades, et kõla oleks loomulikum"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Lubade sünkroonimine telefonist"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Andke oma kellale samad rakenduse load, mille olete andnud selles telefonis"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Heliseadme tüüp"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Teadmata"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Kõlar"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Kõrvaklapid"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Kuuldeaparaat"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Autokomplekt"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Muu"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Võrgu allalaadimiskiiruse limiit"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Seadistage võrgu ribalaiuse kasutusmäära limiit, mis rakendatakse kõikidele võrkudele, mis võrguühendust pakuvad."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Seadistage võrgu allalaadimiskiiruse limiit"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Piirangut pole"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Keela alamprotsesside piirangud"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Keelake rakenduste alamprotsesside puhul süsteemiressursside kasutuse piirangud"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Märkmete rolli sundlubamine"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Lubage märkmete rolli kaudu märkmete tegemise süsteemi integratsioonid. Kui märkmete roll on juba lubatud, ei tehta midagi. Nõuab taaskäivitamist."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Ülekanne"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Rakenduse <xliff:g id="CURRENTAPP">%1$s</xliff:g> ülekandmine"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Kuulake ülekandeid, mida teie läheduses esitatakse"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Edastage meediat teie läheduses olevatesse seadmetesse või kuulake kellegi teise ülekannet"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Ülekanded"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Kuulatakse:"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Otsi ülekandeid"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Sule ülekanne"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Skanni QR-kood"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Sisestage parool"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Ühendust ei saa luua. Proovige uuesti."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Vale parool"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Ülekandega ei saa liituda"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Kuulamise alustamiseks paigutage QR-kood allpool keskele"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR-kood ei ole sobilik vorming"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Konvertimine eSIM-iks"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"eSIM-i ülekandmine teise seadmesse"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# rakendus}other{# rakendust}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Taustal installitud rakendused"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Teie seadme tootja võib teie seadmesse taustal rakendusi installida või lubada seda teha teie operaatoril või muudel partneritel.\n\nSiin loetletud rakendused ei ole seadme tavapäraseks funktsioneerimiseks vajalikud. Võite soovimatud rakendused desinstallida."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Ühtegi rakendust ei installitud taustal"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Desinstalli rakendus"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Rakendused, mis installiti viimase # kuu jooksul}other{Rakendused, mis installiti viimase # kuu jooksul}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Rakendused, mis installiti rohkem kui # kuu tagasi}other{Rakendused, mis installiti rohkem kui # kuud tagasi}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Kuvasuhe"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Kui rakendus ei ole teie seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> jaoks optimeeritud, valige rakenduse vaatamiseks uus kuvasuhe"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Kui rakendus ei ole teie seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> jaoks optimeeritud, valige rakenduse vaatamiseks uus kuvasuhe. Teatud kuvasuhete korral ei pruugita mõningaid rakendusi optimeerida."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Kui rakendus ei ole teie seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> jaoks optimeeritud, valige rakenduse vaatamiseks uus kuvasuhe"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Kui rakendus ei ole teie seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> jaoks optimeeritud, valige rakenduse vaatamiseks uus kuvasuhe. Teatud kuvasuhete korral ei pruugita mõnda rakendust optimeerida."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Soovitatud rakendused"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Muudetud rakendused"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Rakenduse vaikeseade"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Täisekraan"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Pool ekraani"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Seadme kuvasuhe"</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">"See rakendus taaskäivitatakse, kui muudate kuvasuhet. Salvestamata muudatused võivad kaduma minna. Teatud kuvasuhete korral ei pruugita mõningaid rakendusi optimeerida."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Kuvasuhe (katseline)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Kuvasuhe (katse)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Kuvasuhe (laborid)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Katseline"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Katse"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Laborid"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Sõrmejäljeandur"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Vilkuvad märguanded"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Teave vilkuvate märguannete kohta"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Väljas"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Sees / kaamera välgu vilkumine"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Sees / ekraani vilkumine"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Sees / kaamera välgu ja ekraani vilkumine"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Kui saate märguande või kui esitatakse äratuse heli, vilgub kaamera tuli või seadme ekraan."</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Kui saate märguande või kui esitatakse äratuse heli, vilgub seadme ekraan."</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Kui olete valgustundlik, olge vilkuvate märguannete kasutamisel ettevaatlik."</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"välk, valgus, kuulmislangusega, kuulmiskadu"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Näita vilkumist"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Kaamera välgu vilkumine"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Ekraani vilkumine"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Ekraani vilkumise värv"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Sinine"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Taevasinine"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Tsüaansinine"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Kevadroheline"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Roheline"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Šartröösroheline"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Kollane"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranž"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Punane"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Roos"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Lilla"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Valmis"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Tühista"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrastsus"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Tavaline"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Keskmine"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Kõrge"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Selle rakenduse saab avada ainult ühes aknas"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Sees"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Väljas"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Väljas"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Väljas"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Sees"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Väljas"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Sees"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Väljas"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Muudab heledad ekraanid tumedaks ja tumedad heledaks"</string>
    <string name="magnification_feature_summary" msgid="641825267460247848">"Suumige ekraanil kiiresti sisse, et sisu suuremalt kuvada"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Väljas"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Väljas"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Sees"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Väljas"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Sees"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Teie seadme nimi on teie installitud rakendustele nähtav. Bluetooth-seadmetega või WiFi-võrguga ühenduse loomisel või WiFi-kuumkoha seadistamisel võivad seda näha ka teised inimesed."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Grammatiline sugu"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Grammatilise soo valimine"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Petturlike rakenduste skannimine"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Rakenduse tegevuste kontrollimine andmepüügi suhtes"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="60088482227901638">"Skannimise kasutamine"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="2868495870224174097">"Töörakenduste puhul skannimise kasutamine"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
</resources>
