<?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="4676390750360727396">"Jah"</string>
    <string name="no" msgid="6731231425810196216">"Ei"</string>
    <string name="create" msgid="3578857613172647409">"Loo"</string>
    <string name="allow" msgid="3349662621170855910">"Luba"</string>
    <string name="deny" msgid="6947806159746484865">"Keela"</string>
    <string name="dlg_close" msgid="7471087791340790015">"Sule"</string>
    <string name="dlg_switch" msgid="6243971420240639064">"Lüliti"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Tundmatu"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="other">Olete nüüd <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> sammu kaugusel arendajastaatusest.</item>
      <item quantity="one">Olete nüüd <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> sammu kaugusel arendajastaatusest.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Olete nüüd arendaja!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Ei ole vaja, olete juba arendaja."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Traadita ühendus ja võrgud"</string>
    <string name="header_category_connections" msgid="6471513040815680662">"Ühendused"</string>
    <string name="header_category_device" msgid="4544026001618307754">"Seade"</string>
    <string name="header_category_personal" msgid="3310195187905720823">"Isiklik"</string>
    <string name="header_category_access" msgid="7580499097416970962">"Sisene"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Süsteem"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Luba andmesideühendus"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Keela andmesideühendus"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"VoLTE on ette valmistatud"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Videokõne ettevalmistamine"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"WiFi-kõne ettevalmistamine"</string>
    <string name="radio_info_radio_power" msgid="1208229437948820417">"Mobiiliraadio toide"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"SIM-kaardi aadressiraamatu kuvamine"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Kuva määratud valimisnumbrid"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Kuva teenuse valimise numbrid"</string>
    <string name="radioInfo_menu_getPDP" msgid="8951059003824985976">"PDP loendi hankimine"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"Teenus toimib"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Teenus ei toimi"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Ainult hädaabikõned"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Raadio on väljas"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Rändlus"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Rändlus puudub"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Tegevusetu"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Helisemine"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Kõne on pooleli"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Ühendus katkestatud"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Ühendamine"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Ühendatud"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Peatatud"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"Teadmata"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pkts"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"baiti"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Lahuta USB-mäluseade"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"SD-kaardi lahutamine"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Kustuta USB-mäluseade"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Kustuta SD-kaart"</string>
    <string name="preview_pager_content_description" msgid="8926235999291761243">"Eelvaade"</string>
    <string name="preview_page_indicator_content_description" msgid="4821343428913401264">"Eelvaade, <xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. leht <xliff:g id="NUM_PAGES">%2$d</xliff:g>-st"</string>
    <string name="font_size_summary" msgid="1690992332887488183">"Muutke ekraanil kuvatud tekst suuremaks või väiksemaks."</string>
    <string name="small_font" msgid="2295331917424072635">"Väike"</string>
    <string name="medium_font" msgid="2068475425515133701">"Keskmine"</string>
    <string name="large_font" msgid="599055175160971446">"Suur"</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Vähendamine"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Suurendamine"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Näidistekst"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"Võlur Oz"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"11. peatükk: Ozi imeline smaragdlinn"</string>
    <string name="font_size_preview_text_body" msgid="1250552239682375643">"Kuigi rohelised prillid olid silmade kaitseks ninale asetatud, olid Dorothy ja tema sõbrad esialgu selle imelise linna särast pimestatud. Tänavaid ääristasid ilusad rohelisest marmorist majad, mida kaunistasid säravad smaragdid. Tänavakivid olid samuti rohelisest marmorist ja nende vahel särasid päikesevalguses tihedad smaragdiread. Aknad olid rohelisest klaasist ja isegi taevas linna kohal oli rohekas. Pilvede vahelt piilusid rohelised päikesekiired. \n\nInimesi oli palju – mehed, naised ja lapsed olid kõik rõivastatud rohelisse ning ka nende nahal oli rohekas jume. Nad vaatasid uudistavalt Dorothyt ja tema kummalisi kaaslasi ning lõvi nähes jooksid lapsed oma emade selja taha peitu. Kuid keegi ei rääkinud nendega. Tänaval oli palju poode ja Dorothy märkas, et kõik seal oli roheline. Müügil olid rohelised kommid ja popkorn, rohelised kingad, mütsid ning mitmesugused rõivad. Ühes poekeses müüs kaupmees rohelist limonaadi ja lapsed tasusid selle eest roheliste pennidega. \n\nHobuseid ega muid loomi ei paistnud kusagil. Mehed vedasid asju väikestes rohelistes korvides, mida nad enda ees lükkasid. Kõik näisid rõõmsad, rahulolevad ja jõukad."</string>
    <string name="font_size_save" msgid="3450855718056759095">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"USB-mäluseade"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"SD-kaart"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"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="2849387702249327748">"Nähtav kõigile lähedalasuvatele Bluetooth-seadmetele"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Ei ole nähtav teistele Bluetooth-seadmetele"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Nähtav ainult seotud seadmetele"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Nähtavuse ajalõpp"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Lukusta häälvalimine"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Vältige Bluetoothi valija kasutamist, kui ekraan on lukustatud"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Bluetooth-seadmed"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Seadme nimi"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Seadme seaded"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Profiili seaded"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Nimi on määramata, konto nime kasutamine"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Otsi seadmeid"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Seadme ümbernimetamine"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Nimeta ümber"</string>
    <string name="bluetooth_disconnect_title" msgid="6026705382020027966">"Kas katkestada ühendus?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"See lõpetab teie ühenduse seadmega:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Teil ei ole luba Bluetoothi seadete muutmiseks."</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> on läheduses olevatele seadmetele nähtav, kui Bluetoothi seaded on avatud."</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Kas katkestada ühendus seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Edastamine"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Kas profiil keelata?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"See keelab:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;seadmest:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Nimetu Bluetooth-seade"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Otsimine"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"Läheduses ei leitud Bluetooth-seadmeid."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Bluetoothi sidumisettepanek"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Sidumistaotlus"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Puudutage seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> sidumiseks."</string>
    <string name="bluetooth_show_received_files" msgid="5164787486105868895">"Näita vastuvõetud faile"</string>
    <string name="device_picker" msgid="4978696506172252813">"Bluetooth-seadme valimine"</string>
    <string name="bluetooth_permission_request" msgid="1523129741266262748">"Bluetoothi loa taotlus"</string>
    <string name="bluetooth_ask_enablement" msgid="1712443355224737143">"Rakendus tahab selles seadmes Bluetoothi SISSE lülitada."</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="786921566047356213">"Rakendus soovib muuta <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks teie tahvelarvuti teistele Bluetoothi seadmetele nähtavaks."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="5510358858113713272">"Rakendus soovib muuta <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks teie telefoni teistele Bluetoothi seadmetele nähtavaks."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8863617309580598607">"Rakendus soovib muuta tahvelarvuti nähtavaks teistele Bluetoothi seadmetele. Saate seda hiljem muuta Bluetoothi seadetes."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="6487606808683607975">"Rakendus soovib muuta telefoni nähtavaks teistele Bluetoothi seadmetele. Saate seda hiljem muuta Bluetoothi seadetes."</string>
    <string name="bluetooth_ask_start_broadcast" product="default" msgid="3535628155254187911">"<xliff:g id="APP_NAME">%1$s</xliff:g> tahab lülitada sisse Bluetooth-edastuse, et suhelda teiste läheduses olevate seadmetega. Saate seda hiljem muuta Bluetoothi seadetes."</string>
    <string name="bluetooth_ask_enablement_and_start_broadcast" product="default" msgid="8810858601242763295">"<xliff:g id="APP_NAME">%1$s</xliff:g> tahab lülitada sisse Bluetoothi ja Bluetooth-edastuse, et suhelda teiste läheduses olevate seadmetega. Saate seda hiljem muuta Bluetoothi seadetes."</string>
    <string name="bluetooth_broadcasting_explaination" product="default" msgid="4249322115655011799">"Kui see funktsioon on sisse lülitatud, saab teie telefon suhelda teiste läheduses olevate seadmetega.\n\nEdastamiseks kasutatakse Bluetoothi väikese võimsusega signaale."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="3346529092809011149">"Rakendus soovib Bluetoothi sisse lülitada ja muuta tahvelarvuti teistele seadmetele <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks nähtavaks."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="4724094889807196118">"Rakendus soovib Bluetoothi sisse lülitada ja muuta telefoni teistele seadmetele <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks nähtavaks."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="989613204829097159">"Rakendus soovib Bluetoothi sisse lülitada ja muuta tahvelarvuti teistele seadmetele nähtavaks. Saate seda hiljem muuta Bluetoothi seadetes."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6671615712909139801">"Rakendus soovib Bluetoothi sisse lülitada ja muuta telefoni teistele seadmetele nähtavaks. Saate seda hiljem muuta Bluetoothi seadetes."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Bluetoothi sisselülitamine ..."</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Bluetoothi väljalülitamine ..."</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Automaatne ühendamine"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Bluetooth-ühenduse taotlus"</string>
    <string name="bluetooth_connection_notif_message" msgid="3603316575471431846">"Puudutage seadmega „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>” ühenduse loomiseks."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Kas soovite ühendada seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Taotlus telefoniraamatule juurdepääsuks"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="6555508756987053866">"%1$s soovib juurdepääsu teie kontaktisikutele ja kõneajaloole. Kas lubate juurdepääsu kasutajale %2$s?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Ära enam küsi"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Ära enam küsi"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Taotlus sõnumile juurdepääsuks"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s soovib saada juurdepääsu sõnumitele. Kas anda seadmele %2$s juurdepääs?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Juurdepääsutaotlus SIM-kaardile"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"Seade <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib juurdepääsu teie SIM-kaardile. Kui annate juurdepääsu SIM-kaardile, keelatakse seadmes ühenduse ajaks andmesideühendus. Juurdepääsu andmine seadmele <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Kuupäev ja kellaaeg"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Ajavööndi valimine"</string>
    <string name="display_preview_label" msgid="1127597250917274792">"Eelvaade:"</string>
    <string name="display_font_size_label" msgid="8941851418397475389">"Kirja suurus:"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Saada <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Käivita <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Konto:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Puhverserver"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Kustuta"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Puhverserveri port"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Puhverserverist mööduvad"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Taasta vaikeväärtused"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Valmis"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Puhverserveri hosti nimi"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Tähelepanu"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Sisestatud hosti nimi on kehtetu."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Sisestatud välistusloend ei ole õigesti vormindatud. Sisestage välistatud domeenide komadega eraldatud loend."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Peate täitma pordi välja."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Pordi väli peab olema tühi, kui hosti väli on tühi."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Sisestatud port on kehtetu."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Brauser kasutab HTTP-puhverserverit, kuid muud rakendused ei tohi seda kasutada."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"PAC URL: "</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Kärje asukohateave (tugi on katkestatud):"</string>
    <string name="radio_info_neighboring_location_label" msgid="5766020323342985397">"Naaberkärje teave (tugi on katkestatud):"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="7062777594049622128">"Kärje teabe värskendamissagedus:"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Kõik kärje mõõteandmed:"</string>
    <string name="radio_info_dcrtinfo_label" msgid="4062076024399431876">"Andmesideühenduse reaalajas teave:"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Andmesideteenus:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Rändlus:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="2743797189722106231">"Kõne ümbersuunamine:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3587319503902576102">"PPP lähtestuste arv alates käivitumisest:"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Praegune võrk:"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Vastuvõetud andmed:"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Häälteenus:"</string>
    <string name="radio_info_signal_strength_label" msgid="5155734002519307416">"Signaali tugevus:"</string>
    <string name="radio_info_call_status_label" msgid="2611065018172747413">"Häälkõne olek:"</string>
    <string name="radio_info_ppp_sent_label" msgid="7748668735880404586">"Saadetud andmed:"</string>
    <string name="radio_info_message_waiting_label" msgid="1037302619943328273">"Ootel sõnum:"</string>
    <string name="radio_info_phone_number_label" msgid="7942153178953255231">"Telefoninumber:"</string>
    <string name="radio_info_band_mode_label" msgid="8730871744887454509">"Raadioriba valimine"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Häälvõrgu tüüp:"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Andmesidevõrgu tüüp:"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Eelistatud võrgutüübi määramine:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Pingi hosti nimi (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Pingi hosti nimi (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="2382286093023138339">"HTTP-kliendi test:"</string>
    <string name="ping_test_label" msgid="579228584343892613">"Pingimistesti käitamine"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Värskenda"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Värskenda"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="6625185764803245075">"DNS-i kontrolli sisse- või väljalülitamine"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"OEM-i teave/seaded"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Raadio ribarežiimi määramine"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Ribaloendi laadimine …"</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Määra"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Ebaõnnestus"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Õnnestunud"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Muudatused jõustuvad siis, kui USB-kaabel on uuesti ühendatud."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"USB massmälu lubamine"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Baite kokku:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"USB-mäluseade on paigaldamata."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Puudub SD-kaart."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Saadaolevad baidid:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB on kasutusel massmäluna."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"SD-kaart on kasutusel massmäluseadmena."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"USB eemaldamine on nüüd ohutu."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"SD-kaardi eemaldamine on nüüd ohutu."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"USB eemaldati kasutamise ajal"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"SD-kaart eemaldati kasutamise ajal."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Kasutatud baite:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"USB-st meediumi skaneering ..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"SD-kaardi skannimine meediumi jaoks ..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"USB-mälu on kirjutuskaitsega."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"SD-kaart on paigaldatud kirjutuskaitstuna."</string>
    <string name="skip_label" msgid="47510779345218297">"Jäta vahele"</string>
    <string name="next_label" msgid="4693520878012668114">"Järgmine"</string>
    <string name="language_picker_title" msgid="3596315202551687690">"Keeled"</string>
    <string name="pref_title_lang_selection" msgid="2014920136978776034">"Keele-eelistused"</string>
    <string name="locale_remove_menu" msgid="7651301406723638854">"Eemalda"</string>
    <string name="add_a_language" msgid="2330538812283783022">"Lisa keel"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="other">Kas eemaldada valitud keeled?</item>
      <item quantity="one">Kas eemaldada valitud keel?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Tekst kuvatakse teises keeles."</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"Kõiki keeli ei saa eemaldada"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Jätke alles vähemalt üks eelistatud keel"</string>
    <string name="locale_not_translated" msgid="516862628177166755">"Ei pruugi mõnes rakenduses saadaval olla"</string>
    <string name="action_drag_label_move_up" msgid="9052210023727612540">"Teisalda üles"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Teisalda alla"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Teisalda kõige üles"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Teisalda kõige alla"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Eemalda keel"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Tegevuse valimine"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Seadme teave"</string>
    <string name="display_label" msgid="8074070940506840792">"Ekraan"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Teave tahvelarvuti kohta"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Telefoniteave"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"USB-mäluseade"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"SD-kaart"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Puhverserveri seaded"</string>
    <string name="cancel" msgid="6859253417269739139">"Tühista"</string>
    <string name="okay" msgid="1997666393121016642">"OK"</string>
    <string name="forget" msgid="1400428660472591263">"Unusta"</string>
    <string name="save" msgid="879993180139353333">"Salvesta"</string>
    <string name="done" msgid="6942539184162713160">"Valmis"</string>
    <string name="settings_label" msgid="1626402585530130914">"Seaded"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Seaded"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Seadete otsetee"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Lennurežiim"</string>
    <string name="radio_controls_title" msgid="3447085191369779032">"Rohkem"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Traadita ühendus ja võrgud"</string>
    <string name="radio_controls_summary" msgid="2837395036275123133">"WiFi, Bluetoothi, lennukirežiimi ja mobiilsidevõrkude ning VPN-ide haldamine"</string>
    <string name="cellular_data_title" msgid="2525947635539415202">"Mobiilne andmeside"</string>
    <string name="calls_title" msgid="3544471959217176768">"Kõned"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"SMS-sõnumid"</string>
    <string name="cellular_data_summary" msgid="4575500999626276446">"Luba andmekasutus mobiilsidevõrgu kaudu"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Luba andmekas. rändluse ajal"</string>
    <string name="roaming" msgid="3596055926335478572">"Andmesiderändlus"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Ühenda rändluse ajal andmesideteenustega"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Ühenda rändluse ajal andmesideteenustega"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Kaotasite andmesideühenduse, kuna jätsite oma koduvõrgu andmerändluse väljalülitatuks."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Lülita sisse"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"Lisanduda võivad suured tasud."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Kui lubate andmeside rändluse, siis võivad sellega kaasneda rändlustasud!\n\nSeade mõjutab tahvelarvuti kõiki kasutajaid."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Kui lubate andmeside rändluse, siis võivad sellega kaasneda rändlustasud!\n\nSeade mõjutab telefoni kõiki kasutajaid."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Kas lubada andmeside rändlus?"</string>
    <string name="networks" msgid="6333316876545927039">"Operaatori valik"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Võrguoperaatori valimine"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Kuupäev ja kellaaeg"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Kuupäeva ja kellaaja määramine"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Määra kuupäev, kellaaeg, ajavöönd ja vormingud"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Autom. kuup. ja kellaaeg"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Võrgu pakutud kellaaja kasutamine"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Kasuta võrgu pakutud kellaaega"</string>
    <string name="zone_auto" msgid="334783869352026648">"Automaatne ajavöönd"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Kasuta võrgu pakutud ajavööndit"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Kasuta võrgu pakutud ajavööndit"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24-tunnine vorming"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"24-tunnise vormingu kasutamine"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Aeg"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Kellaaja määramine"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Ajavöönd"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Ajavööndi valimine"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Kuupäev"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Kuupäeva määramine"</string>
    <string name="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Sordi tähestiku järgi"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Sordi ajavööndi alusel"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Kuupäev"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Kellaaeg"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Lukusta automaatselt"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast unerežiimi"</string>
    <string name="lock_immediately_summary_with_exception" msgid="9119632173886172690">"Kohe pärast unerežiimile lülitamist, 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="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast unerežiimile lülitumist, välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> hoiab seadet avatuna"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Kuva lukustusekraanil teave omaniku kohta"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Lukustuskuva sõnum"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Luba vidinad"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="1557090442377855233">"Administraator on keelanud"</string>
    <string name="owner_info_settings_summary" msgid="7472393443779227052">"Puudub"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<xliff:g id="COUNT_0">%1$d</xliff:g>/<xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="7591869574491036360">"Nt Joe\' Android."</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Kasutajateave"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Kuva lukustusekraanil profiili teave"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Profiili teave"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Kontod"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Asukoht"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Kontod"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Turvalisus"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Määrake Minu asukoht, ekraani avamine, SIM-kaardi lukk, mandaadi talletuslukk"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Määrake oma asukoht, ekraani avamine, mandaadi talletuslukk"</string>
    <string name="security_passwords_title" msgid="2930627259125138363">"Paroolid"</string>
    <string name="disabled_by_administrator_summary" msgid="5989801404248162477">"Administraator on keelanud"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Sõrmejälg"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Sõrmejälgede haldamine"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"Sõrmej. kasutatakse:"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Sõrmejälje lisamine"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"ekraanilukk"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> sõrmejälge on seadistatud</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> sõrmejälg on seadistatud</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1507739327565151923"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Sõrmejäljega avamine"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Telefoni avamiseks, ostude volitamiseks või rakendustesse sisse logimiseks peate vaid puudutama sõrmejäljeandurit. Olge sõrmejälgede lisamisel ettevaatlik. Neid toiminguid saab teha isegi ühe lisatud sõrmejäljega.\n\nMärkus. Sõrmejälg võib olla vähem turvaline kui keerukas muster või PIN-kood."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="3635924459027832861">"Telefoni avamiseks, ostude volitamiseks või rakendustesse sisse logimiseks peate vaid puudutama sõrmejäljeandurit. Olge sõrmejälgede lisamisel ettevaatlik. Neid toiminguid saab teha isegi ühe lisatud sõrmejäljega.\n\nMärkus. Sõrmejälg võib olla vähem turvaline kui keerukas muster või PIN-kood."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="3199351118385606526">"Tühista"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Jätka"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="5021369420474432665">"Jäta vahele"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="8386444182056861429">"Lisa sõrmejälg"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="7234486440384881699">"Seadme kaitsefunktsioone ei aktiveerita. Te ei saa takistada teisi tahvelarvutit kasutamast, kui selle kaotate, see varastatakse või selle andmed kustutatakse."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="3519190003101280912">"Seadme kaitsefunktsioone ei aktiveerita. Te ei saa takistada teisi seadet kasutamast, kui selle kaotate, see varastatakse või selle andmed kustutatakse."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="417315011140961">"Seadme kaitsefunktsioone ei aktiveerita. Te ei saa takistada teisi telefoni kasutamast, kui selle kaotate, see varastatakse või selle andmed kustutatakse."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="8783499872534165700">"Seadme kaitsefunktsioone ei aktiveerita. Te ei saa takistada teisi tahvelarvutit kasutamast, kui selle kaotate või see varastatakse."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="3120512940873907578">"Seadme kaitsefunktsioone ei aktiveerita. Te ei saa takistada teisi seadet kasutamast, kui selle kaotate või see varastatakse."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3589945558504439395">"Seadme kaitsefunktsioone ei aktiveerita. Te ei saa takistada teisi telefoni kasutamast, kui selle kaotate või see varastatakse."</string>
    <string name="skip_anyway_button_label" msgid="2323522873558834513">"Jäta ikka vahele"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Mine tagasi"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="5877265753699187149">"Leidke andur"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="1959655161889313661">"Leidke telefoni tagaküljel olev sõrmejäljeandur."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Seadme joonis ja sõrmejäljeanduri asukoht"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Nimi"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Kustuta"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="951888937749663602">"Alustame"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Asetage oma sõrm andurile ja tõstke see üles, kui tunnete vibratsiooni"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="8556556992897619044">"Jätkake"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="4232813847507193627">"Liigutage veidi oma sõrme, et lisada oma sõrmejälje kõik erinevad osad"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="4798692662828257300">"Sõrmejälg lisati."</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="835496875787664316">"Alati kui seda ikooni näete, saate tuvastamiseks või ostu volitamiseks kasutada oma sõrmejälge."</string>
    <string name="setup_fingerprint_enroll_finish_message" msgid="7234264291957984004">"Seadme äratamiseks ja avamiseks puudutage lihtsalt sõrmejäljelugejat."</string>
    <string name="setup_fingerprint_enroll_finish_message_secondary" msgid="7104778933406207968">"Kui näete seda ikooni, saate ka oste volitada ja rakendustesse sisse logida."</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="6808422329107426923">"Kas jätta sõrmejälje seadistus vahele?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="274849306857859783">"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="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Seadista ekraanilukk"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"Valmis"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Vabandust, see pole andur"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="5053971232594165142">"Kasutage seadme sõrmejäljeandurit."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="3618021988442639280">"Registreerumist ei lõpetatud"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="2942551158278899627">"Sõrmejälje registreerimisaeg lõppes. Proovige uuesti."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="3624760637222239293">"Sõrmejälje registreerimine ei toiminud. Proovige uuesti või kasutage teist sõrme."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Lisa veel üks"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Järgmine"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Lisaks telefoni avamisele saate oma sõrmejälje abil volitada ka ostusid ja juurdepääsu rakendustele. "<annotation id="url">"Lisateave"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="7007548031540826618">"Ekraaniluku valik on keelatud. Lisateabe saamiseks võtke ühendust organisatsiooni administraatoriga. "<annotation id="admin_details">"Lisateave"</annotation>\n\n"Ostude volitamiseks ja rakendustele juurdepääsemiseks saate endiselt kasutada oma sõrmejälge. "<annotation id="url">"Lisateave"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Tõstke sõrme, seejärel puudutage sõrmejäljelugejat uuesti"</string>
    <string name="setup_fingerprint_enroll_finish_message" msgid="4132164775128798343">"Alati kui seda ikooni näete, saate kasutada oma sõrmejälge."</string>
    <string name="setup_fingerprint_enroll_finish_secondary_message" msgid="3734962461534384882">"Seadete muutmiseks tehke valikud Seaded &gt; Turvalisus &gt; Sõrmejälg."</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Saate lisada kuni <xliff:g id="COUNT">%d</xliff:g> sõrmejälge"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Kas eemaldada kõik sõrmejäljed?"</string>
    <string name="fingerprint_last_delete_message" msgid="8318926239554839722">"Te ei saa oma sõrmejälgi kasutades telefoni avada, oste volitada ega rakendustesse sisse logida."</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="8840100810725902159">"Te ei saa oma tööprofiili avamiseks, ostude volitamiseks ega töörakendustesse sisselogimiseks kasutada oma sõrmejälge."</string>
    <string name="fingerprint_last_delete_confirm" msgid="2634726361059274289">"Jah, eemalda"</string>
    <string name="confirm_fingerprint_icon_content_description" msgid="5255544532157079096">"Jätkamiseks kasutage sõrmejälge."</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Krüpteerimine"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Tahvelarvuti krüpteerimine"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Telefoni krüpteerimine"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Krüpteeritud"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"Saate krüpteerida kontod, seaded, allalaaditud rakendused ja nende andmed, meedia ja muud failid. Kui olete tahvelarvuti krüpteerinud ja ekraaniluku (mustri või PIN-koodi või parooli) seadistanud, peate avama ekraani, et dekrüpteerida tahvelarvuti iga kord, kui lülitate selle sisse. Ainus muu võimalus dekrüpteerimiseks on lähtestada tahvelarvuti tehaseandmetele, mille tulemusel kustutatakse kõik andmed.\n\nKrüpteerimiseks kulub vähemalt tund. Enne krüpteerimise alustamist veenduge, et aku oleks laetud. Tahvelarvuti peab olema kogu protsessi jooksul ühendatud vooluvõrguga. Kui protsess katkeb, kaotate osa andmetest või kõik andmed."</string>
    <string name="crypt_keeper_desc" product="default" msgid="2579929266645543631">"Saate krüpteerida kontod, seaded, allalaaditud rakendused ja nende andmed, meedia ja muud failid. Kui olete telefoni krüpteerinud ja ekraaniluku (mustri või PIN-koodi või parooli) seadistanud, peate avama ekraani, et dekrüpteerida telefon iga kord, kui lülitate selle sisse. Ainus muu võimalus dekrüpteerimiseks on lähtestada telefon tehaseandmetele, mille tulemusel kustutatakse kõik andmed.\n\nKrüpteerimiseks kulub vähemalt tund. Enne krüpteerimise alustamist veenduge, et aku oleks laetud. Telefon peab olema kogu protsessi jooksul ühendatud vooluvõrguga. Kui protsess katkeb, kaotate osa andmetest või kõik andmed."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Krüpteeri tahvelarvuti"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Krüpteeri telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Laadige akut ja proovige uuesti."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Ühendage laadija ja proovige uuesti."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Ekraaniluku PIN-koodi või parooli ei ole"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Enne krüpteerimist peate määrama lukustusekraani PIN-koodi või parooli."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Kas krüpteerida?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Krüpteerimistoiming on pöördumatu ja katkestamisel kaotate andmed. Krüpteerimiseks kulub tund või rohkem, mille jooksul tahvelarvuti taaskäivitub mitu korda."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Krüpteerimistoiming on pöördumatu ja selle katkestamisel kaotate andmed. Krüpteerimiseks kulub tund või rohkem, selle aja jooksul taaskäivitub telefon mitu korda."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Krüpteerimine"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Oodake, kuni teie tahvelarvutit krüpteeritakse. <xliff:g id="PERCENT">^1</xliff:g>% valmis."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Oodake, kuni teie telefon krüpteeritakse. <xliff:g id="PERCENT">^1</xliff:g>% valmis."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Oodake, kuni teie tahvelarvuti krüpteeritakse. Aega on jäänud: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Oodake, kuni teie telefon krüpteeritakse. Aega on jäänud: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Tahvelarvuti avamiseks lülitage see välja ja uuesti sisse."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Telefoni avamiseks lülitage see välja ja uuesti sisse."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Hoiatus! Kui veel <xliff:g id="COUNT">^1</xliff:g> avamiskatset ebaõnnestub, siis seade tühjendatakse."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Sisestage parool"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Krüptimine ebaõnnestus"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"Krüpteerimine katkestati ja seda ei saa lõpule viia. Seetõttu ei pääse te enam oma tahvelarvutis olevatele andmetele juurde. \n\n Tahvelarvuti kasutamise jätkamiseks peate lähtestama selle tehaseseadetele. Kui seadistate tahvelarvutit pärast lähtestamist, saate taastada kõik andmed, mis olid varundatud teie Google\'i kontole."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Krüpteerimine katkestati ja seda ei saa lõpule viia. Seetõttu ei pääse te enam oma telefonis olevatele andmetele juurde. \n\nTelefoni kasutamise jätkamiseks peate selle lähtestama tehaseseadetele. Kui seadistate telefoni pärast lähtestamist, saate taastada kõik andmed, mis olid varundatud teie Google\'i kontole."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dekrüpteerimine ebaõnnestus"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"Sisestatud parool on õige, kuid kahjuks on andmed rikutud. \n\nTahvelarvuti kasutamise jätkamiseks peate selle lähtestama tehaseseadetele. Kui seadistate tahvelarvuti pärast lähtestamist, saate taastada kõik andmed, mis on varundatud teie Google\'i kontole."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Sisestatud parool on õige, kuid kahjuks on andmed rikutud. \n\nTelefoni kasutamise jätkamiseks peate selle lähtestama tehaseseadetele. Kui seadistate telefoni pärast lähtestamist, saate taastada kõik andmed, mis on varundatud teie Google\'i kontole."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Sisestusmeetodi vahetamine"</string>
    <string name="suggested_lock_settings_title" msgid="8971630898700461034">"Ekraaniluku seadistamine"</string>
    <string name="suggested_lock_settings_summary" msgid="8778462376012231110">"Seadme kaitsmine"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3655973509619012084">"Sõrmejälje kasutamine"</string>
    <string name="suggested_fingerprint_lock_settings_summary" msgid="2149569133725273864">"Sõrmejäljega avamine"</string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Ekraaniluku valimine"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Vali tööprofiili lukk"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="90329443364067215">"Tahvelarvuti kaitsmine"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="2399952075134938929">"Seadme kaitsmine"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="1572244299605153324">"Telefoni kaitsmine"</string>
    <string name="setup_lock_settings_picker_fingerprint_message" msgid="5585650064305600578">"Lisaturvalisuse jaoks seadistage varuekraanilukk."</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"Aktiveerige seadme kaitsefunktsioonid, et teised ei saaks ilma teie loata tahvelarvutit kasutada. Valige kasutatav ekraanilukk."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="3787276514406353777">"Aktiveerige seadme kaitsefunktsioonid, et teised ei saaks ilma teie loata seadet kasutada. Valige kasutatav ekraanilukk."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="3692856437543730446">"Aktiveerige seadme kaitsefunktsioonid, et teised ei saaks ilma teie loata telefoni kasutada. Valige kasutatav ekraanilukk."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="4755230324778371292">"Valige oma ekraaniluku varumeetod"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Ekraanilukk"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="124176557311393483">"Tööprofiili lukk"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Ekraaniluku muutmine"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Muuda või keela mustri, PIN-koodi või parooli turve"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Valige ekraani lukustamise meetod"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Puudub"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Pühkimine"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Turvamata"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Muster"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Keskmine turvalisus"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN-kood"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Keskmine kuni kõrge turvalisus"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Parool"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Kõrge turvalisus"</string>
    <string name="unlock_set_do_later_title" msgid="4894767558414979243">"Mitte praegu"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Praegune ekraanilukk"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4939057588092120368">"Sõrmejälg + muster"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="8010746824051056986">"Sõrmejälg + PIN-kood"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="7351131075806338634">"Sõrmejälg + parool"</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2120729867788851674">"Keelanud admin., krüptimiseeskiri või mand. mälu"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Puudub"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Pühkimine"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Muster"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN-kood"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Parool"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Kui olete ekraaniluku seadistanud, saate menüüs Seaded &gt; Turvalisus seadistada ka oma sõrmejälje."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Lülita ekraanilukk välja"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"Kas eemaldada seadme kaitse?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="5507136301904313583">"Kas eemaldada profiili kaitsefunktsioonid?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="8869767290771023461">"Seadme kaitsefunktsioonid ei tööta ilma teie mustrita."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="8212242533942400457">"Seadme kaitsefunktsioonid ei tööta ilma teie mustrita.<xliff:g id="EMPTY_LINE">

</xliff:g>Seadmest eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa oma telefoni avada, oste volitada ega nendega rakendustesse sisse logida.”"</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="586996206210265131">"Seadme kaitsefunktsioonid ei tööta ilma teie PIN-koodita."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="875669051899437197">"Seadme kaitsefunktsioonid ei tööta ilma teie PIN-koodita.<xliff:g id="EMPTY_LINE">

</xliff:g>Seadmest eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa oma telefoni avada, oste volitada ega nendega rakendustesse sisse logida.”"</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="5420612686852555537">"Seadme kaitsefunktsioonid ei tööta ilma teie paroolita."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="2228159168587170445">"Seadme kaitsefunktsioonid ei tööta ilma teie paroolita.<xliff:g id="EMPTY_LINE">

</xliff:g>Seadmest eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa oma telefoni avada, oste volitada ega nendega rakendustesse sisse logida.”"</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="1550718040483548220">"Seadme kaitsefunktsioonid ei tööta ilma teie ekraanilukuta."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6363091330281670692">"Seadme kaitsefunktsioonid ei tööta ilma teie ekraanilukuta.<xliff:g id="EMPTY_LINE">

</xliff:g>Seadmest eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa oma telefoni avada, oste volitada ega nendega rakendustesse sisse logida.”"</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="8682200103576359918">"Profiili kaitsefunktsioonid ei tööta ilma teie mustrita."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="3675154828957224316">"Profiili kaitsefunktsioonid ei tööta ilma teie mustrita.<xliff:g id="EMPTY_LINE">

</xliff:g>Profiililt eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa nendega oma profiili avada, oste volitada ega rakendustesse sisse logida.”"</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="7790688070593867767">"Profiili kaitsefunktsioonid ei tööta ilma teie PIN-koodita."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="4879321153584598940">"Profiili kaitsefunktsioonid ei tööta ilma teie PIN-koodita.<xliff:g id="EMPTY_LINE">

</xliff:g>Profiililt eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa nendega oma profiili avada, oste volitada ega rakendustesse sisse logida.”"</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="7569285520567674461">"Profiili kaitsefunktsioonid ei tööta ilma teie paroolita."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="3527188316958917839">"Profiili kaitsefunktsioonid ei tööta ilma teie paroolita.<xliff:g id="EMPTY_LINE">

</xliff:g>Profiililt eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa nendega oma profiili avada, oste volitada ega rakendustesse sisse logida.”"</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6984215718701688202">"Profiili kaitsefunktsioonid ei tööta ilma teie ekraanilukuta."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="1962204059377724158">"Profiili kaitsefunktsioonid ei tööta ilma teie ekraanilukuta.<xliff:g id="EMPTY_LINE">

</xliff:g>Profiililt eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa nendega oma profiili avada, oste volitada ega rakendustesse sisse logida.”"</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Jah, eemalda"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Avamismustri muutmine"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Muuda avamise PIN-koodi"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Avamisparooli muutmine"</string>
    <string name="lock_profile_wipe_attempts" msgid="1216193652369039672">"Proovige uuesti. Katse <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>/<xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_profile_wipe_warning_title" msgid="2961600792367265036">"Viimane katse"</string>
    <string name="lock_profile_wipe_warning_content_pattern" msgid="8978031996247660921">"Kui sisestate sellel katsel vale töömustri, eemaldatakse teie tööprofiil ja seotud andmed sellest seadmest."</string>
    <string name="lock_profile_wipe_warning_content_pin" msgid="7697973618542377880">"Kui sisestate sellel katsel vale töö-PIN-koodi, eemaldatakse teie tööprofiil ja seotud andmed sellest seadmest."</string>
    <string name="lock_profile_wipe_warning_content_password" msgid="450695588340509349">"Kui sisestate sellel katsel vale tööparooli, eemaldatakse teie tööprofiil ja seotud andmed sellest seadmest."</string>
    <string name="lock_profile_wipe_content" msgid="2150455386921347628">"Liiga palju valesid katseid. Teie tööprofiil ja seotud andmed eemaldatakse sellest seadmest."</string>
    <string name="lock_profile_wipe_dismiss" msgid="5118293266264141442">"Loobu"</string>
    <string name="lockpassword_password_too_short" msgid="2691590536362441127">"Peab olema vähemalt %d tähemärki"</string>
    <string name="lockpassword_pin_too_short" msgid="1677649103470518953">"PIN-koodi pikkus peab olema vähemalt %d numbrit"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Jätka"</string>
    <string name="lockpassword_password_too_long" msgid="4520363269062591833">"Peab olema lühem kui <xliff:g id="NUMBER">%d</xliff:g> tähemärki."</string>
    <string name="lockpassword_pin_too_long" msgid="4010052843684165845">"Peab olema lühem kui <xliff:g id="NUMBER">%d</xliff:g> numbrit."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="5537252833154289817">"Tohib sisaldada ainult numbreid 0–9."</string>
    <string name="lockpassword_pin_recently_used" msgid="214840704635573454">"Seadme administraator ei luba kasutada viimast PIN-koodi."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"See ei tohi sisaldada sobimatut tähemärki"</string>
    <string name="lockpassword_password_requires_alpha" msgid="3036589522150097731">"Peab sisaldama vähemalt ühte tähte"</string>
    <string name="lockpassword_password_requires_digit" msgid="5140062925787058765">"Peab sisaldama vähemalt ühte numbrit"</string>
    <string name="lockpassword_password_requires_symbol" msgid="5944350865681510893">"Peab sisaldama vähemalt ühte sümbolit"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="3121545900151618401">
      <item quantity="other">Peab sisaldama vähemalt %d tähte</item>
      <item quantity="one">Peab sisaldama vähemalt 1 tähte</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="5415008859853535577">
      <item quantity="other">Peab sisaldama vähemalt %d väiketähte</item>
      <item quantity="one">Peab sisaldama vähemalt 1 väiketähte</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="1452012183267855761">
      <item quantity="other">Peab sisaldama vähemalt %d suurtähte</item>
      <item quantity="one">Peab sisaldama vähemalt 1 suurtähte</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="5536275490534483515">
      <item quantity="other">Peab sisaldama vähemalt %d numbrit</item>
      <item quantity="one">Peab sisaldama vähemalt 1 numbrit</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="5132998285340017795">
      <item quantity="other">Peab sisaldama vähemalt %d erisümbolit</item>
      <item quantity="one">Peab sisaldama vähemalt 1 erisümbolit</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="2778958281865593579">
      <item quantity="other">Peab sisaldama vähemalt %d tähemärki, mis ei ole täht</item>
      <item quantity="one">Peab sisaldama vähemalt 1 tähemärki, mis ei ole täht</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="4687102591995446860">"Seadme administraator ei luba viimast parooli kasutada."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="6830610582179569631">"Kasvavad, kahanevad või korduvad numbrijadad on keelatud"</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"OK"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Tühista"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Tühista"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Järgmine"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Seadistamine on lõpetatud."</string>
    <string name="device_admin_title" msgid="3562216873644263804">"Seadme haldamine"</string>
    <string name="manage_device_admin" msgid="5059296715271077278">"Seadme administraatorid"</string>
    <string name="manage_device_admin_summary" msgid="7672709110988761075">"Seadme administraatorite kuvamine või inaktiveerimine"</string>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Usaldusväärsed agendid"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Kasutamiseks määrake kõigepealt ekraanilukk"</string>
    <string name="manage_trust_agents_summary" msgid="6804319935640148441">"Usaldusväärsete agentide kuvamine või inaktiveerimine"</string>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Lülitage Bluetooth sisse"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Halda ühendusi, määra seadme nimi ja leitavus"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"Kas siduda seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Bluetoothi sidumiskood"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Sisestage sidumiskood ja vajutage seejärel sisestusklahvi"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"PIN-kood sisaldab tähti või sümboleid"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Tavaliselt 0000 või 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Peab olema 16-kohaline"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Võib-olla peate selle PIN-koodi sisestama ka teise seadmesse."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Võib-olla peate selle parooli sisestama ka teise seadmesse."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Sidumine seadmega&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Veenduge, et see kuvaks järgmist parooli:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Seadmelt: &lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt; Kas siduda seadmega?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Siduda seadmega:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Sisestage:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g>, seejärel vajutage naasmis- või sisestusklahvi."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="2277931851483023208">"Lubage seadmel <xliff:g id="DEVICE_NAME">%1$s</xliff:g> juurde pääseda teie kontaktidele ja kõneajaloole"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ei saanud ühendust."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Otsi seadmeid"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Värskenda"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Otsimine ..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Seadme seaded"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Seotud seade"</string>
    <string name="bluetooth_preference_paired_dialog_name_label" msgid="8111146086595617285">"Nimi"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Interneti-ühendus"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Klaviatuur"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Kontaktid ja kõneajalugu"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Kas siduda selle seadmega?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Kas jagada telefoniraamatut?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> soovib hankida juurdepääsu teie kontaktidele ja kõne ajaloole."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> tahab siduda Bluetoothiga. Kui ühendus on loodud, on sellel juurdepääs kontaktidele ja kõneajaloole."</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Seotud seadmed"</string>
    <string name="bluetooth_preference_found_devices" msgid="1647983835063249680">"Saadaval seadmed"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Ühtegi seadet pole saadaval"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Ühenda"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Katkesta ühendus"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Seo ja ühenda"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Seo lahti"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Katkesta ühendus ja seo lahti"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Valikud ..."</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Täpsemad"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Täpsemad Bluetoothi seaded"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Kui Bluetooth on sisse lülitatud, saab seade suhelda teiste lähikonna Bluetooth-seadmetega."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Asukoha täpsuse parandamiseks saavad süsteemirakendused ja -teenused endiselt tuvastada Bluetoothi seadmeid. Seda saate muuta <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>skannimisseadetes<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Ühendamine ..."</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus meediumiheliga katkestatakse."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus vabakäeseadme heliga katkestatakse."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus sisendseadmega katkestatakse."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Katkestatakse Interneti-ühendus seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> kaudu."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="1262792320446274407">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> tahvelarvuti Interneti-ühenduse jagamine katkestatakse."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="5700332050175684571">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> telefoni Interneti-ühenduse jagamine katkestatakse."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Seotud Bluetooth-seade"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Ühenda"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Ühenda Bluetooth-seadmega"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Kasutus:"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Nimeta ümber"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Luba sissetul. failiedastused"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="4602294638909590612">"Ühendatud seadmega Internetti juurdepääsuks"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"Kohaliku Interneti-ühenduse jagamine seadmega"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Doki seaded"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Kasutage heli jaoks dokki"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Kõlartelefonina"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Muusika ja meediumi jaoks"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Jäta seaded meelde"</string>
    <string name="wifi_assistant_title" msgid="2553267316621598101">"WiFi Assistant"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Ülekandmine"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Luba juhtmeta ekraaniühendus"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"Läheduses seadmeid ei leitud."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Ühendamine"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Ühendatud"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"Kasutusel"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Pole saadaval"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Kuvaseaded"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Juhtmeta ekraaniühenduse valikud"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Unusta"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Valmis"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Nimi"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="link_speed" msgid="8896664974117585555">"%1$d Mb/s"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Lubab andmete vahetust, kui tahvelarvuti puudutab teist seadet"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Lubab andmete vahetust, kui telefon puudutab teist seadet"</string>
    <string name="nfc_disclaimer_title" msgid="4364003873202264039">"NFC sisselülitamine"</string>
    <string name="nfc_disclaimer_content" msgid="5566907911915158075">"NFC vahetab andmeid selle seadme ja muude läheduses asuvate seadmete või sihtmärkide vahel (nt makseterminalid, juurdepääsulugejad ja interaktiivsed reklaamid või märgendid)."</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Valmis edastama rakenduse sisu NFC kaudu"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Väljas"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Pole saadaval, kuna NFC on välja lülitatud"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="1828555626055290684">"Kui see funktsioon on sisse lülitatud, saate rakenduse sisu teise NFC-toega seadmesse kiirega saata, kui hoiate seadmeid üksteise lähedal. Nii saate edastada näiteks brauserilehti, YouTube\'i videoid, inimeste kontakte ja muud.\n\nLihtsalt hoidke seadmeid lähestikku (tavaliselt tagused koos) ja seejärel puudutage seadme ekraani. Rakendus määrab, mida kiirega edastatakse."</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"WiFi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Lülita WiFi sisse"</string>
    <string name="wifi_settings" msgid="29722149822540994">"WiFi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"WiFi-seaded"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"WiFi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Määra ja halda traadita pääsupunkte"</string>
    <string name="wifi_setup_wizard_title" msgid="7873622558088429710">"WiFi-võrgu valimine"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"WiFi valimine"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"WiFi sisselülitamine ..."</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"WiFi väljalülitamine ..."</string>
    <string name="wifi_error" msgid="3207971103917128179">"Viga"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"5 GHz riba pole selles riigis saadaval"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"Lennurežiimis"</string>
    <string name="wifi_notify_open_networks" msgid="3755768188029653293">"Võrguteatis"</string>
    <string name="wifi_notify_open_networks_summary" msgid="3716818008370391253">"Teavita, kui avalik võrk on saadaval"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Väldi halbu ühendusi"</string>
    <string name="wifi_poor_network_detection_summary" msgid="2784135142239546291">"Ära kasuta WiFi-võrku, kui selle Interneti-ühendus on halb"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4674423884870027498">"Kasuta ainult võrke, millel on hea Interneti-ühendus"</string>
    <string name="wifi_automatically_connect_title" msgid="7950640291510621742">"Kasuta avatud WiFi-t automaatselt"</string>
    <string name="wifi_automatically_connect_summary" msgid="6722194413023965902">"Lase WiFi-abil automaatselt ühenduda kvaliteetsetesse avatud võrkudesse"</string>
    <string name="wifi_select_assistant_dialog_title" msgid="4014645210955009439">"Abi valimine"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Sertifikaatide installimine"</string>
    <string name="wifi_scan_notify_text" msgid="5593805423071186757">"Asukoha täpsuse parandamiseks saavad süsteemirakendused ja -teenused endiselt skannida WiFi-võrke. Seda saate muuta <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>skannimisseadetes<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Ära kuva uuesti"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Hoia WiFi unerežiimis sees"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"WiFi on unerež. sisselülitatud"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Seade muutmisel tekkis probleem"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Tõhusamaks muutmine"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"WiFi optimeerimine"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimeeri aku kasutamine, kui WiFi on sees"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Piira WiFi akukasutust"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="1410499115509796174">"Kui WiFi kaotab juurdepääsu Internetile, lülita mobiiliandmesidele."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8741291033791891668">"Lülitu mobiilsele andmesidele automaatselt"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="2641527693037426430">"Kui WiFi-l puudub Interneti-juurdepääs, kasutatakse mobiilset andmesidet. Andmekasutus võib kulutada andmemahtu."</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Võrgu lisamine"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"WiFi-võrgud"</string>
    <string name="wifi_menu_wps_pbc" msgid="2668564692207863017">"WPS-nupp"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Rohkem valikuid"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"WPS-i PIN-koodi kirje"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"WiFi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Skannimine"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Täpsemalt"</string>
    <string name="wifi_menu_configure" msgid="6150926852602171938">"Seadistamine"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Loo võrguühendus"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Jäta võrk meelde"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Unusta võrk"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Võrgu muutmine"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"NFC-kiibile kirjutamine"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Saadavate võrkude kuvamiseks lülitage WiFi sisse."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"WiFi-võrkude otsimine ..."</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Teil pole WiFi-võrgu muutmiseks luba."</string>
    <string name="wifi_other_network" msgid="1484433183857764750">"Veel ühe võrgu lisamine"</string>
    <string name="wifi_more" msgid="3195296805089107950">"Rohkem"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Automaatseadistus (WPS)"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Täpsemad valikud"</string>
    <string name="wifi_wps_setup_title" msgid="8207552222481570175">"Kaitstud WiFi seadistamine"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"WPS-i käivitamine …"</string>
    <string name="wifi_wps_onstart_pbc" msgid="817003360936932340">"Vajutage marsruuteril nuppu WiFi kaitstud seadistamine. Selle nimi võib olla ka „WPS” või see võib olla märgitud sellise sümboliga:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Sisestage WiFi-ruuteril PIN-kood <xliff:g id="NUMBER">%1$s</xliff:g>. Seadistuse lõpuleviimiseks võib kuluda kuni kaks minutit."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"WPS õnnestus. Võrguga ühenduse loomine …"</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Ühendus on loodud WiFi-võrguga <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"WPS on juba käimas ja selle lõpuleviimiseks võib kuluda kuni kaks minutit"</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"WPS ebaõnnestus. Proovige mõne minuti pärast uuesti."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Ruuteri turvaseadet (WEP) ei toetata"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Ruuteri turvaseadet (TKIP) ei toetata"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Autentimine ebaõnnestus. Proovige uuesti."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Tuvastati teine WPS-i seanss. Proovige mõne minuti pärast uuesti."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Võrgu nimi"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Sisestage SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Turvalisus"</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Signaali tugevus"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Olek"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Lingi kiirus"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Sagedus"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"IP-aadress"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"Salvestusviis:"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"Üksuse <xliff:g id="NAME">%1$s</xliff:g> mandaat"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"EAP meetod"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"2. etapi autentimine"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"CA-sertifikaat"</string>
    <string name="wifi_eap_domain" msgid="8471124344218082064">"Domeen"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Kasutaja sertifikaat"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identiteet"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonüümne identiteet"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Parool"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Kuva parool"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"AP-riba valimine"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"2,4 GHz riba"</string>
    <string name="wifi_ap_choose_5G" msgid="8137061170937978040">"5 GHz riba"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"IP-seaded"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Jaga seadme teiste kasutajatega"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(muutmata)"</string>
    <string name="wifi_unspecified" msgid="4917316464723064807">"Valige"</string>
    <string name="wifi_multiple_cert_added" msgid="3240743501460165224">"(Lisati mitu sertifikaati)"</string>
    <string name="wifi_use_system_certs" msgid="5270879895056893783">"Kasuta süsteemi sertifikaate"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"Ära esita"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"Ära kinnita"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"Sertifikaati pole määratud. Teie ühendus pole privaatne."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Tuleb määrata domeen."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS on saadaval"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" WPS on saadaval"</string>
    <string name="wifi_wps_nfc_enter_password" msgid="2288214226916117159">"Sisestage võrgu parool"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"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_turnoff_message" msgid="5538901671131941043">"Väljalülitamiseks avage ületäitemenüüs valik Täpsem."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Luba"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Keela"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Kas logida sisse, et ühendada?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> nõuab, et peate enne võrguga ühendamist veebis sisse logima."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"ÜHENDA"</string>
    <string name="no_internet_access_text" msgid="7133561752896706392">"Sellel võrgul puudub juurdepääs Internetile. Kas soovite ühenduse säilitada?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"Ära selle võrgu puhul uuesti küsi"</string>
    <string name="lost_internet_access_title" msgid="6228530645663584505">"WiFi pole Internetiga ühendatud"</string>
    <string name="lost_internet_access_text" msgid="1676124057345106398">"Kui WiFi-ühendus on kehv, saate lülituda mobiilsidevõrku. Andmekasutus võib olla tasuline."</string>
    <string name="lost_internet_access_switch" msgid="1980357004205108781">"Lülitu mobiilsidevõrku"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Kasuta edasi WiFi-t"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"Ära näita enam kunagi"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Ühenda"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Võrguga ühenduse loomine ebaõnnestus"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Unusta"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Võrgu unustamine ebaõnnestus"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Salvesta"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Võrgu säilitamine ebaõnnestus"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Tühista"</string>
    <string name="wifi_skip_anyway" msgid="6965361454438011190">"Jäta siiski vahele"</string>
    <string name="wifi_dont_skip" msgid="3615535136327231588">"Mine tagasi"</string>
    <string name="wifi_skipped_message" product="tablet" msgid="6761689889733331124">"HOIATUS. Kui jätate WiFi vahele, siis kasutab tahvelarvuti esmasteks allalaadimisteks ja värskendamiseks ainult mobiilset andmesidet. Võimalike andmeside tasude vältimiseks ühendage tahvelarvuti WiFi-võrku."</string>
    <string name="wifi_skipped_message" product="device" msgid="1385490367826852775">"HOIATUS. Kui jätate WiFi vahele, siis kasutab seade esmasteks allalaadimisteks ja värskendamiseks ainult mobiilset andmesidet. Võimalike andmeside tasude vältimiseks ühendage seade WiFi-võrku."</string>
    <string name="wifi_skipped_message" product="default" msgid="6084295135297772350">"HOIATUS. Kui jätate WiFi vahele, siis kasutab telefon esmasteks allalaadimisteks ja värskendamiseks ainult mobiilset andmesidet. Võimalike andmeside tasude vältimiseks ühendage telefon WiFi-võrku."</string>
    <string name="wifi_and_mobile_skipped_message" product="tablet" msgid="6324917391996718760">"Kui te ei loo WiFi-ühendust:\n\n"<li>"tahvelarvutil ei ole Interneti-ühendust;"</li>\n\n<li>"te ei saa tarkvaravärskendusi enne, kui olete loonud Interneti-ühenduse;"</li>\n\n<li>"te ei saa sel ajal seadme kaitsefunktsioone aktiveerida."</li></string>
    <string name="wifi_and_mobile_skipped_message" product="device" msgid="1110629752293998468">"Kui te ei loo WiFi-ühendust:\n\n"<li>"seadmel ei ole Interneti-ühendust;"</li>\n\n<li>"te ei saa tarkvaravärskendusi enne, kui olete loonud Interneti-ühenduse;"</li>\n\n<li>"te ei saa sel ajal seadme kaitsefunktsioone aktiveerida."</li></string>
    <string name="wifi_and_mobile_skipped_message" product="default" msgid="8271524692702309267">"Kui te ei loo WiFi-ühendust:\n\n"<li>"telefonil ei ole Interneti-ühendust;"</li>\n\n<li>"te ei saa tarkvaravärskendusi enne, kui olete loonud Interneti-ühenduse;"</li>\n\n<li>"te ei saa sel ajal seadme kaitsefunktsioone aktiveerida."</li></string>
    <string name="wifi_connect_failed_message" product="tablet" msgid="4474691090681670156">"Tahvelarvutil ei õnnestunud luua ühendust selle WiFi-võrguga."</string>
    <string name="wifi_connect_failed_message" product="device" msgid="8870885845666880869">"Seadmel ei õnnestunud WiFi-võrguga ühendust luua."</string>
    <string name="wifi_connect_failed_message" product="default" msgid="2185803140161396572">"Telefonil ei õnnestunud luua ühendust selle WiFi-võrguga."</string>
    <string name="wifi_saved_access_points_titlebar" msgid="2996149477240134064">"Salvestatud võrgud"</string>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Täpsemad WiFi-seaded"</string>
    <string name="wifi_configure_titlebar" msgid="7977475161589303074">"WiFi seadistamine"</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"MAC-aadress"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"IP-aadress"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Salvestatud võrgud"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"IP-seaded"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"WiFi täpsemad seaded pole selle kasutaja jaoks saadaval"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Salvesta"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Tühista"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Sisestage kehtiv IP-aadress."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Sisestage kehtiv lüüsi aadress."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Sisestage kehtiv DNS-aadress."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Sisestage võrgu eesliide pikkusega 0 kuni 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Lüüs"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Võrgu prefiksi pikkus"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"WiFi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Seadme teave"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Pea see ühendus meeles"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Otsi seadmeid"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Otsing …"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Nimeta seade ümber"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Võrdõigusvõrgu seadmed"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Meeldejäetud rühmad"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"Ühenduse loomine ebaõnnestus."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Seadme ümbernimetamine ebaõnnestus."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Kas katkestada ühendus?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"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="3283805371034883105">"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="255267538099324413">"Kas tühistada kutse?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"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="834559380069647086">"Kas unustada see rühm?"</string>
    <string name="wifi_tether_checkbox_text" msgid="1847167643625779136">"Kaasaskantav WiFi-tugijaam"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"WiFi-leviala"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="3800646230853724318">"Kasuta WiFi-võrgu loomiseks mobiilseandmeside ühendust"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Leviala sisselülitamine ..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Leviala väljalülitamine ..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="8948641212931906143">"Kantav tööpunkt <xliff:g id="NETWORK_SSID">%1$s</xliff:g> on aktiivne"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Kaasaskantava WiFi-tugijaama viga"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"WiFi-tugijaama seadistamine"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"WiFi-leviala seadistamine"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5618031116920832182">"AndroidAP WPA2 PSK kaasask. WiFi-leviala"</string>
    <string name="wifi_tether_configure_subtext" msgid="7957547035983257748">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g> kaasaskantav WiFi-tugijaam"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"WiFi-kõned"</string>
    <string name="wifi_calling_suggestion_title" msgid="9008010480466359578">"Lülitage sisse WiFi-kõned"</string>
    <string name="wifi_calling_suggestion_summary" msgid="3765923249566552233">"Mobiilsidevõrgu asemel WiFi kasutamine"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Kõne-eelistus"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="8149690312199253909">"WiFi-kõnerežiim"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="2124257075906188844">"WiFi eelistusega"</item>
    <item msgid="5267397515594230396">"Mobiilside eelistusega"</item>
    <item msgid="3132912693346866895">"Ainult WiFi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values">
    <item msgid="4799585830102342375">"2"</item>
    <item msgid="1171822231056612021">"1"</item>
    <item msgid="3194458950573886239">"0"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_without_wifi_only">
    <item msgid="5782108782860004851">"WiFi eelistusega"</item>
    <item msgid="9006785365352731433">"Mobiilside eelistusega"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values_without_wifi_only">
    <item msgid="2339246858001475047">"2"</item>
    <item msgid="6200207341126893791">"1"</item>
  </string-array>
    <string name="wifi_calling_off_explanation" msgid="2597566001655908391">"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."</string>
    <string name="emergency_address_title" msgid="3571902448699714454">"Hädaabi aadressi värskendamine"</string>
    <string name="emergency_address_summary" msgid="306028701568728126">"Aadress, mida hädaabiteenused kasutavad teie asukohana, kui teete WiFi kaudu hädaabikõne"</string>
    <string name="home_settings" msgid="212375129455718176">"Avaekraan"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Ekraan"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Heli"</string>
    <string name="ringtone_summary" msgid="2630023412632683493"></string>
    <string name="all_volume_title" msgid="4296957391257836961">"Helitugevused"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Muusikaefektid"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Helina helitugevus"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibreeri hääletus režiimis"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Märguande vaikeheli"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Helin"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Teatis"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Kasuta teatiste jaoks sissetuleva kõne helitugevust"</string>
    <string name="home_work_profile_not_supported" msgid="7457951997970419085">"Tööprofiile ei toetata"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Märguande vaikeheli"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Meedium"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Määra muusika ja videote helitugevus"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Äratus"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Ühendatud doki heliseaded"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Valimisklahvistiku puutetoonid"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Puudutuste helid"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Ekraaniluku heli"</string>
    <string name="haptic_feedback_enable_title" msgid="7152163068278526530">"Vibreeri puudutamisel"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Mürasummutus"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Muusika, video, mängud ja muu meedia"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Helin ja teated"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Teated"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmid"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Helinate ja teatiste summutamine"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Muusika ja muude meediumide summutamine"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Teatiste summutamine"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Äratuste summutamine"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Dokk"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Doki seaded"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Heli"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Ühendatud töölaua doki seaded"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Ühendatud autodoki seaded"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tahvelarvuti on dokkimata"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon dokkimata"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Ühendatud doki seaded"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Dokki ei leitud"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Enne doki heli seadistamist peate tahvelarvuti dokkima."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Enne doki heli seadistamist peate telefoni dokkima."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Dokki sisestamise heli"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Esita heli tahvelarvuti sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Esita heli telefoni sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"Ära esita heli tahvelarvuti sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"Ära esita heli telefoni sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="account_settings" msgid="6403589284618783461">"Kontod"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Tööprofiili kontod – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Isikliku profiili kontod"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Töökonto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Isiklik konto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="1910951467596035063">"Otsing"</string>
    <string name="search_settings_summary" msgid="9205656546570654169">"Otsinguseadete ja -ajaloo haldamine"</string>
    <string name="display_settings" msgid="7965901687241669598">"Ekraan"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Pööra ekraani automaatselt"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Tahvelarvuti pööramisel automaatselt paigutuse ümberlülitamine"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Muuda telefoni pööramisel automaatselt orientatsiooni"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Tahvelarvuti pööramisel automaatselt paigutuse ümberlülitamine"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Muuda telefoni pööramisel automaatselt orientatsiooni"</string>
    <string name="brightness" msgid="8480105032417444275">"Heleduse tase"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Heledus"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Reguleeri ekraani heledust"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Kohanduv heledus"</string>
    <string name="auto_brightness_summary" msgid="1799041158760605375">"Heleduse optimeerimine valgustingimuste järgi"</string>
    <string name="night_display_title" msgid="2626451512200357686">"Öövalgus"</string>
    <string name="night_display_text" msgid="4535302797673277668">"Funktsioon Öövalgus toonib ekraani punaseks. Nii on hämaras ekraani mugavam vaadata ja sellelt teksti lugeda. See võib aidata teil hõlpsamini magama jääda."</string>
    <string name="night_display_category_schedule" msgid="2044072617637348966">"Ajastamine"</string>
    <string name="night_display_category_status" msgid="1952928783124400330">"Olek"</string>
    <string name="night_display_auto_mode_title" msgid="8046314360381608455">"Lülita automaatselt sisse"</string>
    <string name="night_display_auto_mode_never" msgid="6723636142053240947">"Mitte kunagi"</string>
    <string name="night_display_auto_mode_custom" msgid="6012300346981608242">"Kohandatud ajakava"</string>
    <string name="night_display_auto_mode_twilight" msgid="2123345097508167094">"Loojangust päikesetõusuni"</string>
    <string name="night_display_start_time_title" msgid="8918016772613689584">"Algusaeg"</string>
    <string name="night_display_end_time_title" msgid="8286061578083519350">"Lõppaeg"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Väljas / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="8865054549719499274">"Ära kunagi lülita automaatselt sisse"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="4962295097132112885">"Lülita automaatselt sisse kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="5520577516590422267">"Lülita automaatselt sisse päikeseloojangul"</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Sees / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="44005841579902825">"Ära kunagi lülita automaatselt välja"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="4350556852471560173">"Lülita automaatselt välja kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="6122152828111119250">"Lülita automaatselt välja päikesetõusul"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Unerežiim"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Ekraan lülitub välja"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Pärast <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> tegevusetust"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Taustapilt"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Muutke taustapilti"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Isikupärastage ekraani"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Taustapildi valimine:"</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Ekraanisäästja"</string>
    <string name="screensaver_settings_summary_either_long" msgid="2458481525925378465">"Kui on dokitud või puhkerežiimis ja laeb"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Kui on dokitud või laeb"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Laadimise ajal"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Kui on dokitud"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Välja"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1239088321034437608">"Kui soovite juhtida, mis juhtub telefoni dokkimisel ja/või puhkerežiimi lülitamisel, siis lülitage ekraanisäästja sisse."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8644479926302707286">"Millal ekraanisäästja käivitada?"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Alusta kohe"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Seaded"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Automaatne eredus"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Tõstke äratamiseks"</string>
    <string name="doze_title" msgid="2259176504273878294">"Ambientne ekraan"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Ekraan aktiveerub, kui saate märguandeid"</string>
    <string name="title_font_size" msgid="4405544325522105222">"Fondi suurus"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Teksti suuremaks või väiksemaks muutmine"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"SIM-kaardi luku seaded"</string>
    <string name="sim_lock_settings_category" msgid="5136244267576697004">"Seadista SIM-kaardi lukk"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"SIM-kaardi lukk"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"SIM-kaardi lukustamine"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Nõua tahvelarvuti kasutamiseks PIN-i"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Nõua telefoni kasutamiseks PIN-i"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Nõua tahvelarvuti kasutamiseks PIN-i"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Nõua telefoni kasutamiseks PIN-i"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Muuda SIM-kaardi PIN-koodi"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"SIM-kaardi PIN-kood"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"SIM-kaardi lukustamine"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Ava SIM-kaart"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"SIM-kaardi vana PIN-kood"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"SIM-kaardi uus PIN-kood"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Sisestage uus PIN-kood uuesti"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"SIM-kaardi PIN-kood"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Vale PIN-kood"</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"PIN-koodid ei kattu"</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"PIN-koodi ei saa muuta.\nPIN-kood võib vale olla."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"SIM-i PIN-koodi muutmine õnnestus"</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"SIM-kaardi lukustusolekut ei saa muuta.\nVõimalik, et PIN-kood on vale."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"OK"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Tühista"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Leiti mitu SIM-kaarti"</string>
    <string name="sim_multi_sims_summary" msgid="7018740080801483990">"Valige SIM-kaart, mida soovite eelistatult kasutada mobiilse andmeside jaoks."</string>
    <string name="sim_change_data_title" msgid="294357201685244532">"Muuta andmeside SIM-kaarti?"</string>
    <string name="sim_change_data_message" msgid="1313940695939674633">"Kas kasutada mobiilse andmeside jaoks kaardi <xliff:g id="OLD_SIM">%2$s</xliff:g> asemel kaarti <xliff:g id="NEW_SIM">%1$s</xliff:g>?"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Kas värskendada SIM-kaarti?"</string>
    <string name="sim_preferred_message" msgid="301251431163650167">"<xliff:g id="NEW_SIM">%1$s</xliff:g> on seadme ainus SIM-kaart. Kas soovite kasutada seda SIM-kaarti mobiilse andmeside, kõnede ja SMS-sõnumite jaoks?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Vale SIM-i PIN-kood, seadme avamiseks peate nüüd ühendust võtma oma operaatoriga."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="other">Vale SIM-kaardi PIN-kood, teil on jäänud veel <xliff:g id="NUMBER_1">%d</xliff:g> katset.</item>
      <item quantity="one">Vale SIM-kaardi PIN-kood, jäänud on <xliff:g id="NUMBER_0">%d</xliff:g> katse enne, kui peate seadme avam. operaatoriga ühendust võtma.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"SIM-i PIN-koodi toiming ebaõnnestus."</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Tahvelarvuti olek"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Telefoni olek"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Süsteemivärskendused"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Androidi versioon"</string>
    <string name="security_patch" msgid="8438384045870296634">"Androidi turvapaiga tase"</string>
    <string name="model_number" msgid="3765737700545384794">"Mudeli number"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"Seadme ID"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Põhiribaversioon"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Tuuma versioon"</string>
    <string name="build_number" msgid="3075795840572241758">"Järgunumber"</string>
    <string name="selinux_status" msgid="6212165375172061672">"SELinuxi olek"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Pole saadaval"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Olek"</string>
    <string name="device_status" msgid="607405385799807324">"Olek"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Aku laetuse, võrgu ja muu teave"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefoninumber, signaal jne"</string>
    <string name="storage_settings" msgid="4211799979832404953">"Mäluruum"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Salvestusruum"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Mäluruumi seaded"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"USB-mäluseadme lahutamine, saadaoleva mäluruumi kuvamine"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Eemalda SD-kaart, kuva saadaolev mäluruum"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Minu telefoninumber"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"PRL-versioon"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="952552009117455166">"Mobiilsidevõrgu tüüp"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Operaatori teave"</string>
    <string name="status_data_state" msgid="4578972321533789767">"Mobiilsidevõrgu olek"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Teenuse olek"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Signaali tugevus"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Rändlus"</string>
    <string name="status_operator" msgid="2274875196954742087">"Võrk"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"WiFi MAC-aadress"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Bluetoothi aadress"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Seerianumber"</string>
    <string name="status_unavailable" msgid="7862009036663793314">"Pole saadaval"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Talitlusaeg"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Sisselülitusaeg"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Sisemälu"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"USB-mäluseade"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"SD-kaart"</string>
    <string name="memory_available" msgid="5052397223077021181">"Saadaval"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Saadaval (kirjutuskaitstud)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Kogu ruum"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Arvutamine ..."</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Rakendused ja rakenduste andmed"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Meedium"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Allalaadimised"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Pildid, videod"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Heli (muusika, helinad, Interneti-saated jne)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Muud failid"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Vahemälus olevad andmed"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Lahuta jagatud mälu"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Lahutage SD-kaart"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Sisemise USB lahutamine"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"SD-kaardi lahutamine ohutuks eemaldamiseks"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"USB sisest. paigaldam.-ks"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Sisestage SD-kaart ühendamiseks"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Paigalda USB-mäluseade"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"SD-kaardi ühendamine"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Kustuta USB-mäluseade"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Kustuta SD-kaart"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Sisemisest USB-mäluseadmest kõikide andmete, nagu muusika ja fotode, kustutamine"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Kustutab SD-kaardilt kõik andmed, nagu muusika ja fotod"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Kas soovite vahemälus olevad andmed tühjendada?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"See tühjendab kõikide rakenduste vahemälus olevad andmed."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"MTP või PTP funktsioon on aktiivne"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Kas lahutada USB-seade?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Kas lahutada SD-kaart?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"USB-mäluseadme lahutamisel peatuvad mõned kasutatavad rakendused ega pruugi olla saadaval enne, kui USB-mäluseadme uuesti paigaldate."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"SD-kaardi lahutamisel peatuvad mõned töös olevad rakendused ega pruugi olla saadaval enne, kui SD-kaardi uuesti paigaldate."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="9191518889746166147">"USB-mäluseadet ei saanud lahutada. Proovige hiljem uuesti."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"SD-kaarti ei saanud lahutada. Proovige hiljem uuesti."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"USB-mäluseade lahutatakse."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"SD-kaart lahutatakse."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Eemaldamine"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Eemaldamine pooleli"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Talletusruum saab täis"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Mõned süsteemifunktsioonid, nt sünkroonimine, ei pruugi õigesti toimida. Proovige vabastada ruumi, kustutades üksusi, nt rakendusi või meediasisu, või eemaldades neid."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Ümbernimetamine"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Ühendamine"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Eemaldamine"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Vormindamine"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Vormindamine kaasaskantavana"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Vormindamine sisemisena"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Andmete üleviimine"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Unustamine"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Seadistus"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Avastamine"</string>
    <string name="storage_menu_free" msgid="6386070442027135427">"Ruumi vabastamine"</string>
    <string name="storage_menu_manage" msgid="5914482953856430780">"Salvestusruumi haldamine"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"USB-arvutiühendus"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Ühenda kui"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Meediumiseade (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"Võimaldab teisaldada meediafaile Windowsis või rakendusega Android File Transfer Macis (vt www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Kaamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Võimaldab edastada fotosid kaamera tarkvara abil ja edastada mis tahes faile arvutitest, mis ei toeta MTP-d."</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Võimaldab MIDI toega rakendustel teie arvutis oleva MIDI-tarkvara abil töötada USB kaudu."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Teised kasutajad"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Seadme salvestusruum"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Kaasaskantav salvestusruum"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"Kasutatud <xliff:g id="USED">%1$s</xliff:g> <xliff:g id="TOTAL">%2$s</xliff:g>-st"</string>
    <string name="storage_size_large" msgid="5691585991420946254">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="1303803057698959872">"Kasutatud <xliff:g id="TOTAL">%1$s</xliff:g>-st"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"Kokku kasutatud <xliff:g id="TOTAL">%1$s</xliff:g>-st"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"Üksus <xliff:g id="NAME">%1$s</xliff:g> ühendati"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Üksust <xliff:g id="NAME">%1$s</xliff:g> ei saanud ühendada"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"Üksus <xliff:g id="NAME">%1$s</xliff:g> eemaldati ohutult"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"Üksust <xliff:g id="NAME">%1$s</xliff:g> ei saanud ohutult eemaldada"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"Üksus <xliff:g id="NAME">%1$s</xliff:g> vormindati"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"Üksust <xliff:g id="NAME">%1$s</xliff:g> ei saanud vormindada"</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Salvestusruumi ümbernimetamine"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"Üksus <xliff:g id="NAME_0">^1</xliff:g> väljutati turvaliselt, kuid see on endiselt saadaval. \n\nÜksuse <xliff:g id="NAME_1">^1</xliff:g> kasutamiseks peate selle esmalt ühendama."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"Ü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_dialog_unsupported" msgid="4503128224360482228">"Seade ei toeta üksust <xliff:g id="NAME_0">^1</xliff:g>. \n\nÜksuse <xliff:g id="NAME_1">^1</xliff:g> kasutamiseks selle seadmega peate selle esmalt seadistama."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Pärast vormindamist saate üksust <xliff:g id="NAME_0">^1</xliff:g> kasutada teistes seadmetes. \n\nKõik üksuses <xliff:g id="NAME_1">^1</xliff:g> olevad andmed kustutatakse. Kaaluge esmalt nende varundamist. \n\n"<b>"Fotode ja muu meedia varundamine"</b>" \nTeisaldage oma meediafailid selle seadme teise salvestusruumi või kandke need USB-kaabli abil üle arvutisse. \n\n"<b>"Rakenduste varundamine"</b>" \nKõik üksusesse <xliff:g id="NAME_6">^1</xliff:g> salvestatud rakendused desinstallitakse ja nende andmed kustutatakse. Nende rakenduste säilitamiseks teisaldage need selle seadme teise salvestusruumi."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><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="9028875424669047327">"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="1370847944388479245">"Kas unustada <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Kõik üksusele <xliff:g id="NAME">^1</xliff:g> salvestatud rakendused, fotod ja andmed kaovad jäädavalt."</string>
    <string name="storage_detail_apps" msgid="6141154016753507490">"Rakendused"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Pildid"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Videod"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Heli"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Vahemälus olevad andmed"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Muu"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Süsteem"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Üksuse <xliff:g id="NAME">^1</xliff:g> avastamine"</string>
    <string name="storage_detail_dialog_other" msgid="5343550781234524040">"Muud failid hõlmavad rakenduste salvestatud faile, Internetist või Bluetoothi kaudu alla laaditud faile, Androidi faile jms. \n\nJaotise <xliff:g id="NAME">^1</xliff:g> kogu sisu vaatamiseks puudutage käsku Avasta."</string>
    <string name="storage_detail_dialog_system" msgid="3058775028564971102">"Süsteem sisaldab faile, mida Androidi operatsioonisüsteem kasutab sisemiselt. \n\nNeid faile ei saa üksikult vaadata."</string>
    <string name="storage_detail_dialog_user" msgid="1675756743326079688">"Kasutaja <xliff:g id="USER_0">^1</xliff:g> võib olla salvestanud fotosid, muusikat, filme, rakendusi või teisi andmeid, mis võtavad ruumi <xliff:g id="SIZE">^2</xliff:g>. \n\nÜksikasjade vaatamiseks lülitage kasutajale <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Seadista üksus <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Kasuta kaasaskantava salvestusruumina"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"Fotode ja muu meedia teisaldamiseks seadmete vahel."</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Kasuta sisemise salvestusruumina"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"Üksuste (sh rakendused ja fotod) ainult sellesse seadmesse salvestamiseks. Vajalik on vormindamine, mis takistab selle töötamist teistes seadmetes."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Vorminda sisem. salvestusruumina"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"Üksuse <xliff:g id="NAME_0">^1</xliff:g> turvaliseks muutmiseks tuleb see vormindada. \n\nPärast vormindamist töötab üksus <xliff:g id="NAME_1">^1</xliff:g> ainult selles seadmes. \n\n"<b>"Vormindamisel kustutatakse kõik praegu üksusesse <xliff:g id="NAME_2">^1</xliff:g> salvestatud andmed."</b>" Andmete kaotamise vältimiseks kaaluge nende varundamist."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Vorm. kaasask. salvestusruumina"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Seade <xliff:g id="NAME_0">^1</xliff:g> tuleb vormindada. \n\n"<b>"Vormindamisel kustutatakse kõik praegu seadmesse <xliff:g id="NAME_1">^1</xliff:g> salvestatud andmed."</b>" Andmete kaotsimineku vältimiseks kaaluge nende varundamist."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Kustuta ja vorminda"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"Üksuse <xliff:g id="NAME">^1</xliff:g> vormindamine …"</string>
    <string name="storage_wizard_format_progress_body" msgid="4445041233802828430">"Ärge eemaldage üksust <xliff:g id="NAME">^1</xliff:g> vormindamise ajal."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Teis. andmed uude salvestusruumi"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Saate fotod, failid ja mõned rakendused teisaldada uude üksusesse <xliff:g id="NAME">^1</xliff:g>. \n\nTeisaldamine võtab umbes <xliff:g id="TIME">^2</xliff:g> ja vabastab sisemises salvestusruumis <xliff:g id="SIZE">^3</xliff:g>. Selle toimingu ajal mõned rakendused ei tööta."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Teisalda kohe"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Teisalda hiljem"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Teisalda andmed kohe"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Teisaldamine võtab umbes <xliff:g id="TIME">^1</xliff:g>. See vabastab üksuses <xliff:g id="NAME">^3</xliff:g> <xliff:g id="SIZE">^2</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="5509475628423823202">"Teisalda"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Andmete teisaldamine …"</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Teisaldamise ajal: \n• ärge eemaldage üksust <xliff:g id="NAME">^1</xliff:g>; \n• ei tööta mõned rakendused korralikult; \n• hoidke seadet laetuna."</string>
    <string name="storage_wizard_ready_title" msgid="5381632402953258267">"Üksus <xliff:g id="NAME">^1</xliff:g> on valmis"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"Üksus <xliff:g id="NAME">^1</xliff:g> on valmis fotode ja muu meediaga kasutamiseks."</string>
    <string name="storage_wizard_ready_internal_body" msgid="122532674037860197">"Uus üksus <xliff:g id="NAME">^1</xliff:g> töötab. \n\nFotode, failide ja rakenduse andmete teisaldamiseks seadmesse avage menüü Seaded &gt; Salvestusruum."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Teisalda rakendus <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"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_progress_title" msgid="4443920302548035674">"Rakenduse <xliff:g id="APP">^1</xliff:g> teisaldamine …"</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Ä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_move_progress_cancel" msgid="542047237524588792">"Tühista teisaldamine"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Üksus <xliff:g id="NAME_0">^1</xliff:g> näib olevat aeglane. \n\nSaate jätkata, kuid sellesse asukohta teisaldatud rakendused võivad töötada katkendlikult ja andmete ülekandmine võib võtta kaua aega. \n\nParema toimivuse saavutamiseks kaaluge kiirema üksuse <xliff:g id="NAME_1">^1</xliff:g> kasutamist."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Aku olek"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Aku tase"</string>
    <string name="apn_settings" msgid="3743170484827528406">"Pääsupunktinimed"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Pääsupunkti muutmine"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Määramata"</string>
    <string name="apn_name" msgid="4115580098369824123">"Nimi"</string>
    <string name="apn_apn" msgid="2479425126733513353">"Pääsupunktnimi"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Puhverserver"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Port"</string>
    <string name="apn_user" msgid="455637547356117761">"Kasutajanimi"</string>
    <string name="apn_password" msgid="5412301994998250968">"Parool"</string>
    <string name="apn_server" msgid="2436185314756372858">"Server"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"MMS-i puhverserver"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"MMS-port"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Autentimise tüüp"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Puudub"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP või CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Pääsupunktinime tüüp"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"APN-i protokoll"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"APN-i rändlusprotokoll"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Luba/keela APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN on lubatud"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN on keelatud"</string>
    <string name="bearer" msgid="594270280031923558">"Kandja"</string>
    <string name="mvno_type" msgid="2543253857818336421">"MVNO tüüp"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"MVNO väärtus"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Kustuta pääsupunktinimi"</string>
    <string name="menu_new" msgid="3014205883303921729">"Uus pääsupunktinimi"</string>
    <string name="menu_save" msgid="8109345640668285399">"Salvesta"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Loobu"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Nimeväli ei tohi tühi olla."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"APN ei saa olla tühi."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"MCC-väli peab olema kolmekohaline."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"MNC-väli peab olema kahe- või kolmekohaline."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"APN-i vaikeseadete taastamine."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Lähtesta vaikeseadetele"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"APN-i vaikeseadete lähtestamine on lõpule viidud."</string>
    <string name="reset_network_title" msgid="4557113742173895074">"Võrguseadete lähtestamine"</string>
    <string name="reset_network_desc" msgid="581668983587311282">"See lähtestab kõik võrguseaded, sh:\n\n"<li>"WiFi"</li>\n<li>"mobiilne andmeside"</li>\n<li>"Bluetooth"</li></string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Lähtesta seaded"</string>
    <string name="reset_network_final_desc" msgid="6388371121099245116">"Kas lähtestada kõik võrguseaded? Seda toimingut ei saa tagasi võtta."</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Lähtesta seaded"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Kas lähtestada?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"Võrguseadete lähtestamine pole selle kasutaja puhul saadaval"</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Võrguseaded lähtestati"</string>
    <string name="device_reset_title" msgid="2384019005638768076">"Lähtesta seade"</string>
    <string name="master_clear_title" msgid="5907939616087039756">"Tehaseandmete lähtestamine"</string>
    <string name="master_clear_desc" product="tablet" msgid="9146059417023157222">"See kustutab kõik andmed teie tahvelarvuti "<b>"sisemälust"</b>", sh:\n\n"<li>"teie Google\'i konto"</li>\n<li>"süsteemi ja rakenduste andmed ning seaded"</li>\n<li>"Allalaaditud rakendused"</li></string>
    <string name="master_clear_desc" product="default" msgid="4800386183314202571">"See kustutab kõik andmed telefoni "<b>"sisemälust"</b>", sh:\n\n"<li>"teie Google\'i konto"</li>\n<li>"süsteemi ja rakenduse andmed ning seaded"</li>\n<li>"Allalaaditud rakendused"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Olete praegu sisse logitud järgmistele kontodele:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"Seadmes on teisi kasutajaid.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Muusika"</li>\n<li>"Fotod"</li>\n<li>"Muud kasutajaandmed"</li></string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Muusika, piltide ja muu kasutajateabe kustutamiseks tuleb tühjendada ka "<b>"USB-mäluseade"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Muusika, piltide ja muude kasutajaandmete kustutamiseks tuleb tühjendada ka "<b>"SD-kaart"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Kustuta USB-mäluseade"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Kustuta SD-kaart"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Sisemiselt USB-mäluseadmelt kõikide andmete (nt muusika või fotode) kustutamine"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"SD-kaardilt kõigi andmete (nt muusika või fotode) kustutamine"</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Lähtesta tahvelarvuti"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Lähtesta telefon"</string>
    <string name="master_clear_final_desc" msgid="7318683914280403086">"Kas kustutada kõik teie isiklikud andmed ja allalaaditud rakendused? Seda toimingut ei saa tagasi võtta."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Kustuta kõik"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Lähtestust ei tehtud, sest süsteemi kustutamise teenus pole saadaval."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Kas lähtestada?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Tehaseseadetele lähtestamine pole selle kasutaja puhul saadaval"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Kustutamine"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Oodake ..."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Kõneseaded"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Seadista kõnepost, kõne edastamine, ootel kõne, helistaja ID"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"USB jagamine"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Kantav tööpunkt"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Bluetoothi jagamine"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Jagamine"</string>
    <string name="tether_settings_title_all" msgid="8356136101061143841">"Jagam. ja kant. kuumkoht"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"Kui andmeside mahu säästja on sisse lülitatud, siis ei saa jagada ega kasutada teisaldatavat leviala"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"USB jagamine"</string>
    <string name="usb_tethering_available_subtext" msgid="156779271296152605">"USB ühendatud, märkige jagamiseks"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Jagatud"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="8427089411146908205">"Ei saa jagada, kui USB-mäluseade on kasutusel"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"USB ei ole ühendatud"</string>
    <string name="usb_tethering_turnon_subtext" msgid="4748616058219273033">"Ühendage sisselülitamiseks"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"USB jagamise viga"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Bluetoothi jagamine"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="4328374808439440517">"Tahvelarvuti Interneti-ühendust jagatakse"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="7451579908917710359">"Telefoni Interneti-ühenduse jagamine"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="7296104766087335891">"Tahvelarvuti Interneti-ühendust jagatakse 1 seadmega"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="2785474869740805972">"Telefoni Interneti-ühenduse jagamine 1 seadmega"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="7345108029216525495">"Selle tahvelarvuti Interneti-ühendust jagatakse <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> seadmega"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="2992288063706153665">"Selle telefoni Interneti-ühendust jagatakse <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> seadmega"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6630416508030836214">"Seadme <xliff:g id="DEVICE_NAME">%1$d</xliff:g> Interneti-ühenduse jagamine"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="3737828501935728137">"Tahvelarvuti Interneti-ühendust ei jagata"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="9099562374002272901">"Telefoni Interneti-ühendust ei jagata"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Jagamata"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="2135590598511178690">"Ei saa jagada rohkem kui <xliff:g id="MAXCONNECTION">%1$d</xliff:g> seadmele."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühenduse jagamine lõpetatakse."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Abi"</string>
    <string name="network_settings_title" msgid="4871233236744292831">"Mobiilsidevõrgud"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Mobiilipakett"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"SMS-i rakendus"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Kas muuta SMS-i rakendust?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"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="602683880284921998">"Kas kasutada SMS-i rakendusena rakendust <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Kas muuta WiFi Assistanti?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"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="7444620909047611601">"Kas kasutada võrguühenduste haldamiseks rakendust <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Tundmatu SIM-kaardi operaator"</string>
    <string name="mobile_no_provisioning_url" msgid="2399426808423775711">"Operaatoril %1$s pole teenusepakkumise veebisaite"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Sisestage SIM-kaart ja taaskäivitage"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Looge Interneti-ühendus"</string>
    <string name="location_title" msgid="1029961368397484576">"Minu asukoht"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Tööprofiili asukoht"</string>
    <string name="location_mode_title" msgid="3982009713118421689">"Režiim"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Väga täpne"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Aku säästmine"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Ainult seade"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Asukoht on väljas"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Hiljutised asukohapäringud"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Ükski rakendus pole hiljuti asukohateavet küsinud"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Asukohateenused"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Suur akukasutus"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Madala tarbimisega akukasutus"</string>
    <string name="location_mode_screen_title" msgid="4528716772270246542">"Asukoharežiim"</string>
    <string name="location_mode_high_accuracy_description" msgid="5703350404315028607">"Asukoha määramine GPS-i, WiFi-, Bluetoothi või mobiilsidevõrgu abil"</string>
    <string name="location_mode_battery_saving_description" msgid="8361848607963121770">"Asukoha määramine WiFi-, Bluetoothi või mobiilsidevõrgu abil"</string>
    <string name="location_mode_sensors_only_description" msgid="788127681455735699">"Kasutage asukoha määramiseks GPS-i"</string>
    <string name="location_menu_scanning" msgid="8536245838478802959">"Skannimine"</string>
    <string name="location_scanning_screen_title" msgid="4408076862929611554">"Skannimine"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"WiFi skannimine"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="8036382029606868081">"Parandab asukoha täpsust, lubades süsteemirakendustel ja -teenustel mis tahes ajal tuvastada WiFi-võrke."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Bluetoothi skannimine"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="8602726521250591852">"Parandab asukoha täpsust, lubades süsteemirakendustel ja -teenustel mis tahes ajal tuvastada Bluetoothi seadmeid."</string>
    <string name="location_network_based" msgid="6010456018401296590">"WiFi/mobiilsidevõrgu asukoht"</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Lubage rakendustel kasutada Google\'i asukohateenust, et asukohta kiiremini määrata. Kogutud anonüümsed asukohaandmed saadetakse Google\'ile."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"WiFi järgi määratud asukoht"</string>
    <string name="location_gps" msgid="8392461023569708478">"GPS-i satelliidid"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Lubage rakendustel tahvelarvuti GPS-i abil teie asukohta määrata"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Lubage rakendustel telefoni GPS-i abil teie asukohta määrata"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Kasuta abistatud GPS-i"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Kasuta serverit GPS-i abistamiseks (eemaldage märge võrgukasutuse vähendamiseks)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Kasutage serverit GPS-i assisteerimiseks (eemaldage märge GPS-i toimivuse parandamiseks)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Asukoht ja Google\'i otsing"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Lubage Google\'il otsingutulemuste ja muude teenuste parandamiseks kasutada teie asukohta"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Juurdepääs minu asukohale"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Laske rakendustel, mis on palunud teie luba, kasutada teie asukohateavet"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Asukohaallikad"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Teave tahvelarvuti kohta"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Telefoni kohta"</string>
    <string name="about_settings" product="emulator" msgid="221313099578564438">"Teave jäljendatud seadme kohta"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Vaadake juriidilist teavet, olekut, tarkvara versiooni"</string>
    <string name="legal_information" msgid="5769301644270604095">"Juriidiline teave"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Kaasautorid"</string>
    <string name="manual" msgid="3025943393642974445">"Käsitsi"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Regulatiivsildid"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Ohutus- ja regulatiivjuhend"</string>
    <string name="copyright_title" msgid="865906688917260647">"Autoriõigus"</string>
    <string name="license_title" msgid="1990487604356037871">"Litsents"</string>
    <string name="terms_title" msgid="7697580845616764642">"Nõuded ja tingimused"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Süsteemi WebView\' litsents"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Taustapildid"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Satelliitpiltide pakkujad:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Käsitsi"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Juhendi laadimisel ilmnes probleem."</string>
    <string name="settings_license_activity_title" msgid="7553683406244228650">"Avatud lähtekoodiga litsentsid"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Litsentside laadimisega on probleem."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Laadimine ..."</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Ohutusteave"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Ohutusteave"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="250674109915859456">"Teil ei ole andmesideühendust. Selle teabe vaatamiseks praegu minge Interneti-ühendusega arvutis aadressile %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Laadimine ..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Valige parool"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Mustri valimine"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Valige PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Kinnitage parool"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Kinnitage PIN-kood"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Paroolid ei ühti"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"PIN-koodid ei ühti"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Lukust avamise meetod"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Parool on määratud"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"PIN-kood on määratud"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Muster on määratud"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Jätkamiseks kasutage seadme mustrit"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Jätkamiseks sisestage seadme PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Jätkamiseks sisestage seadme parool"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Jätkamiseks kasutage oma tööprofiili mustrit"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Jätkamiseks sisestage oma tööprofiili PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Jätkamiseks sisestage oma tööprofiili parool"</string>
    <string name="lockpassword_strong_auth_required_reason_restart_device_pattern" msgid="8548464672947477043">"Jätkamiseks kasutage seadme mustrit. Seda on vaja pärast seadme taaskäivitamist."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_device_pin" msgid="8048122891934295280">"Jätkamiseks sisestage seadme PIN-kood. Seda on vaja pärast seadme taaskäivitamist."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_device_password" msgid="9007679426540259125">"Jätkamiseks sisestage seadme parool. Seda on vaja pärast seadme taaskäivitamist."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_pattern" msgid="7462071286473121099">"Jätkamiseks kasutage tööprofiili mustrit. Seda on vaja pärast seadme taaskäivitamist."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_pin" msgid="809763184419127790">"Jätkamiseks sisestage tööprofiili PIN-kood. Seda on vaja pärast seadme taaskäivitamist."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_password" msgid="8923861444535970646">"Jätkamiseks sisestage tööprofiili parool. Seda on vaja pärast seadme taaskäivitamist."</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"Vale PIN-kood"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Vale parool"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Vale muster"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Seadme turvalisus"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Muuda avamismustrit"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Muuda avamise PIN-koodi"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Joonistage avamismuster"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Abi saamiseks vajutage valikut Menüü."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Kui olete valmis, siis tõstke sõrm"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Ühendage vähemalt <xliff:g id="NUMBER">%d</xliff:g> punkti. Proovige uuesti."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Muster on salvestatud"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Joonistage muster kinnitamiseks uuesti"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Teie uus avamismuster"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Kinnita"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Koosta uuesti"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Kustuta"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Jätka"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Avamismuster"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Mustri nõudmine"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Ekraani avamiseks tuleb koostada muster"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Tee muster nähtavaks"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="4864525074768391381">"Muuda profiilimuster nähtavaks"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Vibreeri puudutamisel"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Lukus toitenupu vajutamisel"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"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="1652352830005653447">"Määra avamismuster"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Muuda avamismustrit"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Kuidas joonistada avamismustrit"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Liiga palju valesid katseid. Proovige uuesti <xliff:g id="NUMBER">%d</xliff:g> sekundi pärast."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Rakendus pole teie telefoni installitud."</string>
    <string name="lock_settings_profile_title" msgid="2121876391814535295">"Tööprofiili turvalisus"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3334747927367115256">"Tööprofiili ekraanilukk"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Kasutatakse ühte lukku"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Tööprofiili ja seadme ekraani puhul kasutatakse ühte lukku"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"Kas kasutada ühte lukku?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1787427605545808829">"Teie tööprofiil ja seadme ekraan kasutavad sama lukku. Teie seadme ekraaniluku puhul kehtivad ka kõik tööprofiili luku eeskirjad."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="3221303098797469900">"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="8249970828159656518">"Kasuta ühte lukku"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Kasuta ühte lukku"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Sama mis seadme ekraanilukk"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Halda rakendusi"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Installitud rakenduste haldamine ja eemaldamine"</string>
    <string name="applications_settings" msgid="1721442176406964682">"Rakendused"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Rakenduste haldamine, kiirkäivituse otseteede seadistamine"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Rakenduse seaded"</string>
    <string name="install_applications" msgid="4872012136210802181">"Tundmatud allikad"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Luba kõik rakenduse allikad"</string>
    <string name="install_unknown_applications_title" msgid="663831043139080992">"Lubab installida rakendusi muudest allikatest kui Google Play"</string>
    <string name="install_unknown_applications" msgid="176855644862942064">"Luba tundmatutest allikatest pärinevate rakenduste installimine"</string>
    <string name="install_all_warning" product="tablet" msgid="3263360446508268880">"Teie tahvelarvuti ja isikuandmed on haavatavamad rünnakutele rakenduste kaudu, mis pärinevad tundmatutest allikatest. Nõustute, et olete ainuisikuliselt vastutav tahvelarvuti kahjustuste või andmekao eest, mis võivad tuleneda nende rakenduste kasutamisest."</string>
    <string name="install_all_warning" product="default" msgid="8113734576826384682">"Telefon ja isiklikud andmed on rünnakute suhtes haavatavamad tundmatutest allikatest pärit rakenduste kaudu. Nõustute, et olete ainuisikuliselt vastutav telefoni kahjustuste või andmekao eest, mis võivad tuleneda nende rakenduste kasutusest."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Täpsemad seaded"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Luba rohkem seadete valikuid"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Rakenduse teave"</string>
    <string name="storage_label" msgid="8700867073480107253">"Mäluruum"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Avamine vaikimisi"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Vaikeseaded"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Ekraani ühilduvus"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Load"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Vahemälu"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Tühjenda vahemälu"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Vahemälu"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="3983110543017963732">
      <item quantity="other">%d üksust</item>
      <item quantity="one">1 üksus</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="8575655132961012158">"Tühista juurdepääs"</string>
    <string name="controls_label" msgid="7611113077086853799">"Juhtnupud"</string>
    <string name="force_stop" msgid="7435006169872876756">"Sunni peatuma"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Kokku"</string>
    <string name="application_size_label" msgid="8494609207373874267">"Rakendus"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Rakendus USB-mäluseadmel"</string>
    <string name="data_size_label" msgid="8679376373625710107">"Andmed"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"USB-mäluseadme andmed"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"SD-kaart"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Desinstalli"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Kõikidelt kasutajatelt desinstallimine"</string>
    <string name="install_text" msgid="884360662922471113">"Installi"</string>
    <string name="disable_text" msgid="6544054052049395202">"Keela"</string>
    <string name="enable_text" msgid="9217362512327828987">"Luba"</string>
    <string name="clear_user_data_text" msgid="5597622864770098388">"Kustuta andmed"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Desinstalli värskendused"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Olete otsustanud selle rakenduse mõne toimingu puhul käivitada vaikimisi."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Olete lubanud sellel rakendusel vidinaid luua ja nende andmetele juurde pääseda."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Vaikeväärtused pole määratud."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Kustuta vaikeväärtused"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"See rakendus ei pruugi teie ekraanile sobida. Sobivust saate kontrollida siin."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Küsi käivitamisel"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Skaleeri rakendus"</string>
    <string name="unknown" msgid="1592123443519355854">"Tundmatu"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Sordi nime alusel"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Sordi suuruse järgi"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Kuva töötavad teenused"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Kuva vahemällu salvestatud protsessid"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Hädaabirakendus"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Läht. rakend. eelistused"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Läht. rakend. eelistused?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"See lähtestab kõik järgmised eelistused:\n\n "<li>"Keelatud rakendused"</li>\n" "<li>"Keelatud rakenduse märguanded"</li>\n" "<li>"Toimingute vaikerakendused"</li>\n" "<li>"Rakenduste taustaandmete piirangud"</li>\n" "<li>"Igasugused lubade piirangud"</li>\n\n" Rakenduse andmed säilivad."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Lähtesta rakendused"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Halda ruumi"</string>
    <string name="filter" msgid="2018011724373033887">"Filter"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Filtrivalikute valimine"</string>
    <string name="filter_apps_all" msgid="5142129378749391876">"Kõik"</string>
    <string name="filter_apps_disabled" msgid="5364447573326472890">"Keelatud"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Allalaaditud"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Töös"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"USB-mäluseade"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"SD-kaardil"</string>
    <string name="disabled" msgid="9206776641295849915">"Keelatud"</string>
    <string name="not_installed" msgid="2797554494953450291">"Pole selle kasutaja jaoks installitud"</string>
    <string name="no_applications" msgid="7336588977497084921">"Rakendusi pole."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Sisemälu"</string>
    <string name="internal_storage_sentence" msgid="889098931914857143">"sisemine salvestusruum"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"USB-mäluseade"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"SD-kaardi mäluruum"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Suuruse ümberarvutamine ..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Kas kustutada rakenduse andmed?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Rakenduse kõik andmed kustutatakse lõplikult. See hõlmab kõiki faile, seadeid, kontosid, andmebaase jne."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"OK"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Tühista"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"Rakendust ei leitud installitud rakenduste loendist."</string>
    <string name="clear_data_failed" msgid="7214074331627422248">"Rakenduse andmete kustutamine ebaõnnestus."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Kustuta andmed"</string>
    <string name="clear_failed_dlg_text" msgid="5464475937929941008">"Rakenduse andmete tühjendamine ebaõnnestus."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"See rakendus pääseb teie tahvelarvutis juurde järgmisele:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Sel rakendusel on teie telefonis järgmised juurdepääsuõigused:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Sellel rakendusel on teie tahvelarvutis juurdepääs järgmisele. Toimivuse parandamiseks ja mälukasutuse vähendamiseks on mõned neist lubadest saadaval rakenduse <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> jaoks, kuna see töötab samas protsessis kui <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Sellel rakendusel on teie telefonis juurdepääs järgmisele. Toimivuse parandamiseks ja mälukasutuse vähendamiseks on mõned neist lubadest saadaval rakenduse <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> jaoks, kuna see töötab samas protsessis kui <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> ja <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="1873827777191260824">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="5925635036718502724">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> ja <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"See rakendus võib põhjustada tasusid:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Tasulise SMS-i saatmine"</string>
    <string name="computing_size" msgid="1599186977475211186">"Arvutamine ..."</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Paketi suurust ei saanud arvutada."</string>
    <string name="empty_list_msg" msgid="3552095537348807772">"Teil pole ühtegi kolmanda osapoole rakendust installitud."</string>
    <string name="version_text" msgid="9189073826278676425">"versioon <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Teisalda"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Teisalda tahvelarvutisse"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Teisalda telefoni"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Teisalda USB-mällu"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Teisalda SD-kaardile"</string>
    <string name="moving" msgid="6431016143218876491">"Teisaldamine"</string>
    <string name="another_migration_already_in_progress" msgid="7817354268848365487">"Teine üleviimine on juba pooleli."</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Ei ole piisavalt ruumi."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"Rakendust ei ole olemas."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Rakendus on kopeerimiskaitstud."</string>
    <string name="invalid_location" msgid="4354595459063675191">"Installimise asukoht ei ole kehtiv."</string>
    <string name="system_package" msgid="1352722848400644991">"Süsteemivärskendusi ei saa installida välisele kandjale."</string>
    <string name="move_error_device_admin" msgid="8148342933314166497">"Seadme administraatorit ei saa installida välisele meediakandjale."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Kas peatada sunniviisiliselt?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Kui sunnite rakenduse peatuma, võib see valesti käituda."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="187885379493011720">"Ei saa rakendust teisaldada. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Eelistatud installiasukoht"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Muutke uute rakenduste eelistatud installiasukohta"</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Kas keelata sisseeh. rakendus?"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Keela rakendus"</string>
    <string name="app_disable_dlg_text" msgid="7824930380425568584">"Rakenduse keelamisel ei pruugi muud rakendused enam ootuspäraselt töötada."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Kas kustutada andmed ja keelata rakendus?"</string>
    <string name="app_special_disable_dlg_text" msgid="1007112763234313018">"Rakenduse keelamisel ei pruugi muud rakendused enam ootuspäraselt töötada ja teie andmed kustutatakse."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Kas lülitada teatised välja?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Kui lülitate selle rakenduse teatised välja, võivad olulised märguanded ja värskendused märkamata jääda."</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Pood"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Rakenduse üksikasjad"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"Rakendus installiti poest <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_settings" msgid="5108481883575527511">"Rakenduse tööd"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Töötab"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Pole kasutatud)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Vaikerakendusi pole."</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Kasutatud mälu"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Vaadake rakenduste kasutatavat mälu"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Taaskäivitamine"</string>
    <string name="cached" msgid="1059590879740175019">"Vahemällu salvestatud taustaprotsess"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Midagi ei esitata"</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Käivitas rakendus"</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> vaba"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> kasutusel"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Kasutaja: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Eemaldatud kasutaja"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<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="8019860457123222953">"<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="744424668287252915">"<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="1607384595790852782">"<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="6588371727640789560">"Seadme mälu"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Rakenduse RAM-i kasutus"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Süsteem"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Rakendused"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Tasuta"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Kasutati"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"Vahemälus"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-i"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Käitatav rakendus"</string>
    <string name="no_services" msgid="7133900764462288263">"Pole aktiivne"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Teenused"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Protsessid"</string>
    <string name="service_stop" msgid="6369807553277527248">"Peata"</string>
    <string name="service_manage" msgid="1876642087421959194">"Seaded"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"Selle teenuse käivitas tema rakendus. Selle peatamine võib põhjustada rakenduse sulgemise."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Seda rakendust ei saa ohutult peatada. Peatamisel võite kaotada osa oma praegusest tööst."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"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="479683614471552426">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: praegu kasutusel. Puudutage selle juhtimiseks valikut Seaded."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Peamine protsess on kasutusel."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Teenus <xliff:g id="COMP_NAME">%1$s</xliff:g> on kasutusel."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Teenusepakkuja <xliff:g id="COMP_NAME">%1$s</xliff:g> on kasutusel."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Kas peatada süsteemi teenus?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Kui teenuse peatate, ei pruugi mõned tahvelarvuti funktsioonid õigesti töötada, kuni selle välja ja seejärel uuesti sisse lülitate."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Kui teenuse peatate, ei pruugi mõned telefoni funktsioonid õigesti töötada, kuni selle välja ja seejärel uuesti sisse lülitate."</string>
    <string name="language_settings" msgid="8758655933029560944">"Keeled ja sisend"</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Keeled ja sisend"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Klaviatuur ja sisestusmeetodid"</string>
    <string name="phone_language" msgid="7116581601133118044">"Keeled"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Automaatne asendamine"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Paranda valesti sisestatud sõnad"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Autom. suurtähtede kasut."</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Lausete alguses suurtähtede kasutamine"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Automaatsed kirjavahemärgid"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Füüsilise klaviatuuri seaded"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Vajutage kaks korda tühikuklahvi, et sisestada „.”"</string>
    <string name="show_password" msgid="3001113966880559611">"Muuda paroolid nähtavaks"</string>
    <string name="ime_security_warning" msgid="4135828934735934248">"See sisestusmeetod võib koguda kogu teie sisestatava teksti, sh isikuandmed (nt paroolid ja krediitkaardinumbrid). See pärineb rakendusest <xliff:g id="IME_APPLICATION_NAME">%1$s</xliff:g>. Kas soovite seda sisestusmeetodit kasutada?"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"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="246728645150092058">"Seaded"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Keel"</string>
    <string name="failed_to_open_app_settings_toast" msgid="1251067459298072462">"Rakenduse <xliff:g id="SPELL_APPLICATION_NAME">%1$s</xliff:g> seadete avamine ebaõnnestus"</string>
    <string name="keyboard_and_input_methods_category" msgid="212319666432360385">"Klaviatuur ja sisestusmeetodid"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Virtuaalne klaviatuur"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Saadaolev virtuaalne klaviatuur"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Klaviatuuride haldamine"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Klaviatuuri abi"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Füüsiline klaviatuur"</string>
    <string name="show_ime" msgid="2658582193437188227">"Virtuaalse klaviatuuri kuvamine"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Hoia seda ekraanil, kui füüsiline klaviatuur on aktiivne"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Klaviatuuri otseteede abiline"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Saadaolevate otseteede kuvamine"</string>
    <string name="default_keyboard_layout" msgid="4172606673510531271">"Vaikeseade"</string>
    <string name="pointer_settings_category" msgid="8183819795164034286">"Hiir/puuteplaat"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Kursori kiirus"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Mängukontroller"</string>
    <string name="vibrate_input_devices" msgid="2599591466928793082">"Kasuta värinat"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Suunab värina mängukontrollerisse, kui see on ühendatud."</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Klaviatuuri paigutuse valimine"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Seadista klaviatuuri paigutus"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Vahetamiseks vajutage Ctrl+tühikut"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Vaikepaigutus"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Klaviatuuri paigutused"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Isiklik sõnaraamat"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Lisa"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Lisa sõnastikku"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Fraas"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Rohkem valikuid"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Vähem valikuid"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Sõna:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Otsetee:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Keel:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Sisestage sõna"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Valikuline otsetee"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Muuda sõna"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Muuda"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Kustuta"</string>
    <string name="user_dict_settings_empty_text" msgid="1971969756133074922">"Kasutaja sõnaraamatus ei ole ühtki sõna. Sõna lisamiseks puudutage nuppu Lisa (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Kõikides keeltes"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Rohkem keeli ..."</string>
    <string name="testing" msgid="6584352735303604146">"Testimine"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Teave tahvelarvuti kohta"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Telefoni andmed"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Tekstisisestus"</string>
    <string name="input_method" msgid="5434026103176856164">"Sisestusmeetod"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Praegune klaviatuur"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Sisestusmeetodi valija"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automaatne"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Kuva alati"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Peida alati"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Sisestusmeetodite seadistamine"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Seaded"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Seaded"</string>
    <string name="active_input_method_subtypes" msgid="3596398805424733238">"Aktiivsed sisestusmeetodid"</string>
    <string name="use_system_language_to_select_input_method_subtypes" msgid="5747329075020379587">"Süsteemi keelte kasutamine"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Üksuse <xliff:g id="IME_NAME">%1$s</xliff:g> seaded"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Aktiivsete sisestusmeetodite valim."</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Ekraaniklaviatuuri seaded"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Füüsiline klaviatuur"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Füüsilise klaviatuuri seaded"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Valige vidin"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Valige vidin"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Kas luua vidin ja lubada juurdepääs?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Pärast vidina loomist saab <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> juurdepääsu kõikidele kuvatavatele andmetele."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Luba rakendusel <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> alati vidinaid luua ja nende andmetele juurdepääs hankida"</string>
    <string name="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g> p <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> m <xliff:g id="SECONDS">%4$d</xliff:g> s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> m <xliff:g id="SECONDS">%3$d</xliff:g> s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g> m <xliff:g id="SECONDS">%2$d</xliff:g> s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g>s"</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> p <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> min"</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Kasutusstatistika"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Kasutusstatistika"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Sortimisalus:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Rakendus"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Viimane kasutamine"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Kasutusaeg"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Juurdepääsetavus"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Juurdepääsetavuse seaded"</string>
    <string name="vision_settings_title" msgid="4204111425716868288">"Nähtavuse seaded"</string>
    <string name="vision_settings_description" msgid="5679491180156408260">"Seadet saab kohandada vastavalt oma vajadustele. Neid juurdepääsetavuse funktsioone saab hiljem muuta menüüs Seaded."</string>
    <string name="accessibility_services_title" msgid="2592221829284342237">"Teenused"</string>
    <string name="talkback_title" msgid="7912059827205988080">"TalkBack"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Peamiselt pimedatele ja halva nägemisega inimestele mõeldud ekraanilugeja"</string>
    <string name="accessibility_system_title" msgid="7187919089874130484">"Süsteem"</string>
    <string name="accessibility_display_title" msgid="7610175687949675162">"Ekraan"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Tiitrid"</string>
    <string name="accessibility_screen_magnification_title" msgid="9002237235486714636">"Suurendamise liigutus"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Suumimiseks puudutage kolm korda"</string>
    <string name="accessibility_screen_magnification_summary" msgid="7798920976388197258"><b>"Suumimiseks"</b>" puudutage ekraani ühe sõrmega kiiresti kolm korda.\n"<ul><li>"Kerimiseks lohistage kahte või enamat sõrme."</li>\n<li>"Suumi kohandamiseks liigutage kahte või enamat sõrme kokku või lahku."</li></ul>\n\n<b>"Ajutiseks suumimiseks"</b>" puudutage ekraani kiiresti kolm korda ja hoidke sõrme kolmandal puudutusel all.\n"<ul><li>"Ekraanil liikumiseks lohistage sõrme."</li>\n<li>"Väljasuumimiseks tõstke sõrm üles."</li></ul>\n\n"Klaviatuuril ja navigeerimisribal ei saa sisse suumida."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Juurdepääsetavuse otsetee"</string>
    <string name="accessibility_global_gesture_preference_summary_on" msgid="6180927399052022181">"Sees"</string>
    <string name="accessibility_global_gesture_preference_summary_off" msgid="8102103337813609849">"Välja"</string>
    <string name="accessibility_global_gesture_preference_description" msgid="1605107799571936715">"Kui see funktsioon on sisse lülitatud, saate juurdepääsetavuse funktsioonid kiiresti aktiveerida kahe toiminguga.\n\n1. toiming: vajutage ja hoidke all toitenuppu, kuni kuulete heli või tunnete vibratsiooni.\n\n2. toiming: puudutage pikalt kahe sõrmega, kuni kuulete helikinnitust.\n\nKui seadmel on mitu kasutajat, kasutage lukustusekraanil seda otseteed, et ajutiselt lubada juurdepääs seadme avamiseni."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Suure kontrastsusega tekst"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Ekraanisuurenduse värskendus"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Ekraanisuurenduse kasutus rakenduste vahetamisel"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Toitenupp lõpetab kõne"</string>
    <string name="accessibility_toggle_speak_password_preference_title" msgid="5986628515113204844">"Paroolide ettelugemine"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="535173100516295580">"Suur hiirekursor"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Monoheli"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Heli esitamisel ühendatakse kanalid"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Puute ja hoidmise viide"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Värvuste ümberpööramine"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="8658240868230680912">"(Katseline) võib mõjutada toimivust"</string>
    <string name="accessibility_autoclick_preference_title" msgid="7014499339068449623">"Klikk pärast kursori peatumist"</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Viide enne klikki"</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Kuva kiirseadetes"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Korrigeerimise režiim"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="other">Äärmiselt lühike viivitus (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Äärmiselt lühike viivitus (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay" formatted="false" msgid="5589565607652364932">
      <item quantity="other">Väga lühike viivitus (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Väga lühike viivitus (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5887754135102768400">
      <item quantity="other">Lühike viivitus (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Lühike viivitus (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="6340683412750219405">
      <item quantity="other">Pikk viivitus (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Pikk viivitus (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay" formatted="false" msgid="3503199424330634970">
      <item quantity="other">Väga pikk viivitus (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Väga pikk viivitus (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Seaded"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Sees"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Väljas"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Eelvaade"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Standardvalikud"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Keel"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Teksti suurus"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Tiitri stiil"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Kohandatud valikud"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Tausta värv"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Tausta läbipaistvus"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Tiitrite akna värv"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Tiitrite akna läbipaistvus"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Teksti värv"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Teksti läbipaistvus"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Serva värv"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Serva tüüp"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Fondi perekond"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Tiitrid näevad välja sellised"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Vaikeseade"</string>
    <string name="color_title" msgid="4258931051732243983">"Värv"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Vaikevärv"</string>
    <string name="color_none" msgid="3475640044925814795">"Puudub"</string>
    <string name="color_white" msgid="8045195170201590239">"Valge"</string>
    <string name="color_gray" msgid="9192312087142726313">"Hall"</string>
    <string name="color_black" msgid="7517353520909872561">"Must"</string>
    <string name="color_red" msgid="4949354900304125428">"Punane"</string>
    <string name="color_green" msgid="5537717328428845841">"Roheline"</string>
    <string name="color_blue" msgid="7731984529016953223">"Sinine"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Tsüaan"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Kollane"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Fuksia"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Kas soovite kasutada teenust <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> peab:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Seaded ei saa teie vastust kinnitada, sest rakendus varjab loataotlust."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Kui lülitate sisse teenuse <xliff:g id="SERVICE">%1$s</xliff:g>, ei kasuta seade andmete krüpteerimise täiustamiseks ekraanilukku."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Kuna lülitasite sisse juurdepääsetavuse teenuse, siis ei kasuta teie seade andmete krüpteerimise täiustamiseks ekraanilukku."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Kuna teenuse <xliff:g id="SERVICE">%1$s</xliff:g> sisselülitamine mõjutab andmete krüpteerimist, peate kinnitama oma mustri."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Kuna teenuse <xliff:g id="SERVICE">%1$s</xliff:g> sisselülitamine mõjutab andmete krüpteerimist, peate kinnitama oma PIN-koodi."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Kuna teenuse <xliff:g id="SERVICE">%1$s</xliff:g> sisselülitamine mõjutab andmete krüpteerimist, peate kinnitama oma parooli."</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Toimingute jälgimine"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="6640333613848713883">"Saama märguandeid, kui te kasutate rakendust."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Kas peatan teenuse <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2247101878627941561">"Kui puudutate valikut OK, siis teenus <xliff:g id="SERVICE">%1$s</xliff:g> peatub."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Ühtki teenust pole installitud"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Kirjeldust ei ole sisestatud."</string>
    <string name="settings_button" msgid="3006713718908152930">"Seaded"</string>
    <string name="print_settings" msgid="4742428530112487843">"Printimine"</string>
    <plurals name="print_settings_title" formatted="false" msgid="6994238166067938432">
      <item quantity="other">%d prinditööd</item>
      <item quantity="one">1 prinditöö</item>
    </plurals>
    <string name="print_settings_title" msgid="3685449667822217816">"Printimisteenused"</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Ühtki teenust pole installitud"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Printereid ei leitud"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Seaded"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Printerite lisamine"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Sees"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Väljas"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Lisa teenus"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Lisa printer"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Otsing"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Printerite otsimine"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Teenus on keelatud"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Prinditööd"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Prinditöö"</string>
    <string name="print_restart" msgid="8373999687329384202">"Taaskäivita"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Tühista"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> printimine"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> tühistamine"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Printeri viga: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Printer blokeeris töö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Otsingukast on kuvatud"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Otsingukast on peidetud"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Lisateave selle printeri kohta"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Aku"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Mis on akut kasutanud"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Aku andmed pole saadaval."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Jäänud on <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> laadimise lõpuni"</string>
    <string name="power_usage_list_summary" msgid="2409288197839512482">"Kasutus alates viimasest täislaadimisest"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Akukasutus alates lahutamisest"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Akukasutus alates lähtestamisest"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> akutoitel"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> alates lahutamisest"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Laadimine"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Ekraan sees"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS on sisse lülitatud"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Kaamera on sees"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Taskulamp on sees"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"WiFi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Sisse lülitatud"</string>
    <string name="battery_stats_phone_signal_label" msgid="3537569115723850618">"Mobiilsidevõrgu signaal"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Seadme ärkveloleku aeg"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"WiFi õigel ajal"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"WiFi õigel ajal"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Ajaloo üksikasjad"</string>
    <string name="details_title" msgid="3792801565213935385">"Üksikasjade kasutamine"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Kasuta detaile"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Reguleerige energiakasutust"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Kaasnevad paketid"</string>
    <string name="power_screen" msgid="3023346080675904613">"Ekraan"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Taskulamp"</string>
    <string name="power_camera" msgid="4976286950934622605">"Kaamera"</string>
    <string name="power_wifi" msgid="1135085252964054957">"WiFi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="6596471490976003056">"Mobiiltelefon ooterežiimil"</string>
    <string name="power_phone" msgid="5392641106474567277">"Tavakõned"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tahvelarvuti on ooterežiimis"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Telefon tegevuseta"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Muu"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Liigselt arvestatud"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"CPU kokku"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"CPU esiplaanil"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Hoia ärkvel"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"WiFi töötab"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tahvelarvuti"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Saadetud mob.-andmeside paketid"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Vastuvõetud m.-andmeside paketid"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Mobiiliraadio on aktiivne"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Saadetud WiFi-paketid"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Vastuvõetud WiFi-paketid"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Heli"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Kaamera"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Taskulamp"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Kestus"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Aeg ilma signaalita"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Aku koguvmahtuvus"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Arvutatud energiatarbimine"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Tuvastatud energiatarbimine"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Sunni peatuma"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Rakenduse teave"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Rakenduse seaded"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Ekraani seaded"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"WiFi-seaded"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Bluetoothi ​​seaded"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Tavakõnede akukasutus"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Akukasutus tahvelarvuti ooterežiimis"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Akukasutus telefoni ooterežiimis"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Mobiiltelefoni raadio akukasutus"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Aku säästmiseks lülitu mobiililevita kohtades lennurežiimile"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Taskulambi kasutatud akutoide"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Kaamera akukasutus"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Ekraani ja taustvalguse akukasutus"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Vähenda ekraani heledust ja/või ekraani ajalõppu"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"WiFi kasutatav aku"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Lülitage WiFi välja, kui te seda ei kasuta või see pole saadaval"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Bluetoothi akukasutus"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Kui te Bluetoothi ei kasuta, lülitage see välja"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Proovige ühendus luua teise Bluetoothi seadmega"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Rakenduse akukasutus"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Peatage või desinstallige rakendus"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Valige akut säästev režiim"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Rakendus võib pakkuda akukasutust vähendavaid seadeid"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Kasutaja akukasutus"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Muu energiatarbimine"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Akukasutus näitab ligikaudset energiatarbimist ega sisalda iga energiatarbimise allikat. Kategooria Muu kajastab arvutatud ligikaudse energiatarbimise ja aku tegeliku tarbimise vahet."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Liigselt arvestatud energiatarbimine"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> alates lahutamisest"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Alates viimasest lahutamisest <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Kasutus kokku"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Värskenda"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"Android OS"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Meediumiserver"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Rakenduse optimeerimine"</string>
    <string name="battery_saver" msgid="1426682272004907982">"Akusäästja"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Automaatne sisselülitamine"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Mitte kunagi"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="7536784431655058267">"%1$s akutaseme juures"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Protsessi statistika"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Tehnilised üksikasjad protsesside käitamise kohta"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Mälu kasutamine"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"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="6522457033380025618">"<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="3934992858120683459">"Taust"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"Esiplaan"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Vahemälus"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"Android OS"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Omaprotsessid"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Tuum"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Vahemälud"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"RAM-i kasutus"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"RAM-i kasutus (taustal)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Tööaeg"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Protsessid"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Teenused"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Kestus"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Mälu üksikasjad"</string>
    <string name="mem_state_subtitle" msgid="2407238869781011933">"Mälu olekud"</string>
    <string name="mem_use_subtitle" msgid="7319468770222422412">"Mälu kasutamine"</string>
    <string name="mem_use_kernel_type" msgid="8698327165935012484">"Tuum"</string>
    <string name="mem_use_native_type" msgid="5976704902328347400">"Kohalikud"</string>
    <string name="mem_use_kernel_cache_type" msgid="6411475064463957513">"Tuuma vahemälud"</string>
    <string name="mem_use_zram_type" msgid="9087217476795358232">"ZRami vahetus"</string>
    <string name="mem_use_free_type" msgid="717708548454880840">"Tasuta"</string>
    <string name="mem_use_total" msgid="6308786055749777934">"Kokku"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 tundi"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 tundi"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 tundi"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 päev"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Kuva süsteem"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Peida süsteem"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Kuva protsendid"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"USS-i kasutamine"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Statistika tüüp"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"Taust"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"Esiplaan"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Vahemälus"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Kõnesisend ja -väljund"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Kõnesisendi ja -väljundi seaded"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Häälotsing"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Androidi klaviatuur"</string>
    <string name="voice_category" msgid="1430370497125803904">"Kõne"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Häälsisendi seaded"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Häälsisend"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Häälsisendi teenused"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Täielik otsetee sõna ja interaktsioon"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Lihtne kõnesüntees"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"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="tts_reset_speech_rate_title" msgid="3993885027390495498">"Kõne kiiruse lähtestamine"</string>
    <string name="tts_reset_speech_rate_summary" msgid="8561618897094097540">"Teksti rääkimise kiirus lähtestatakse tavakiirusele."</string>
    <string name="gadget_title" msgid="5519037532720577836">"Toite juhtimine"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"WiFi-seade värskendamine"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Bluetoothi seade värskendamine"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"sees"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"väljas"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"sisselülitamine"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"väljalülitamine"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"WiFi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Asukoht"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Sünkroonimine"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Heledus <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"automaatne"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"täielik"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"poolik"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"väljas"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Mandaatide salvestusruum"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Salvestusseadmelt installimine"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"SD-kaardilt installimine"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Sertifikaatide installimine salvestusseadmelt"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Sertifikaatide installimine SD-kaardilt"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Mandaatide kustutamine"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Kõikide sertifikaatide eemaldamine"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Usaldusväärsed mandaadid"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Usaldusväärsete CA-sertifikaatide kuvamine"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Kasutaja mandaadid"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Salvestatud mandaatide vaatamine ja muutmine"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Täpsemad"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Salvestusruumi tüüp"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Riistvaratoega"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Ainult tarkvara"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Mandaadid pole selle kasutaja jaoks saadaval"</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Sisestage mandaadi salvestamise parool."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Kehtiv parool:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Kas eemaldada kogu sisu?"</string>
    <string name="credentials_password_too_short" msgid="7502749986405522663">"Parool peab olema vähemalt 8 tähemärki."</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Vale parool."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Vale parool. Teil on veel üks võimalus, enne kui mandaatide mälu kustutatakse."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Vale parool. Teil on veel <xliff:g id="NUMBER">%1$d</xliff:g> võimalus(t) enne, kui mandaatide mälu kustutatakse."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Mandaatide mälu kustutatakse."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Mand. mälu ei saanud kustut."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Mandaadi mälu on lubatud."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="6757119179588664966">"Enne mandaatide salvestusruumi kasutamist peate määrama lukustusekraani PIN-koodi või parooli."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Kasutusjuurdepääsuga rakend."</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Hädaabitoon"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Määra käitumine hädaabikõne korral"</string>
    <string name="privacy_settings" msgid="5446972770562918934">"Varundamine ja lähtestamine"</string>
    <string name="privacy_settings_title" msgid="4856282165773594890">"Varundamine ja lähtestamine"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Varundamine ja taastamine"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Isikuandmed"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Minu andmete varundamine"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Varundage rakenduse andmed, WiFi-paroolid ja muud seaded Google\'i serverites"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Varukonto"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Kaasa rakenduse andmed"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Automaatne taastamine"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Rakenduse uuesti installimisel taasta varundatud seaded ja andmed"</string>
    <string name="backup_inactive_title" msgid="5355557151569037197">"Varundamisteenus ei ole aktiivne."</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Ühelegi kontole ei ole praegu salvestatud varundatud andmeid"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"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="694766389396659626">"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="960850365007767734">"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="1335557832906433309">"Seadme haldusseaded"</string>
    <string name="active_device_admin_msg" msgid="6930903262612422111">"Seadme administraator"</string>
    <string name="remove_device_admin" msgid="7736174723276745230">"Inaktiveeri see seadme administraator"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Desinstalli rakendus"</string>
    <string name="remove_and_uninstall_device_admin" msgid="6983421266937728520">"Inaktiveeri ja desinstalli"</string>
    <string name="select_device_admin_msg" msgid="2645509057946368094">"Seadme administraatorid"</string>
    <string name="no_device_admins" msgid="702695100241728775">"Pole ühtegi seadme ülemat"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Isiklik"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Töö"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Saadaval pole ühtegi usaldusväärset agenti"</string>
    <string name="add_device_admin_msg" msgid="6246742476064507965">"Aktiveerin seadme administraatori?"</string>
    <string name="add_device_admin" msgid="1349673618141610506">"Aktiveeri see seadme administraator"</string>
    <string name="device_admin_add_title" msgid="7705551449705676363">"Seadme administraator"</string>
    <string name="device_admin_warning" msgid="2026747446313628233">"Selle administraatori aktiveerimisel lubatakse rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid:"</string>
    <string name="device_admin_status" msgid="4252975713178851910">"See administraator 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="6249331160676175009">"Kas aktiveerida profiilihaldur?"</string>
    <string name="adding_profile_owner_warning" msgid="8081841501073689534">"Jätkamisel haldab kasutajat administraator, kes võib salvestada ka seotud andmeid lisaks teie isiklikele andmetele.\n\nTeie administraator saab jälgida ja hallata selle kasutajaga seotud seadeid, juurdepääsu, rakendusi ning andmeid, sh võrgutegevust ja seadme asukohateavet."</string>
    <string name="admin_disabled_other_options" msgid="4564776259414246934">"Administraator on muud valikud keelanud."</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Rohkem üksikasju"</string>
    <string name="untitled_apn" msgid="1230060359198685513">"Pealkirjata"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Üldine"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Märguannete logi"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Kõne helin ja vibratsioon"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Süsteem"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"WiFi seadistamine"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"WiFi-võrguga <xliff:g id="NETWORK_NAME">%s</xliff:g> ühenduse loomine"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"WiFi-võrguga <xliff:g id="NETWORK_NAME">%s</xliff:g> ühenduse loomine ..."</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Ühendus on loodud WiFi-võrguga <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Võrgu lisamine"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Ühendus puudub"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Lisa võrk"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Värskenda loendit"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Jäta vahele"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Järgmine"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Tagasi"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Võrgu üksikasjad"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Ühenda"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Unusta"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Salvesta"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Tühista"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Võrkude skaneering ..."</string>
    <string name="wifi_setup_status_select_network" msgid="3960480613544747397">"Puudutage võrku sellega ühenduse loomiseks"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Ühenda olemasoleva võrguga"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Turvamata võrguga ühenduse loomine"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Sisestage võrgu konfigureerimine"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Uue võrguga ühenduse loomine"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Ühendamine ..."</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Minge järgmise sammu juurde"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="6796317704783144190">"EAP-d ei toetata."</string>
    <string name="wifi_setup_eap_not_supported" msgid="6812710317883658843">"Seadistamise ajal ei saa seadistada EAP WiFi-ühendust. Saate seda teha pärast seadistamise lõppu. Selleks tehke valikud Seaded &gt; Traadita ühendus ja võrgud."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Ühendamiseks võib kuluda mõni minut ..."</string>
    <string name="wifi_setup_description_connected" msgid="6649168170073219153">"Seadistamise jätkamiseks puudutage valikut "<b>"Järgmine"</b>".\n\nKui soovite luua ühenduse muu WiFi-võrguga, puudutage valikut "<b>"Tagasi"</b>"."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sünkroonimine lubatud"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sünkroonimine keelatud"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Kohe sünkroonimine"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Sünkroonimise viga"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sünkroonimine ebaõnnestus"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sünkroonimine on aktiivne"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sünkroonimine"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Sünkroonimisega on praegu probleeme. See on varsti tagasi."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Lisa konto"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Tööprofiil ei ole veel saadaval"</string>
    <string name="work_mode_label" msgid="5794470908668593961">"Töörežiim"</string>
    <string name="work_mode_summary" msgid="1620246003886940776">"Lubatakse tööprofiili toimingud, sh rakendused, taustal sünkroonimine ja seotud funktsioonid"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Eemalda tööprofiil"</string>
    <string name="background_data" msgid="5779592891375473817">"Andmeside kasutus taustal"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Rakendused saavad andmeid sünkroonida, saata ja vastu võtta"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Keel. taustaandmed?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Taustaandmete keelamine pikendab aku kestvust ja vähendab andmekasutust. Mõned rakendused võivad siiski andmesideühendusi taustal kasutada."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Rakenduse andmete automaatne sünkr."</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sünkroonim. on SEES"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sünkroonimine VÄLJAS"</string>
    <string name="sync_error" msgid="5060969083117872149">"Sünkroonimise viga"</string>
    <string name="last_synced" msgid="4242919465367022234">"Viimati sünkroonitud <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sünkroonimine ..."</string>
    <string name="settings_backup" msgid="2274732978260797031">"Varunda seaded"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Minu seadete varundamine"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sünkrooni kohe"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Loobu sünkroonimisest"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Puudutage kohe sünkroonimiseks<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Kalender"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Kontaktid"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Tere tulemast Google Synci!"</font>" \nSee on Google\'i meetod andmete sünkroonimiseks, mis tagab teile kõikjal juurdepääsu kontaktisikutele, kokkusaamistele ja muule."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Rakenduse sünkroonimisseaded"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Andmed ja sünkroonimine"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Parooli muutmine"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Konto seaded"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Eemalda konto"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Konto lisamine"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Lõpeta"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Kas eemaldada konto?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Selle konto eemaldamisel kustutatakse kõik seal olevad sõnumid, kontaktid ja muud tahvelarvutis olevad andmed."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Selle konto eemaldamisel kustutatakse kõik seal olevad sõnumid, kontaktid ja muud telefonis olevad andmed."</string>
    <string name="remove_account_failed" msgid="6980737964448187854">"Administraator ei luba sellist muudatust teha"</string>
    <string name="provider_label" msgid="7724593781904508866">"Vajutage tellimusi"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Ei saa käsitsi sünkroonida"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Selle üksuse sünkroonimine on praegu keelatud. Seade muutmiseks lülitage ajutiselt sisse taustaandmed ja automaatne sünkroonimine."</string>
    <string name="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"4G MAC-aadress"</string>
    <string name="enter_password" msgid="8035706727471334122">"Androidi käivitamiseks sisestage parool"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Androidi käivitamiseks sisestage oma PIN-kood"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Androidi käivitamiseks joonistage muster"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Vale muster"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Vale parool"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Vale PIN-kood"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Kontrollimine ..."</string>
    <string name="starting_android" msgid="4001324195902252681">"Androidi käivitamine ..."</string>
    <string name="delete" msgid="4219243412325163003">"Kustuta"</string>
    <string name="misc_files" msgid="6720680815969643497">"Mitmesugused failid"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"valitud <xliff:g id="NUMBER">%1$d</xliff:g>/<xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g>/<xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Vali kõik"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Andmekasutus"</string>
    <string name="data_usage_app_summary_title" msgid="4147258989837459172">"Rakenduse andmekasutus"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Operaatori andmemahuarvestus võib erineda seadme omast"</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Rakenduse kasutamine"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"RAKENDUSE TEAVE"</string>
    <string name="data_usage_cellular_data" msgid="4859424346276043677">"Mobiilne andmeside"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Andmemahupiirangu määramine"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Andmete kasutamistsükkel"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Rakenduse kasutamine"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Andmesiderändlus"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Piira taustaandmeid"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Taustaandmete lubamine"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Eraldi 4G kasutamine"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Kuva WiFi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"WiFi peitmine"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Kuva Etherneti-kasutus"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Etherneti kasut. peitmine"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Võrgupiirangud"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Andmete automaatne sünkroonimine"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"SIM-kaardid"</string>
    <string name="data_usage_menu_cellular_networks" msgid="5243515735055652279">"Mobiilsidevõrgud"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"Peatatud limiidi juures"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Andmete autom. sünkroonimine"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Isiklike andmete autom. sünk."</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Tööandmete autom. sünkroon."</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Tsükli muutmine ..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Kuupäev andmekasutustsükli lähtestamiseks:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Sel perioodil ei kasut. andmeid ükski rakendus."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Esiplaan"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Taust"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"piiratud"</string>
    <string name="data_usage_disable_mobile" msgid="2613595056882494652">"Kas lülitada sisse mobiilne andmeside?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="3934211003105066167">"Määra mob. andmem. piirang"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Määrake 4G andmemahupiirang"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Määrake 2G-3G andmemahupiirang"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Määra WiFi andmepiirang"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"WiFi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="2084466270343460491">"Mobiilside"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G–3G"</string>
    <string name="data_usage_list_mobile" msgid="7219011330831181312">"Mobiilside"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Mitte ükski"</string>
    <string name="data_usage_enable_mobile" msgid="5900650720568852325">"Mobiilne andmeside"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"2G–3G-andmeside"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"4G-andmeside"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Esiplaanil:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Taustal:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Rakenduse seaded"</string>
    <string name="data_usage_app_restrict_background" msgid="7359227831562303223">"Andmeside kasutus taustal"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="4669789008211107454">"Luba taustal mobiilse andmeside kasutus"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="1446565717342917727">"Rakend. taustandm. piiramiseks määrake mob. andmeside piirang."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Kas soovite taustandmeid piirata?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5871168521456832764">"Kui saadaval on ainult mobiilsidevõrgud, võib taustaandmeid kasutav rakendus selle funktsiooni tõttu lakata töötamast.\n\nVõite leida sobivamad andmekasutuse juhtimisvõimalused rakenduse seadetest."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="1493134803720421674">"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="2438617846762244389">"Kas lülitan andmete automaatse sünkroonimise sisse?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Veebis kontodel tehtud muudatused kopeeritakse automaatselt teie tahvelarvutisse.\n\nMõned kontod võivad ka kõik tahvelarvutis tehtud muudatused automaatselt veebi kopeerida. Google\'i konto toimib sellisel viisil."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Veebis kontodel tehtud muudatused kopeeritakse automaatselt teie telefoni.\n\nMõned kontod võivad ka kõik telefonis tehtud muudatused automaatselt veebi kopeerida. Google\'i konto toimib sellisel viisil."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Kas lülitan andmete automaatse sünkroonimise välja?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"See säästab andmeside mahu 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="1373797281540188533">"Kasutustsükli lähtestuskuupäev"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Igakuine kuupäev:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Määra"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Andmekasutuse hoiatuse määramine"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Andmekasutuse piirangu määramine"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Andmekasutuse piiramine"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="5788774061143636263">"Kui määratud limiit on täis, lülitab tahvelarvuti mobiilse andmeside välja.\n\nKuna andmekasutust mõõdab tahvelarvuti ja teie operaator või arvestada kasutust teisiti, siis võiksite määrata konservatiivse limiidi."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3511301596446820549">"Kui määratud limiit on täis, lülitab telefon mobiilse andmeside välja.\n\nKuna andmekasutust mõõdab telefon ja teie operaator või arvestada kasutust teisiti, siis võiksite määrata konservatiivse limiidi."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Kas soovite taustandmeid piirata?"</string>
    <string name="data_usage_restrict_background" msgid="6264965779074729381">"Kui piirate mobiilside taustandmeid, siis toimivad mõned rakendused ja teenused ainult siis, kui seade on ühendatud WiFi-võrku."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7954930300449415764">"Kui piirate mobiilside taustandmeid, siis toimivad mõned rakendused ja teenused ainult siis, kui seade on ühendatud WiFi-võrku.\n\nSeade mõjutab kõiki tahvelarvuti kasutajaid."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="259958321968870600">"Kui piirate mobiilside taustandmeid, siis toimivad mõned rakendused ja teenused ainult siis, kui seade on ühendatud WiFi-võrku.\n\nSeade mõjutab kõiki telefoni kasutajaid."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><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="860566507375933039"><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="614263770923231598">"Eemaldatud rakendused"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Eemaldatud rakendused ja kasutajad"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"<xliff:g id="RECEIVED">%1$s</xliff:g> vastu võetud, <xliff:g id="SENT">%2$s</xliff:g> saadetud"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: kasutatud umbes <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="1925687342154538972">"<xliff:g id="RANGE">%2$s</xliff:g>: tahvelarvuti mõõdetud kasutus u <xliff:g id="TOTAL">%1$s</xliff:g>. Oper. andmekasutuse arvestus võib erineda."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g>: telef. mõõdetud kasutus on u <xliff:g id="TOTAL">%1$s</xliff:g>. Operaatori andmekasutuse arvestus võib erineda."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Võrgupiirangud"</string>
    <string name="data_usage_metered_body" msgid="3262343834446126044">"Kui andmeside kasutus taustal on piiratud, siis käideldakse mahupõhiseid võrke nagu mobiilsidevõrke. Rakendused võivad kuvada hoiatuse, enne kui neid võrke kasutatakse suurte failide allalaadimiseks."</string>
    <string name="data_usage_metered_mobile" msgid="2326986339431119372">"Mobiilsidevõrgud"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Mahupõhised WiFi-võrgud"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Mahupõhiste võrkude valimiseks lülitage WiFi sisse."</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Operaatori andmemahuarvestus võib erineda seadme omast"</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Hädaabikõne"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Tagasi kõne juurde"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Nimi"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Tüüp"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Serveri aadress"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"PPP krüpteerimine (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"L2TP saladus"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"IPSeci tunnus"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"IPSeci eeljagatud võti"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"IPSeci kasutaja sertifikaat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"IPSeci CA-sertifikaat"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Serveri IPSeci sertifikaat"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Kuva täpsemad valikud"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"DNS-i otsingudomeenid"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"DNS-serverid (nt 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Edastamismarsruudid (nt 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Kasutajanimi"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Parool"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Salvesta kontoteave"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(ei kasutata)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(ära kinnita serverit)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(serverist saadud)"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Tühista"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Loobu"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Salvesta"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Ühenda"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Asenda"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"VPN-i profiili muutmine"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Unusta"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Profiiliga <xliff:g id="PROFILE">%s</xliff:g> ühendamine"</string>
    <string name="vpn_disconnect_confirm" msgid="2555877026824771115">"Katkestage ühendus selle VPN-iga."</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Katkesta ühendus"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Versioon <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="2232239391189465752">"Unusta VPN"</string>
    <string name="vpn_replace_always_on_vpn_title" msgid="3010435028275752220">"Kas asendada olemasolev VPN?"</string>
    <string name="vpn_replace_always_on_vpn_message" msgid="4764679857158814028">"Teil juba on ühendus VPN-iga. Kui jätkate mõne teisega, asendatakse teie olemasolev VPN."</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"<xliff:g id="VPN_NAME">%1$s</xliff:g> ei saa ühendust luua"</string>
    <string name="vpn_cant_connect_message" msgid="2593197919352621279">"See rakendus ei toeta alati sisselülitatud VPN-i."</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"VPN-i profiili lisamine"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Muuda profiili"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Kustuta profiil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Alati sees VPN"</string>
    <string name="vpn_no_vpns_added" msgid="4308317205962153438">"Ühtegi VPN-i pole lisatud."</string>
    <string name="vpn_always_on_active" msgid="2789423425184556882">"Valik Alati sees on aktiivne"</string>
    <string name="vpn_not_supported_by_this_app" msgid="5002053874215892179">"Rakendus ei toeta seda"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"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="9214462857336483711">"Puudub"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Alati sees VPN-i jaoks on vaja IP-aadressi nii serverile kui ka DNS-ile."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Võrguühendus puudub. Proovige hiljem uuesti."</string>
    <string name="vpn_missing_cert" msgid="7972907102570411501">"Sertifikaat on puudu. Muutke profiili."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Süsteem"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Kasutaja"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Keela"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Luba"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Eemalda"</string>
    <string name="trusted_credentials_trust_label" msgid="8003264222650785429">"Usalda"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Kas lubada süsteemi CA-sertifikaat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Kas keelata süsteemi CA-sertifikaat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Kas eemaldada kasutaja CA-sertifikaat jäädavalt?"</string>
    <string name="one_userkey" msgid="6034020579534914349">"üks kasutajavõti"</string>
    <string name="one_usercrt" msgid="2150319011101639509">"üks kasutaja sertifikaat"</string>
    <string name="one_cacrt" msgid="6844397037970164809">"üks CA-sertifikaat"</string>
    <string name="n_cacrts" msgid="5979300323482053820">"%d CA-sertifikaati"</string>
    <string name="user_credential_title" msgid="1329449215749665378">"Mandaadi üksikasjad"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Õigekirjakontroll"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Sisestage oma täieliku varukoopia praegune parool siia"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Sisestage täielike varukoopiate uus parool siia"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Sisestage siia uuesti oma täieliku varukoopia uus parool"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Varukoopia määramine"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Tühista"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Süsteemi lisavärskendused"</string>
    <string name="selinux_status_disabled" msgid="924551035552323327">"Keelatud"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Lubav"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Jõustumisel"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Võrku võidakse jälgida"</string>
    <string name="done_button" msgid="1991471253042622230">"Valmis"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <item quantity="other">Sertifikaatide usaldamine või eemaldamine</item>
      <item quantity="one">Sertifikaadi usaldamine või eemaldamine</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="1489335297837656666">
      <item quantity="other">Domeen <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> installis teie seadmesse sertifikaadi volitused, mis võivad lubada jälgida teie seadme võrgutegevusi (sh meilid, rakendused ja turvalised veebisaidid).\n\nLisateabe saamiseks nende sertifikaatide kohta võtke ühendust administraatoriga.</item>
      <item quantity="one">Domeen <xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> installis teie seadmesse sertifikaadi volituse, mis võib lubada jälgida teie seadme võrgutegevusi (sh meilid, rakendused ja turvalised veebisaidid).\n\nLisateabe saamiseks selle sertifikaadi kohta võtke ühendust administraatoriga.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="30645643499556573">
      <item quantity="other">Domeen <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> installis teie tööprofiilile sertifikaadi volitused, mis võivad lubada jälgida töökoha võrgutegevusi (sh meilid, rakendused ja turvalised veebisaidid).\n\nLisateabe saamiseks nende sertifikaatide kohta võtke ühendust administraatoriga.</item>
      <item quantity="one">Domeen <xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> installis teie tööprofiilile sertifikaadi volituse, mis võib lubada jälgida töökoha võrgutegevusi (sh meilid, rakendused ja turvalised veebisaidid).\n\nLisateabe saamiseks selle sertifikaadi kohta võtke ühendust administraatoriga.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"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>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="2426799352517325228">
      <item quantity="other">Kontrollige sertifikaate</item>
      <item quantity="one">Kontrollige sertifikaati</item>
    </plurals>
    <string name="user_settings_title" msgid="6151874007858148344">"Kasutajad"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Kasutajad ja profiilid"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Lisa kasutaja või profiil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Kasutaja lisamine"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Piiratud profiil"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"Enne piiratud profiili loomist peate seadistama lukustusekraani, et oma rakendusi ja isiklikke andmeid kaitsta."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Määra lukk"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Pole seadistatud"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Pole seadistatud – piiratud profiil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Seadistamata – tööprofiil"</string>
    <string name="user_admin" msgid="993402590002400782">"Administraator"</string>
    <string name="user_you" msgid="1639158809315025986">"Teie (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Hüüdnimi"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Lisamine"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Saate lisada kuni <xliff:g id="USER_COUNT">%1$d</xliff:g> kasutajat"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Kasutajatel on oma rakendused ja sisu"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Oma kontol saate piirata juurdepääsu rakendustele ja sisule"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Kasutaja"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Piiratud profiil"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Kas lisada uus kasutaja?"</string>
    <string name="user_add_user_message_long" msgid="8562152293752222985">"Võite jagada seadet teiste inimestega, luues uusi kasutajaid. Igal kasutajal on oma ruum, mida saab kohandada rakenduste, taustapildi ja muuga. Kasutajad saavad kohandada ka seadme seadeid, näiteks WiFi-valikuid, mis mõjutavad kõiki kasutajaid.\n\nKui lisate uue kasutaja, siis peab ta seadistama oma ruumi.\n\nIga kasutaja saab värskendada rakendusi kõigi kasutajate jaoks."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Kui lisate uue kasutaja, siis peab ta seadistama oma ruumi.\n\nIga kasutaja saab värskendada rakendusi kõigi kasutajate jaoks."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Kas seadistada nüüd kasutaja?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Veenduge, et isik saaks seadet kasutada ja oma ruumi seadistada"</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Kas soovite kohe profiili seadistada?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Seadista nüüd"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Mitte praegu"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Ainult tahvelarvuti omanik saab hallata kasutajaid."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Ainult telefoni omanik saab hallata kasutajaid."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Piiratud profiilid ei saa kontosid lisada"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Kustuta seadmest <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Lukustuskuva seaded"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2250956835192699766">"Kasutajate lisamine"</string>
    <string name="user_add_on_lockscreen_menu_summary" msgid="133203601188164761">"kui seade on lukus"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Uus kasutaja"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Uus profiil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Kas soovite kustutada iseenda?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Kas eemaldada kasutaja?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Kas eemaldada profiil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Kas eemaldada tööprofiil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"Kaotate selles tahvelarvutis olevad ruumi ja andmed. Seda toimingut ei saa tagasi võtta."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"Kaotate selles telefonis olevad ruumi ja andmed. Seda toimingut ei saa tagasi võtta."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Kõik rakendused ja andmed kustutatakse."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Kui jätkate, kustutatakse kõik selle profiili rakendused ja andmed."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Kõik rakendused ja andmed kustutatakse."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Uue kasutaja lisamine ..."</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Kasutaja kustutamine"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Kustuta"</string>
    <string name="user_guest" msgid="8475274842845401871">"Külaline"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Eemalda külaline"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Kas eemaldada külaline?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Seansi kõik rakendused ja andmed kustutatakse."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Eemalda"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Lülita telefonikõned sisse"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Lülita telefonikõned ja SMS-id sisse"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Kasutaja eemaldamine"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Kas lülitada telefonikõned sisse?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Selle kasutajaga jagatakse kõneajalugu."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Kas lülitada telefonikõned ja SMS-id sisse?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"Selle kasutajaga jagatakse kõne- ja SMS-ajalugu."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Hädaabiteave"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Rakenduste ja sisu lubamine"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Piirangutega rakendused"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Laienda rakenduste seadeid"</string>
    <string name="home_app_uninstall_button" msgid="6808453012607962899">"Desinstalli see rakendus"</string>
    <string name="only_one_home_message" msgid="3538846733750242759">"Avalehe seaded peidetakse, kuni installite mõne teise avalehe rakenduse."</string>
    <string name="global_change_warning" product="tablet" msgid="8045013389464294039">"Seade mõjutab kõiki tahvelarvuti kasutajaid."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Seade mõjutab kõiki telefoni kasutajaid."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Muuda keelt"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Puuduta ja maksa"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Kuidas see toimib?"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Makske poes oma telefoniga"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Vaikemakseviis"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Määramata"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="3234730182120288495">"Kasuta vaikerakendust"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Alati"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Välja arvatud siis, kui mõni teine makserakendus on avatud"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Maksa funktsiooni Puuduta ja maksa terminalis rakendusega"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Terminali kaudu maksmine"</string>
    <string name="nfc_how_it_works_content" msgid="4749007806393224934">"Seadistage makserakendus. Seejärel peate oma telefoni tagakülge hoidma lihtsalt mis tahes terminali suunas, millel on kontaktivaba makse sümbol."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"Selge"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Rohkem ..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Kas määrata eelistuseks?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Kas kasutada funktsiooniga Puuduta ja maksa alati rakendust <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Kas kasutada funktsiooni Puuduta ja maksa puhul alati rakenduse <xliff:g id="APP_1">%2$s</xliff:g> asemel rakendust <xliff:g id="APP_0">%1$s</xliff:g>?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Piirangud"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Eemalda piirangud"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Muuda PIN-koodi"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Kuva teatised"</string>
    <string name="help_label" msgid="6886837949306318591">"Abi ja tagasiside"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Sisu konto"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"Foto ID"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Väga ohtlikud olukorrad"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Häirete vastuvõtmine, kui ilmneb väga tõsine oht elule ja varale"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Ohtlikud olukorrad"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Häirete vastuvõtmine, kui ilmneb tõsine oht elule ja varale"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Lasteröövi märguanded"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Teadaannete vastuvõtmine lasteröövide kohta"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Kordamine"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Kõnehalduri lubamine"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Lubage sellel teenusel hallata, kuidas kõnesid tehakse."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Kõnehaldur"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2451014351355183338">"Hädaolukorra ülekanded"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Võrguoperaatorid"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Pääsupunktide nimed"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Tõhustatud 4G LTE režiim"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"LTE-andmete kasutamine hääle- ja sidekvaliteedi täiustamiseks (soovitatav)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Eelistatud võrgutüüp"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (soovitatav)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Töökoha SIM-kaart"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Juurdepääs rakendusele ja sisule"</string>
    <string name="user_rename" msgid="8523499513614655279">"NIMETA ÜMBER"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Rakendusele piirangute määramine"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Juhib: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"See rakendus pääseb teie kontode juurde"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Sellel rakendusel on juurdepääs teie kontodele. Juhib: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"WiFi ja mobiilne andmeside"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"WiFi ja mobiilse andmeside seadete muutmise lubamine"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Bluetoothi sidumiste ja seadete muutmise lubamine"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Luba andmevahetus, kui <xliff:g id="DEVICE_NAME">%1$s</xliff:g> puudutab teist NFC-seadet"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Andmete vahetuse lubamine, kui tahvelarvuti puudutab teist seadet"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Andmete vahetuse lubamine, kui telefon puudutab teist seadet"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Asukoht"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Rakendustel asukohateabe kasutamise lubamine"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Tagasi"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Järgmine"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Lõpeta"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Jäädvusta foto"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Vali foto galeriist"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Foto valimine"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"SIM-kaardid"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"SIM-kaardid"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"SIM-kaardid on muutunud"</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Puudutage tegevuste määramiseks"</string>
    <string name="sim_cellular_data_unavailable" msgid="9018555543451203035">"Mobiilne andmeside pole saadaval"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Puudutage andmeside SIM-kaardi valimiseks"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Kasuta helistamiseks alati seda"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Andmete SIM-kaardi valimine"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Andmete SIM-kaardi vahetamine, selleks võib kuluda kuni üks minut ..."</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Helistamine SIM-kaardiga"</string>
    <string name="sim_select_card" msgid="211285163525563293">"SIM-kaardi valimine"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"SIM-kaart on tühi"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"SIM-kaardi nimi"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Sisestage SIM-kaardi nimi"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"SIM-kaardi pesa %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operaator"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Number"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"SIM-kaardi värv"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"SIM-kaardi valimine"</string>
    <string name="color_orange" msgid="4417567658855022517">"Oranž"</string>
    <string name="color_purple" msgid="3888532466427762504">"Lilla"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Ühtegi SIM-kaarti pole sisestatud"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"SIM-kaardi olek"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Tagasihelistamine vaike-SIM-kaardilt"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"SIM-kaart väljuvate kõnede jaoks"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Muud kõne seaded"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Eelist. võrgu mahalaad."</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Võrgunime levitamise keelamine"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Võrgunime levitamise keelamine ei lase kolmandatel osapooltel hankida juurdepääsu teie võrguteabele."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Võrgunime levitamise keelamine takistab automaatset ühendamist varjatud võrkudega."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<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="6272913297433198340">"SIM-kaardid on muutunud."</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Puudutage seadistamiseks"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Eelistatud SIM-kaart:"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Küsi iga kord"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Valik on tegemata"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Seaded"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Seaded"</string>
    <string name="search_menu" msgid="6283419262313758339">"Otsingu seaded"</string>
    <string name="query_hint_text" msgid="3350700807437473939">"Otsinguseaded"</string>
    <string name="search_recents_queries_label" msgid="2128811638532309069">"Hiljutised otsingud"</string>
    <string name="search_results_label" msgid="4163304782363526148">"Tulemused"</string>
    <string name="keywords_wifi" msgid="1395786161993828719">"wifi, wi-fi, võrguühendus"</string>
    <string name="keywords_more_default_sms_app" msgid="2265154063220360784">"tekstsõnum, SMS-i saatmine, sõnumid, sõnumside"</string>
    <string name="keywords_more_mobile_networks" msgid="1538131503712402851">"mobiil, mobiilioperaator, traadita, andmed, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"wifi, wi-fi, kõne, helistamine"</string>
    <string name="keywords_home" msgid="3626170808219458848">"käivitaja"</string>
    <string name="keywords_display" msgid="8910345814565493016">"ekraan, puuteekraan"</string>
    <string name="keywords_display_brightness_level" msgid="3891383826236015854">"ekraani hämardamine, puuteekraan, aku"</string>
    <string name="keywords_display_auto_brightness" msgid="3325150824507953765">"ekraani hämardamine, puuteekraan, aku"</string>
    <string name="keywords_display_night_display" msgid="7630169927425425754">"ekraani hämardamine, öö, toon"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"taust, isikupärastamine, ekraani kohandamine"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"teksti suurus"</string>
    <string name="keywords_display_cast_screen" msgid="7684618996741933067">"projekt, ülekandmine"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"ruum, ketas, kõvaketas, seadme kasutus"</string>
    <string name="keywords_battery" msgid="1173830745699768388">"energiakasutus, laadimine"</string>
    <string name="keywords_spell_checker" msgid="1399641226370605729">"õigekiri, sõnastik, õigekirjakontroll, automaatne korrigeerimine"</string>
    <string name="keywords_voice_input" msgid="769778245192531102">"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="5150660047085754699">"hinda, keel, vaikimisi, kõnele, kõnelemine, TTS, juurdepääsetavus, ekraanilugeja, pime"</string>
    <string name="keywords_date_and_time" msgid="758325881602648204">"24-tunnine kell"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"lähtesta, taasta, tehaseseaded"</string>
    <string name="keywords_factory_data_reset" msgid="5894970373671252165">"pühi, kustuta, taasta, tühista, eemalda"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"printer"</string>
    <string name="keywords_sounds" msgid="7146245090127541167">"kõlar piiks"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"mitte segada, katkesta, katkestus, paus"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="6615286961552714686">"läheduses, asukohaajalugu, aruandlus"</string>
    <string name="keywords_location_mode" msgid="8584992704568356084">"täpsus"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"konto"</string>
    <string name="keywords_users" msgid="3434190133131387942">"piirang, piira, piiratud"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"tekstiparandus, paranda, heli, vibreeri, automaatne, keel, liigutus, soovita, soovitus, teema, solvav, sõna, tüüp, emotikon, rahvusvaheline"</string>
    <string name="keywords_reset_apps" msgid="5293291209613191845">"lähtestamine, eelistused, vaikeseade"</string>
    <string name="keywords_emergency_app" msgid="3143078441279044780">"hädaabi, ICE, rakendus, vaikimisi"</string>
    <string name="keywords_default_phone_app" msgid="4213090563141778486">"telefon, helistamine, vaikerakendus"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"rakendused, allalaadimine, rakendused, süsteem"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"rakendused, load, turvalisus"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"rakendused, vaikimisi"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"optimeerimiste ignoreerimine, Doze, rakenduse ooterežiim"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"ere, RGB, SRGB, värv, loomulik, tavaline"</string>
    <string name="keywords_color_temperature" msgid="2688947724153266364">"värvitemperatuur D65 D73 valge kollane sinine soe külm"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"libista avamiseks, parool, muster, PIN"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"töö väljakutse, töö, profiil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"tööprofiil, hallatud profiil, ühenda, ühendamine, töö, profiil"</string>
    <string name="keywords_gesture" msgid="5696040361482126337">"liigutus"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"WiFi NFC-kiibi seadistamine"</string>
    <string name="write_tag" msgid="8571858602896222537">"Kirjuta"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Kirjutamiseks puudutage kiipi ..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Vale parool, proovige uuesti."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Õnnestus!"</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"NFC-kiibile ei saa andmeid kirjutada. Kui probleem püsib, proovige muud kiipi"</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"NFC-kiip ei ole kirjutatav. Kasutage muud kiipi."</string>
    <string name="default_sound" msgid="8821684447333687810">"Vaikeheli"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Helina helitugevus on <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Helina helitugevus on 80%"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Meedia helitugevus"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Alarmi helitugevus"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Helina helitugevus"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Märguande helitugevus"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Telefoni helin"</string>
    <string name="notification_ringtone_title" msgid="3361201340352664272">"Märguande vaikehelin"</string>
    <string name="alarm_ringtone_title" msgid="2015124067611102995">"Äratuse vaikehelin"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Vibreeri ka kõnede puhul"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Muud helid"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Valimisklahvistiku toonid"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Ekraani lukustamise helid"</string>
    <string name="charging_sounds_title" msgid="1132272552057504251">"Laadimise helid"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Dokkimise helid"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Puutehelid"</string>
    <string name="vibrate_on_touch_title" msgid="5388579924689395023">"Vibreeri puudutamisel"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Kõlari dokkimise heli"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Kogu heli"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Ainult meedia heli"</string>
    <string name="emergency_tone_silent" msgid="1067515631635824291">"Hääletu"</string>
    <string name="emergency_tone_alert" msgid="8941852695428130667">"Märguanne"</string>
    <string name="emergency_tone_vibrate" msgid="8281126443204950847">"Vibratsioon"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Sisselülitamise helid"</string>
    <string name="zen_mode_settings_title" msgid="2689740350895257590">"Mitte segada"</string>
    <string name="zen_mode_priority_settings_title" msgid="2623117023031824309">"Prioriteetne lubab ainult"</string>
    <string name="zen_mode_automation_settings_title" msgid="4228995740594063774">"Automaatsed reeglid"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="3373871113435938830">"Ajakava Mitte segada määramine"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="8554080399360506596">"Seade vaigist. teatud aegadel"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Ainult prioriteetsed"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Ainult alarmid"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Täielik vaikus"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="6751708745442997940">"Visuaalsete häirimiste blok."</string>
    <string name="configure_notification_settings" msgid="3558846607192693233">"Märguannete seadistamine"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Täpsemad"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Töö märguanded"</string>
    <string name="notification_pulse_title" msgid="1247988024534030629">"Vilkuv märguande tuli"</string>
    <string name="lock_screen_notifications_title" msgid="6173076173408887213">"Lukustuskuval"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Kuva kogu märguande sisu"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7891552853357258782">"Peida märguande tundlik sisu"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Ära kuva märguandeid üldse"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Kuidas tuleks märguanded kuvada siis, kui seade on lukus?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1416589393106326972">"Märguanded"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Kuva töökoha märguannete kogu sisu"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="256116258285695645">"Peida töökoha märguannete tundlik sisu"</string>
    <string name="lock_screen_notifications_summary_disable_profile" msgid="4080720698960233358">"Ära kuva töökoha märguandeid üldse"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"Kuidas tuleks profiili märguanded kuvada siis, kui seade on lukus?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Profiili märguanded"</string>
    <string name="app_notifications_title" msgid="139788604658984593">"Märguanded"</string>
    <string name="notification_importance_title" msgid="848692592679312666">"Tähtsus"</string>
    <string name="notification_importance_none" msgid="3173515479356106227">"Määramata"</string>
    <string name="notification_importance_blocked" msgid="4348392266695847526">"Ära kuva kunagi selle rakenduse märguandeid"</string>
    <string name="notification_importance_min" msgid="1859001310034196751">"Täisekr. häirimine, servas kuvamine, helis. ega vibreerimine pole lubatud. Kuva märguannete loendi allosas. Peida lukustuskuval ja olekuribal."</string>
    <string name="notification_importance_low" msgid="1466326143251705794">"Täisekraanil häirimine, ekraani servas kuvamine, helisemine ega vibreerimine pole lubatud."</string>
    <string name="notification_importance_default" msgid="2857618184137114962">"Täisekraanil häirimine ega ekraani servas kuvamine pole lubatud."</string>
    <string name="notification_importance_high" msgid="495354850199578732">"Kuva alati ekraani servas. Täisekraanil häirimine pole lubatud."</string>
    <string name="notification_importance_max" msgid="7538045535631915413">"Kuva alati ekraani servas ja luba täisekraanil häirimine. Kuva märguannete loendi ülaosas."</string>
    <string name="notification_importance_unspecified" msgid="6172151762388245221">"Rakendus määrab iga märguande tähtsuse"</string>
    <string name="importance_reset" msgid="7458420788555607007">"Lähtesta"</string>
    <string name="show_silently" msgid="2222875799232222056">"Kuva vaikselt"</string>
    <string name="show_silently_summary" msgid="7616604629123146565">"Ära tee heli, vibreeri ega kuva neid märguandeid praeguse ekraani servas."</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Juurdepääs märguannetele"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Rakendused ei suuda märguandeid lugeda"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="other">%d rakendust saavad lugeda märguandeid</item>
      <item quantity="one">%d rakendus saab lugeda märguandeid</item>
    </plurals>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Ükski installitud rakendus pole taotlenud märguande juurdepääsu."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"Kas lubada teenusel <xliff:g id="SERVICE">%1$s</xliff:g> märguannetele juurde pääseda?"</string>
    <string name="notification_listener_security_warning_summary" msgid="119203147791040151">"Teenus <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> saab lugeda kõiki märguandeid, sh isiklikke andmeid, nagu kontaktide nimed ja teile saadetud tekstsõnumid. See saab ka loobuda märguannetest või aktiveerida märguannetes olevaid toimingunuppe. \n\nSee võimaldab ka rakendusel lülitada sisse või välja funktsiooni Mitte segada ja muuta sellega seotud seadeid."</string>
    <string name="notification_listener_disable_warning_summary" msgid="6738915379642948000">"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="8333442186428083057">"Lülita välja"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Tühista"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Virtuaalreaalse abilise teenused"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Ükski installitud rakendus pole taotlenud virtuaalreaalse abilise teenusena käitamist."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Kas lubada virtuaalreaalse teenuse juurdepääs teenusele <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="6931541068825094653">"Virtuaalreaalses režiimis kuulajat <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> saab käitada, kui kasutate rakendusi virtuaalreaalses režiimis."</string>
    <string name="display_vr_pref_title" msgid="7049857952347953979">"Kui seade on virtuaalreaalsuse režiimis"</string>
    <string name="display_vr_pref_low_persistence" msgid="6221441245293606681">"Kasuta vähese liikumisest tuleneva hägususe seadeid"</string>
    <string name="display_vr_pref_off" msgid="1244880066079174840">"Ära tee midagi"</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Juurdepääs funktsioonile Mitte segada"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Ükski installitud rakendus pole palunud juurdepääsu funktsioonile Mitte segada"</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Rakenduste laadimine ..."</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Blokeeri kõik"</string>
    <string name="app_notification_block_summary" msgid="9049487483231233726">"Ära kuva kunagi selle rakenduse märguandeid"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Funktsiooni Mitte segada alistamine"</string>
    <string name="app_notification_override_dnd_summary" msgid="3516007157020189746">"Lubage nendel märguannetel teid jätkuvalt katkestada, kui funktsioon Mitte segada on määratud valikule Ainult prioriteetsed"</string>
    <string name="app_notification_visibility_override_title" msgid="2187232730902430718">"Lukustuskuval"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokeeritud"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prioriteet"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Tundlik"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Valmis"</string>
    <string name="app_notification_importance_title" msgid="8002263131149345584">"Tähtsus"</string>
    <string name="zen_mode_rule_name" msgid="5149068059383837549">"Reegli nimi"</string>
    <string name="zen_mode_rule_name_hint" msgid="3781174510556433384">"Reegli nime sisestamine"</string>
    <string name="zen_mode_rule_name_warning" msgid="4517805381294494314">"Reegli nimi on juba kasutusel"</string>
    <string name="zen_mode_add_rule" msgid="9100929184624317193">"Reegli lisamine"</string>
    <string name="zen_mode_delete_rule" msgid="2985902330199039533">"Reegli kustutamine"</string>
    <string name="zen_mode_choose_rule_type" msgid="5423746638871953459">"Reegli tüübi valimine"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Kas kustutada reegel „<xliff:g id="RULE">%1$s</xliff:g>”?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Kustuta"</string>
    <string name="zen_mode_rule_type" msgid="2289413469580142888">"Reegli tüüp"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"Teadmata"</string>
    <string name="zen_mode_configure_rule" msgid="8865785428056490305">"Reegli seadistamine"</string>
    <string name="zen_schedule_rule_type_name" msgid="142936744435271449">"Kellaaja reegel"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Automaatne reegel on teatud kellaaegade puhul määratud sisse lülitama funktsiooni Mitte segada"</string>
    <string name="zen_event_rule_type_name" msgid="2645981990973086797">"Sündmuse reegel"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Automaatne reegel on teatud sündmuste puhul määratud sisse lülitama funktsiooni Mitte segada"</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Sündmuste ajal:"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Sündmuste ajal kalendris <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"mis tahes kalender"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"Kus vastus on <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"Mis tahes kalender"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"Kui vastus on"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"Jah, Võib-olla või Pole vastanud"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"Jah või Võib-olla"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Jah"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"Reeglit ei leitud."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="976098744828219297">"Sees / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="2101201392041867409">"<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="3195058680641389948">"Päevad"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Puudub"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Iga päev"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="767054141267122030">"Äratus võib lõppaja alistada"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="4597050434723180422">"Peata lõppajal või järgmise äratuse korral sellest olenevalt, kumb varem saabub."</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"<xliff:g id="START">%1$s</xliff:g> kuni <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="7051492091133751208">"Kõned"</string>
    <string name="zen_mode_messages" msgid="5886440273537510894">"Sõnumid"</string>
    <string name="zen_mode_all_messages" msgid="6449223378976743208">"Kõik sõnumid"</string>
    <string name="zen_mode_selected_messages" msgid="8245990149599142281">"Valitud sõnumid"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"Kõigilt"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Ainult kontaktidelt"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Ainult tärniga tähistatud kontaktidelt"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Puudub"</string>
    <string name="zen_mode_alarms" msgid="2165302777886552926">"Alarmid"</string>
    <string name="zen_mode_reminders" msgid="5458502056440485730">"Meeldetuletused"</string>
    <string name="zen_mode_events" msgid="7914446030988618264">"Sündmused"</string>
    <string name="zen_mode_all_callers" msgid="584186167367236922">"Kõik helistajad"</string>
    <string name="zen_mode_selected_callers" msgid="3127598874060615742">"Valitud helistajad"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Korduvad helistajad"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="7192713032364140137">"Kui sama inimene helistab <xliff:g id="MINUTES">%d</xliff:g> minuti jooksul teist korda, siis see lubatakse"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Autom. sisselülitus"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Mitte kunagi"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Igal õhtul"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Argiõhtuti"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Algusaeg"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Lõppaeg"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> järgmisel päeval"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Muudetakse määramata ajaks valikule Ainult alarmid"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="other">Muudetakse valikule Ainult alarmid <xliff:g id="DURATION">%1$d</xliff:g> minutiks (kellani <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="one">Muudetakse valikule Ainult alarmid üheks minutiks kellani <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="2407703455581767748">
      <item quantity="other">Muudetakse valikule Ainult alarmid <xliff:g id="DURATION">%1$d</xliff:g> tunniks kellani <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="one">Muudetakse valikule Ainult alarmid üheks tunniks kellani <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="7465525754879341907">"Muudetakse valikule Ainult alarmid kuni kella <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Muudetakse valikule Katkesta alati"</string>
    <string name="zen_mode_screen_on" msgid="7712038508173845101">"Blokeeri, kui ekraan on sees"</string>
    <string name="zen_mode_screen_on_summary" msgid="6444425984146305149">"Keelab režiimiga Mitte segada vaigistatud märguannete piilumise või ekraanile ilmumise"</string>
    <string name="zen_mode_screen_off" msgid="5026854939192419879">"Blokeeri, kui ekraan on väljas"</string>
    <string name="zen_mode_screen_off_summary" msgid="6490932947651798094">"Keelab režiimiga Mitte segada vaigistatud märguannetel ekraani sisse lülitada või märguandetuld vilgutada"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="3758698381956461866">"Keelatakse režiimiga Mitte segada vaigistatud märguannete sisselülitamine ekraanil"</string>
    <string name="zen_mode_all_visual_interruptions" msgid="2851308980832487411">"Väljas"</string>
    <string name="zen_mode_screen_on_visual_interruptions" msgid="7373348148129140528">"Kui ekraan on sees"</string>
    <string name="zen_mode_screen_off_visual_interruptions" msgid="4850792880144382633">"Kui ekraan on väljas"</string>
    <string name="zen_mode_no_visual_interruptions" msgid="8742776003822778472">"Kui ekraan on sees või väljas"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Märguandeseaded"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Seadme kohta tagasiside saatmine"</string>
    <string name="restr_pin_enter_admin_pin" msgid="2451187374960131018">"Administraatori PIN-koodi sisestamine"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Sees"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Väljas"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Ekraanikuva kinnitamine"</string>
    <string name="screen_pinning_description" msgid="3360904523688769289">"Kui seade on s. lülitatud, võite ekraanikuva kinnitada. Nii jääb kuva avatuks, kuni selle tühistate.\n\nEkraanikuva kinnit. tehke järgmist.\n\n1. Veenduge, et ekraanikuva kinnit. oleks sisse lülitatud.\n\n2. Avage kuva, mille soovite kinnitada.\n\n3. Puud. valikut Ülevaade.\n\n4. Pühkige üles ja puud. kinnitamisikooni."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Enne vabastamist küsi avamismustrit"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Enne vabastamist küsi PIN-koodi"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Enne vabastamist küsi parooli"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Vabastamise korral lukusta seade"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Seda tööprofiili hallatakse rakendusega"</string>
    <string name="managing_admin" msgid="8843802210377459055">"Haldab <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Katseline)"</string>
    <string name="display_auto_rotate_title" msgid="6176450657107806043">"Kui seade on pööratud"</string>
    <string name="display_auto_rotate_rotate" msgid="4544299861233497728">"Ekraanikuva sisu pööramine"</string>
    <string name="display_auto_rotate_stay_in_portrait" msgid="292745182318093651">"Vertikaalkuva säilitamine"</string>
    <string name="display_auto_rotate_stay_in_landscape" msgid="3804752830204062162">"Horisontaalkuva säilitamine"</string>
    <string name="display_auto_rotate_stay_in_current" msgid="317932372686498096">"Praeguse suuna säilitamine"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"IMEI teave"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Turvaline käivitamine"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Jätka"</string>
    <string name="encryption_interstitial_message_pin" msgid="7164072567822375682">"Seadme täiendavaks kaitsmiseks võite määrata, et seade nõuab käivitumiseks PIN-koodi sisestamist. Kuni seade pole käivitunud, ei saa see vastu võtta kõnesid, sõnumeid ega märguandeid, sh alarme. \n\nSee aitab kaitsta andmeid seadme kaotsimineku või varguse korral."</string>
    <string name="encryption_interstitial_message_pattern" msgid="6747091924626566031">"Seadme täiendavaks kaitsmiseks võite määrata, et seade nõuab käivitumiseks mustri sisestamist. Kuni seade pole käivitunud, ei saa see vastu võtta kõnesid, sõnumeid ega märguandeid, sh alarme. \n\nSee aitab kaitsta andmeid seadme kaotsimineku või varguse korral."</string>
    <string name="encryption_interstitial_message_password" msgid="3462225324186045679">"Seadme täiendavaks kaitsmiseks võite määrata, et seade nõuab käivitumiseks parooli sisestamist. Kuni seade pole käivitunud, ei saa see vastu võtta kõnesid, sõnumeid ega märguandeid, sh alarme. \n\nSee aitab kaitsta andmeid seadme kaotsimineku või varguse korral."</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="3775537118799831558">"Lisaks sõrmejälje kasutamisele seadme avamiseks saate oma seadet kaitsta ka PIN-koodi küsimisega enne käivitamist. Enne seadme käivitamist ei saa see vastu võtta kõnesid, sõnumeid ega märguandeid, sh alarme.\n\nSee aitab kaitsta kadunud või varastatud seadmes olevaid andmeid."</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="1105290967535237237">"Lisaks sõrmejälje kasutamisele seadme avamiseks saate oma seadet kaitsta ka mustri küsimisega enne käivitamist. Enne seadme käivitamist ei saa see vastu võtta kõnesid, sõnumeid ega märguandeid, sh alarme.\n\nSee aitab kaitsta kadunud või varastatud seadmes olevaid andmeid."</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="3512482682507378424">"Lisaks sõrmejälje kasutamisele seadme avamiseks saate oma seadet kaitsta ka parooli küsimisega enne käivitamist. Enne seadme käivitamist ei saa see vastu võtta kõnesid, sõnumeid ega märguandeid, sh alarme.\n\nSee aitab kaitsta kadunud või varastatud seadmes olevaid andmeid."</string>
    <string name="encrypt_require_pin" msgid="2063945047845243752">"Nõua seadme käivitamiseks PIN-koodi sisestamist"</string>
    <string name="encrypt_require_pattern" msgid="6898479411004015810">"Nõua seadme käivitamiseks mustri sisestamist"</string>
    <string name="encrypt_require_password" msgid="8770628366276570518">"Nõua seadme käivitamiseks parooli sisestamist"</string>
    <string name="encrypt_dont_require_pin" msgid="1082444817726247368">"Tänan, ei"</string>
    <string name="encrypt_dont_require_pattern" msgid="6668299362640433843">"Tänan, ei"</string>
    <string name="encrypt_dont_require_password" msgid="2580403214917009046">"Tänan, ei"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Kas nõuda PIN-koodi?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Kas nõuda mustrit?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Kas nõuda parooli?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Kui sisestate PIN-koodi seadme käivitamiseks, siis pole juurdepääsetavusteenused (nagu <xliff:g id="SERVICE">%1$s</xliff:g>) saadaval."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Kui sisestate mustri seadme käivitamiseks, siis pole juurdepääsetavusteenused (nagu <xliff:g id="SERVICE">%1$s</xliff:g>) saadaval."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Kui sisestate parooli seadme käivitamiseks, siis pole juurdepääsetavusteenused (nagu <xliff:g id="SERVICE">%1$s</xliff:g>) saadaval."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="7870273558547549125">"Märkus. Pärast taaskäivitamist ei saa see rakendus käivituda enne, kui olete telefoni avanud"</string>
    <string name="imei_information_title" msgid="8499085421609752290">"IMEI teave"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"IMEI suhteline teave"</string>
    <string name="slot_number" msgid="3762676044904653577">"(<xliff:g id="SLOT_NUM">%1$d</xliff:g>. pesa)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Ava vaikimisi"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"Tüübis <xliff:g id="STORAGE_TYPE">%2$s</xliff:g> on kasutusel <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Linkide avamine"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Toetatud linkide avamine"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Avamine ilma küsimata"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Toetatud lingid"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Muud vaikeseaded"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"Tüübis <xliff:g id="STORAGE_TYPE">%2$s</xliff:g> on kasutusel <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="410824961149037234">"sisemälu"</string>
    <string name="storage_type_external" msgid="8928374515368986503">"väline mälu"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Sisemine salvestusruum"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Väline salvestusruum"</string>
    <string name="app_data_usage" msgid="7942375313697452803">"Rakenduse andmekasutus"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"<xliff:g id="SIZE">%1$s</xliff:g> kasut. alates <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Kasutatud salvestusruum"</string>
    <string name="change" msgid="6657848623929839991">"Muuda"</string>
    <string name="change_storage" msgid="600475265207060436">"Salvestusruumi muutmine"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Märguanded"</string>
    <string name="notifications_enabled" msgid="4386196629684749507">"Tavaline"</string>
    <string name="notifications_disabled" msgid="3200751656741989335">"Blokeeritud"</string>
    <string name="notifications_silenced" msgid="4728603513072110381">"Vaigistatud"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Lukustuskuval ei näidata tundlikku sisu"</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"Pole lukustuskuval"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"Režiim Mitte segada alistati"</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"%d. tase"</string>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> luba on antud</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> luba on antud</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="1564663886246010959">
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g>/<xliff:g id="COUNT_3">%d</xliff:g> loast on antud</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g>/<xliff:g id="COUNT_1">%d</xliff:g> loast on antud</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> täiendavat luba</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> täiendav luba</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Lube ei antud"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Lube ei taotletud"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Kõik rakendused"</string>
    <string name="filter_enabled_apps" msgid="3318021007093070639">"Lubatud"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Isiklik"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Töö"</string>
    <string name="filter_notif_blocked_apps" msgid="3446926933792244485">"Blokeeritud"</string>
    <string name="filter_with_domain_urls_apps" msgid="4573276638806792792">"Domeeni URL-idega"</string>
    <string name="filter_notif_priority_apps" msgid="5056470299318500609">"Alistab valiku Mitte segada"</string>
    <string name="filter_notif_sensitive_apps" msgid="3847012996691991486">"Luk.-kuval ei kuvata tundlikku sisu"</string>
    <string name="filter_notif_hide_notifications_apps" msgid="3977513041080404368">"Ei kuvata kunagi lukustuskuval"</string>
    <string name="filter_notif_silent" msgid="8533960664617048281">"Kuva vaikselt"</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Täpsemad"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Rakenduste seadistamine"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Tundmatu rakendus"</string>
    <string name="app_permissions" msgid="4148222031991883874">"Rakenduse load"</string>
    <string name="app_permissions_summary" msgid="2098173899436407221">"<xliff:g id="COUNT_0">%d</xliff:g> rakendusel <xliff:g id="COUNT_1">%d</xliff:g>-st on täiendav juurdepääs"</string>
    <string name="app_permissions_group_summary" msgid="2721303391744909000">"<xliff:g id="COUNT_0">%d</xliff:g> rakendust <xliff:g id="COUNT_1">%d</xliff:g>-st on lubatud"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Puudutusega äratamine"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Seadme äratamiseks topeltpuudutage ekraani"</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Linkide avamine"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Toetatud linke ei avata"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Domeeni <xliff:g id="DOMAIN">%s</xliff:g> avamine"</string>
    <string name="domain_urls_summary_some" msgid="3950089361819428455">"Ava domeen <xliff:g id="DOMAIN">%s</xliff:g> ja muud URL-id"</string>
    <plurals name="domain_urls_apps_summary" formatted="false" msgid="4322996467951692661">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> rakendust saavad avada oma toetatud linke</item>
      <item quantity="one">Üks rakendus saab avada oma toetatud linke</item>
    </plurals>
    <string name="app_link_open_always" msgid="2474058700623948148">"Ava selles rakenduses"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Küsi iga kord"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"Ära ava selles rakenduses"</string>
    <string name="fingerprint_not_recognized" msgid="1739529686957438119">"Ei tuvastatud"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Vaikeseade"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Vaikimisi töö jaoks"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Abirakendus ja häälsisend"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Abirakendus"</string>
    <string name="default_assist_none" msgid="3709083569608735487">"Puudub"</string>
    <string name="choose_assist_title" msgid="2373353478479305516">"Abirakenduse valimine"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Kas soovite rakenduse <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> muuta abirakenduseks?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"Abimees saab teie süsteemis kasutatavate rakenduste kohta teavet vaadata (sh teie ekraanil kuvatud või rakendustes juurdepääsetav teave)."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"Nõustu"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Ei nõustu"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Häälsisendi valimine"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Brauserirakendus"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Vaikebrauserit pole"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Telefonirakendus"</string>
    <string name="default_app" msgid="6864503001385843060">"(Vaikeseade)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Süsteem)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Süsteemi vaikeseade)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Rakenduste salvestusruum"</string>
    <string name="usage_access" msgid="5479504953931038165">"Juurdepääs kasutusele"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Luba juurdepääs kasutusele"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Rakenduse kasutuse eelistused"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"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="7490541005204254222">"Mälu"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Mälu üksikasjad"</string>
    <string name="always_running" msgid="6042448320077429656">"Töötab alati (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Töötab vahel (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Töötab harva (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Maksimaalne"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Keskmine"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Maksimaalselt <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"Keskmiselt <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="3459065925679828230">"Aku optimeerimine"</string>
    <string name="high_power_filter_on" msgid="3222265297576680099">"Pole optimeeritud"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Pole optimeeritud"</string>
    <string name="high_power_off" msgid="3393904131961263278">"Akukasutuse optimeerimine"</string>
    <string name="high_power_system" msgid="7362862974428225301">"Aku optimeerimine pole saadaval"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"Aku optimeerimist ei rakendata. Aku võib kiiremini tühjeneda."</string>
    <plurals name="high_power_count" formatted="false" msgid="2464701722383894640">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> rakendusel lubati aku optimeerimist eirata</item>
      <item quantity="one">1 rakendusel lubati aku optimeerimist eirata</item>
    </plurals>
    <string name="high_power_prompt_title" msgid="4257734526819699048">"Kas soovite aku optimeeringuid eirata?"</string>
    <string name="high_power_prompt_body" msgid="4072587909486730876">"Kas lubate rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> säilitada ühendus taustal? See võib kasutada rohkem akut."</string>
    <string name="battery_summary" msgid="101415762036784289">"Kasutus alates viimasest täislaadimisest on <xliff:g id="PERCENTAGE">%1$d</xliff:g>%%"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Akut pole pärast viimast täislaadimist kasutatud"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Rakenduse seaded"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Kuva SystemUI tuuner"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Täiendavad load"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"Veel <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1124840737776588602">"Kas jagada veaaruannet?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"IT-administraator taotles veaaruannet, mis aitaks seadmes vigu otsida. Rakendusi ja andmeid võidakse jagada."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="3495929560689435496">"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="5859287696666024466">"Seda veaaruannet jagatakse IT-administraatoriga. Lisateabe saamiseks võtke temaga ühendust."</string>
    <string name="share_remote_bugreport_action" msgid="532226159318779397">"Jaga"</string>
    <string name="decline_remote_bugreport_action" msgid="518720235407565134">"Keeldu"</string>
    <string name="usb_use_charging_only" msgid="2180443097365214467">"Selle seadme laadimine"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Selle seadme laadimine"</string>
    <string name="usb_use_power_only" msgid="6426550616883919530">"Toite andmine"</string>
    <string name="usb_use_power_only_desc" msgid="4912352581010190141">"Andke teisele ühendatud seadmele toidet"</string>
    <string name="usb_use_file_transfers" msgid="7409600791007250137">"Failide teisaldamine"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Failide teisaldamine teise seadmesse"</string>
    <string name="usb_use_photo_transfers" msgid="7794775645350330454">"Fotode edastamine (PTP)"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Fotode või failide edastamine, kui MTP-d ei toetata (PTP)"</string>
    <string name="usb_use_MIDI" msgid="870922185938298263">"Seadme kasutamine MIDI-na"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Kasutage seda seadet MIDI-na"</string>
    <string name="usb_use" msgid="3256040963685055320">"Kasutage USB-d järgmiseks."</string>
    <string name="background_check_pref" msgid="7550258400138010979">"Taustakontroll"</string>
    <string name="background_check_title" msgid="4534254315824525593">"Täielik juurdepääs taustale"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Ekraanil oleva teksti kasutamine"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Abirakendusele lubatakse ekraani sisule juurdepääs tekstina"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Ekraanipildi kasutamine"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Abirakendusele lubatakse juurdepääs ekraanipildile"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Ekraani vilkumine"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"Kui abirakendus pääseb tekstile ekraanil või ekraanipildil juurde, vilguvad ekraani servad"</string>
    <string name="assist_footer" msgid="1982791172085896864">"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="829566450150198512">"Keskmine mälukasutus"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Maksimaalne mälukasutus"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Mälukasutus"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Rakenduse kasutamine"</string>
    <string name="memory_details" msgid="5943436005716991782">"Üksikasjad"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"Viimase 3 tunni jooksul kasutati mälu keskmiselt <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"Viimase 3 tunni jooksul mälu ei kasutatud"</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Sordi keskmise kasutuse järgi"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Sordi maksimaalse kasutuse järgi"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Jõudlus"</string>
    <string name="total_memory" msgid="2017287600738630165">"Kogu mälumaht"</string>
    <string name="average_used" msgid="5338339266517245782">"Keskmine kasutus (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"Vaba"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Rakenduste kasutatav mälu"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> rakendust kasutasid mälu viimase <xliff:g id="DURATION_1">%2$s</xliff:g> jooksul</item>
      <item quantity="one">1 rakendus kasutas mälu viimase <xliff:g id="DURATION_0">%2$s</xliff:g> jooksul</item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Sagedus"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Maksimaalne kasutus"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Andmeid pole kasutatud"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Kas lubada rakenduse <xliff:g id="APP">%1$s</xliff:g> juurdepääs funktsioonile Mitte segada?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"Rakendus saab funktsiooni Mitte segada sisse/välja lülitada ja muuta sellega seotud seadeid."</string>
    <string name="zen_access_disabled_package_warning" msgid="302820100078584431">"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="558779234015793950">"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="5518216907304930148">"Kõik selle rakenduse loodud režiimi Mitte segada reeglid eemaldatakse."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"Ära optimeeri"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimeeri"</string>
    <string name="ignore_optimizations_on_desc" msgid="2321398930330555815">"Aku võib kiiremini tühjeneda"</string>
    <string name="ignore_optimizations_off_desc" msgid="5255731062045426544">"Soovitatav aku kasutusaja pikendamiseks"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Kas lubada rakendusel <xliff:g id="APP">%s</xliff:g> eirata aku optimeerimisi?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Puudub"</string>
    <string name="work_profile_usage_access_warning" msgid="8870622842216566692">"Selle rakenduse puhul ei takista kasutuse juurdepääsu väljalülitamine administraatoril jälgida teie tööprofiilil olevate rakenduste andmekasutust."</string>
    <string name="accessibility_lock_screen_progress" msgid="2408292742980383166">"Kasutatud <xliff:g id="COUNT_0">%1$d</xliff:g> <xliff:g id="COUNT_1">%2$d</xliff:g>-st tähemärgist"</string>
    <string name="draw_overlay_title" msgid="4003905926278954971">"Teiste rakenduste peale joonistav. rakendused"</string>
    <string name="draw_overlay" msgid="9078696044299199938">"Teiste rakend. peale joonist."</string>
    <string name="system_alert_window_settings" msgid="1757821151143694951">"Teiste rakenduste peale joonistamine"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Rakendused"</string>
    <string name="system_alert_window_access_title" msgid="8811695381437304132">"Teiste rakenduste peale joonistamine"</string>
    <string name="permit_draw_overlay" msgid="6606018549732046201">"Luba joonistada üle teiste rakenduste"</string>
    <string name="app_overlay_permission_preference" msgid="8355410276571387439">"Rakenduse peale joonistamise luba"</string>
    <string name="allow_overlay_description" msgid="7895191337585827691">"See luba võimaldab rakenduse kuvada teiste aktiivsete rakenduste peal ja see võib häirida liidese kasutamist teistes rakendustes või muuta seda, mida arvate teistes rakendustes nägevat."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"virtuaalreaalsus virtuaalreaalne kuulaja stereo abiline teenus"</string>
    <string name="keywords_system_alert_window" msgid="8579673659566564926">"süsteem märguanne aken dialoog teiste rakenduste peale joonistamine"</string>
    <string name="overlay_settings" msgid="222062091489691363">"Teiste rakend. peale joonist."</string>
    <string name="system_alert_window_summary" msgid="4268867238063922290">"<xliff:g id="COUNT_0">%d</xliff:g> rakendusel <xliff:g id="COUNT_1">%d</xliff:g>-st on luba joonistada teiste rakenduste peale"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Loaga rakendused"</string>
    <string name="system_alert_window_on" msgid="2939489395109048888">"Jah"</string>
    <string name="system_alert_window_off" msgid="6189115687233061992">"Ei"</string>
    <string name="write_settings" msgid="4797457275727195681">"Süsteemiseadete muutmine"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"kirjuta muuda süsteemiseaded"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"<xliff:g id="COUNT_0">%d</xliff:g> <xliff:g id="COUNT_1">%d</xliff:g>-st rakendusest võivad muuta süsteemiseadeid"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"Saab muuta süsteemiseadeid"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"Saab muuta süsteemiseadeid"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Süsteemiseadete muutmine"</string>
    <string name="write_settings_preference" msgid="3407383041273067448">"Rakendustel süsteemiseadete muutmise lubamine"</string>
    <string name="permit_write_settings" msgid="6393779336656870080">"Luba muuta süsteemiseadeid"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"Luba võimaldab rakendusel muuta süsteemiseadeid."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Jah"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Ei"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Pöörake kaks korda kaamera avamiseks"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"Avage kaamerarakendus, pöörates rannet kaks korda"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="1651873760405034645">"Kaamera avam. vajut. 2 korda toitenuppu"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Kaamera avatakse kiirelt ekraani avamata"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Kuvamissuurus"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Ekraanil kuvatud üksuste suuremaks või väiksemaks muutmine"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"ekraani tihedus, ekraani suum, skaala, skaleerimine"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"Muutke ekraanil kuvatud üksused suuremaks või väiksemaks. Mõne rakenduse asend võib ekraanil muutuda."</string>
    <string name="screen_zoom_preview_title" msgid="4680671508172336572">"Eelvaade"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="4622359904253364742">"Vähendamine"</string>
    <string name="screen_zoom_make_larger_desc" msgid="2236171043607896594">"Suurendamine"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="8443032489384985820">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="998709701837681129">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="6546951024984852686">"Tere, Pete!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"Kas soovid täna kokku saada ja kohvi juua?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Kõlab hästi. Tean üht head lähedalasuvat kohta."</string>
    <string name="screen_zoom_conversation_message_4" msgid="5564676794767555447">"Suurepärane!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="7453710416319650556">"Teisipäev, 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="7107225702890747588">"Teisipäev, 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="3785674344762707688">"Teisipäev, 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2511469395448561259">"Teisipäev, 18:03"</string>
    <string name="see_all" msgid="8883901630052886984">"Kuva kõik"</string>
    <string name="see_less" msgid="1250265310929558370">"Kuva vähem"</string>
    <string name="disconnected" msgid="5787956818111197212">"Ühendus on katkestatud"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"Kasutatud andmemaht on <xliff:g id="AMOUNT">%1$s</xliff:g>"</string>
    <plurals name="notification_summary" formatted="false" msgid="4019451362120557382">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> rakenduse puhul blokeeriti saatmine</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> rakenduse puhul blokeeriti saatmine</item>
    </plurals>
    <string name="notification_summary_none" msgid="3440195312233351409">"Kõigil rakendustel lubatakse saata"</string>
    <string name="apps_summary" msgid="193158055537070092">"Installitud on <xliff:g id="COUNT">%1$d</xliff:g> rakendust"</string>
    <string name="apps_summary_example" msgid="2118896966712746139">"24 installitud rakendust"</string>
    <string name="storage_summary" msgid="1110250618334248745">"Kasutatud on <xliff:g id="SIZE1">%1$s</xliff:g> <xliff:g id="SIZE2">%2$s</xliff:g>-st"</string>
    <string name="display_summary_on" msgid="5628868543070268634">"Kohanduv heledus on SEES"</string>
    <string name="display_summary_off" msgid="6399558022426312990">"Kohanduv heledus on VÄLJAS"</string>
    <string name="memory_summary" msgid="8080825904671961872">"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="user_summary" msgid="1617826998097722499">"Sisse logitud kasutajana <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="3472482669588561110">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> on vaikevalik"</string>
    <string name="location_on_summary" msgid="5127631544018313587">"SEES / <xliff:g id="LOCATION_MODE">%1$s</xliff:g>"</string>
    <string name="location_off_summary" msgid="6474350053215707957">"VÄLJAS"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Varundamine on keelatud"</string>
    <string name="about_summary" msgid="8460677224778433924">"Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Keelatud toiming"</string>
    <string name="default_admin_support_msg" msgid="239311515653633217">"See toiming on keelatud. Lisateabe saamiseks võtke ühendust oma organisatsiooni administraatoriga."</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Rohkem üksikasju"</string>
    <string name="admin_profile_owner_message" msgid="5834937282929663252">"Teie administraator saab jälgida ja hallata teie tööprofiiliga seotud rakendusi ja andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_profile_owner_user_message" msgid="7153676784012255048">"Teie administraator saab jälgida ja hallata selle kasutajaga seotud rakendusi ja andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_device_owner_message" msgid="8734500370023898028">"Teie administraator saab jälgida ja hallata selle seadmega seotud rakendusi ja andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="condition_turn_off" msgid="1960945836880080298">"Lülita välja"</string>
    <string name="condition_turn_on" msgid="9089876276117874591">"Lülita sisse"</string>
    <string name="condition_expand_show" msgid="608202020023489939">"Kuva"</string>
    <string name="condition_expand_hide" msgid="948507739223760667">"Peida"</string>
    <string name="condition_hotspot_title" msgid="7778958849468560027">"Leviala on sees"</string>
    <string name="condition_hotspot_summary" msgid="3433182779269409683">"Teisaldatav WiFi-leviala <xliff:g id="ID_1">%1$s</xliff:g> on aktiivne, WiFi on selles seadmes välja lülitatud."</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Lennukirežiim on sees"</string>
    <string name="condition_airplane_summary" msgid="2136872325308526329">"WiFi, Bluetooth ja mobiilne andmeside on välja lülitatud. Te ei saa helistada ega Internetiga ühendust luua."</string>
    <string name="condition_zen_title" msgid="2679168532600816392">"Režiim Mitte segada on sees (<xliff:g id="ID_1">%1$s</xliff:g>)"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Akusäästja on sisse lülitatud"</string>
    <string name="condition_battery_summary" msgid="4418839236027977450">"Jõudlust on vähendatud. Asukohateenused ja taustaandmed on välja lülitatud."</string>
    <string name="condition_cellular_title" msgid="2398754272044917264">"Mobiilne andmeside on väljas"</string>
    <string name="condition_cellular_summary" msgid="1818046558419658463">"Internet on saadaval ainult WiFi kaudu"</string>
    <string name="condition_bg_data_title" msgid="2483860304802846542">"Andmeside mahu säästja on sees"</string>
    <string name="condition_bg_data_summary" msgid="656957852895282228">"Taustaandmed on saadaval ainult WiFi kaudu. Kui WiFi pole saadaval, võib see mõjutada mõne rakenduse või teenuse tööd."</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Tööprofiil on välja lülitatud"</string>
    <string name="condition_work_summary" msgid="7543202177571590378">"Rakendused, taustal sünkroonimine ja muud tööprofiiliga seotud funktsioonid on välja lülitatud."</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"Öövalgus on sees"</string>
    <string name="condition_night_display_summary" msgid="6156601053674688864">"Ekraan on toonitud punaseks. See võib aidata teil magama jääda."</string>
    <string name="suggestions_title" msgid="7280792342273268377">"Soovitused"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"+ <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestion_remove" msgid="904627293892092439">"Eemalda"</string>
    <string name="color_temperature" msgid="2070126836910615605">"Külm värvitemperatuur"</string>
    <string name="color_temperature_desc" msgid="4793729830226404052">"Kasutatakse külmemaid ekraanivärve"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Värvi muutmise rakendamiseks lülitage ekraan välja"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Automaatsed süsteemivärskendused"</string>
    <string name="usage" msgid="2977875522080448986">"Kasutus"</string>
    <string name="cellular_data_usage" msgid="2763710678354680712">"Mobiilse andmeside kasutus"</string>
    <string name="wifi_data_usage" msgid="686754111095324306">"WiFi andmekasutus"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Etherneti andmekasutus"</string>
    <string name="wifi" msgid="1081550856200013637">"WiFi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Ethernet"</string>
    <string name="cell_data_template" msgid="3308709914705592281">"<xliff:g id="ID_1">%1$s</xliff:g> mobiilset andmesidet"</string>
    <string name="wifi_data_template" msgid="501654649753761778">"<xliff:g id="ID_1">%1$s</xliff:g> WiFi-andmeid"</string>
    <string name="ethernet_data_template" msgid="5775729859383597507">"<xliff:g id="ID_1">%1$s</xliff:g> Etherneti-andmeid"</string>
    <string name="cell_warning_only" msgid="763147658209027140">"<xliff:g id="ID_1">%1$s</xliff:g> – andmemahu hoiatus"</string>
    <string name="cell_warning_and_limit" msgid="2273413629267437470">"<xliff:g id="ID_1">%1$s</xliff:g> – andmemahu hoiatus / <xliff:g id="ID_2">%2$s</xliff:g> – andmemahu piirang"</string>
    <string name="billing_cycle" msgid="5169909190811133499">"Arveldustsükkel"</string>
    <string name="billing_cycle_summary" msgid="9009106526129293752">"Kuupõhine tsükkel algab iga kuu <xliff:g id="ID_1">%1$s</xliff:g>. päeval"</string>
    <string name="billing_cycle_fragment_summary" msgid="1940518156600077066">"Kuupõhine alates <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Võrgupiirangud"</string>
    <string name="operator_warning" msgid="1862988028996859195">"Operaatori andmemahuarvestus võib erineda seadme andmemahuarvestusest"</string>
    <string name="data_used_template" msgid="3245919669966296505">"<xliff:g id="ID_1">%1$s</xliff:g> on kasutatud"</string>
    <string name="data_warning" msgid="209133958008062117">"Andmemahu hoiatus"</string>
    <string name="set_data_limit" msgid="2901526323210516923">"Andmemahupiirangu määramine"</string>
    <string name="data_limit" msgid="1885406964934590552">"Andmemahu piirang"</string>
    <string name="data_usage_template" msgid="392191945602400904">"<xliff:g id="ID_1">%1$s</xliff:g> on kasutatud vahemikus <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1029654422228677273">"Seadistamine"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Muud kasutusandmetesse kaasatud rakendused"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> rakendusel on lubatud kasutada piiranguteta andmemahtu, kui andmeside mahu säästja on sisse lülitatud</item>
      <item quantity="one">1 rakendusel on lubatud kasutada piiranguteta andmemahtu, kui andmeside mahu säästja on sisse lülitatud</item>
    </plurals>
    <string name="data_saver_title" msgid="398458827917495765">"Andmeside mahu säästja"</string>
    <string name="unrestricted_data_saver" msgid="7019858887510062789">"Piiranguteta juurdepääs andmesidele"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Taustaandmed on välja lülitatud"</string>
    <string name="data_saver_on" msgid="6774217590237934709">"Sees"</string>
    <string name="data_saver_off" msgid="6892309031162738794">"Väljas"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Piiranguteta andmekasutus"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Luba piiranguteta juurdepääs andmesidele, kui andmeside mahu säästja on sisse lülitatud"</string>
    <string name="home_app" msgid="4066188520886810030">"Avaekraani rakendus"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Vaikimisi avaekraan puudub"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="3832020101401318248">"Turvaline käivitamine"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="7873036097628404476">"Seadme käivitamisel nõutakse mustrit. Kui seade on välja lülitatud, ei saa see vastu võtta kõnesid, sõnumeid, märguandeid ega alarme."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="6022831284097476933">"Seadme käivitamisel nõutakse PIN-koodi. Kui seade on välja lülitatud, ei saa see vastu võtta kõnesid, sõnumeid, märguandeid ega alarme."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="6818285221244966231">"Seadme käivitamisel nõutakse parooli. Kui seade on välja lülitatud, ei saa see vastu võtta kõnesid, sõnumeid, märguandeid ega alarme."</string>
    <string name="suggestion_additional_fingerprints" msgid="2214281455363797037">"Lisage veel üks sõrmejälg"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Teise sõrmega avamine"</string>
    <string name="battery_saver_on_summary" msgid="9072203872401530722">"Sees / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="8309471955051162327">"Väljas / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="battery_saver_desc_turn_on_auto_never" msgid="6715896635178578813">"Ära kunagi lülita automaatselt sisse"</string>
    <string name="battery_saver_desc_turn_on_auto_pct" msgid="7472323223085636533">"Lülita automaatselt sisse akutaseme %1$s juures"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"Aku optimeerimist ei kasutata"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Kui seade on lukus, keela märguannetes vastuste või muu teksti sisestamine"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Vaikimisi õigekirjakontroll"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Õigekirjakontrolli valimine"</string>
    <string name="spell_checker_not_selected" msgid="8871083796179200696">"Pole valitud"</string>
    <string name="notification_log_no_title" msgid="5678029849672024215">"(puudub)"</string>
    <string name="notification_log_details_delimiter" msgid="3116559361552416747">": "</string>
    <string name="notification_log_details_package" msgid="2596495677039100284">"pkg"</string>
    <string name="notification_log_details_key" msgid="2995791937075862968">"võti"</string>
    <string name="notification_log_details_group" msgid="2430467015200368698">"grupp"</string>
    <string name="notification_log_details_group_summary" msgid="7945543958255585829">"(kokkuvõte)"</string>
    <string name="notification_log_details_visibility" msgid="2552873780715930971">"nähtavus"</string>
    <string name="notification_log_details_public_version" msgid="4247242364605495240">"avalik versioon"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"prioriteet"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"tähtsus"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"selgitus"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"kavatsus"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"kustuta kavatsus"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"täisekraani kavatsus"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"toimingud"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"pealkiri"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"kaugsisestused"</string>
    <string name="notification_log_details_content_view" msgid="6638731378278561786">"kohandatud vaade"</string>
    <string name="notification_log_details_extras" msgid="4188418723779942047">"lisad"</string>
    <string name="notification_log_details_icon" msgid="8939114059726188218">"ikoon"</string>
    <string name="notification_log_details_parcel" msgid="243148037601903212">"paki suurus"</string>
    <string name="notification_log_details_ashmem" msgid="7241814108477320636">"ashmem"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"heli"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"vibratsioon"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"vaikeseade"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"puudub"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"Asetuse objekt puudub."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"Asetuse objekt ei sisalda seda võtit."</string>
    <string name="special_access" msgid="8275242424094109976">"Erijuurdepääs"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Kas soovite tõesti kasutaja andmed kustutada ja teisendada failide krüpteerimisele?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Kustuta ja teisenda"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Teenuse ShortcutManager sageduse piiramise lähtestamine"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Teenuse ShortcutManager sageduse piiramine lähtestati"</string>
    <string name="notification_suggestion_title" msgid="4506524937307816475">"Lukustuskuva märguannete juhtimine"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Märguande sisu kuvamine või peitmine"</string>
    <string name="page_tab_title_summary" msgid="4070309266374993258">"Kõik"</string>
    <string name="page_tab_title_support" msgid="6330657582897417458">"Tugi"</string>
    <string name="developer_density_summary" msgid="1998244213021456519">"<xliff:g id="ID_1">%d</xliff:g> dp"</string>
    <string name="developer_smallest_width" msgid="7516950434587313360">"Kõige väiksem laius"</string>
    <string name="premium_sms_none" msgid="8268105565738040566">"Ükski installitud rakendus pole taotlenud juurdepääsu tasuliste SMS-ide saatmiseks"</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"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="4660047004791638305">"Juurdepääs tasuliste SMS-ide saatmiseks"</string>
    <string name="bluetooth_disabled" msgid="1558295505487648234">"Keelatud"</string>
    <string name="demo_mode" msgid="2655748420527206870">"Demorežiim"</string>
    <string name="support_escalation_title" msgid="4111071371281023145">"Oleme valmis teid aitama"</string>
    <string name="support_escalation_24_7_title" msgid="8118369197749832074">"Aitame teid 24/7"</string>
    <string name="support_escalation_24_7_content_description" msgid="3772776213036994533">"Aitame teid ööpäev läbi"</string>
    <string name="support_escalation_summary" msgid="8473084168776014405">"Meie tugitiim aitab teid kõigi probleemide korral"</string>
    <string name="support_escalation_24_7_summary" msgid="2802773279262547187">"Meie tugitiim on iga päev ja iga kell saadaval"</string>
    <string name="support_escalation_closed_summary" msgid="2240967274380168303">"Otsige abiteabest või naaske ajal, mil tugiteenus töötab (kohaliku aja järgi):&lt;br&gt;&lt;b&gt;<xliff:g id="OPERATION_HOURS">%s</xliff:g>&lt;/b&gt;"</string>
    <string name="support_escalation_no_internet_summary" msgid="2526082812336597989">"Telefonitoe tööaeg (kohaliku aja järgi)&lt;br&gt;&lt;b&gt;<xliff:g id="OPERATION_HOURS">%s</xliff:g>&lt;/b&gt;"</string>
    <string name="support_escalation_unavailable_summary" msgid="5208552975245211898">"Otsige abi või avastage nõuandeid ja nippe"</string>
    <string name="support_country_list_title" msgid="823853371280534111">"Toe riik:"</string>
    <string name="support_country_format" msgid="4502523713489559595">"<xliff:g id="COUNTRY">%s</xliff:g> – <xliff:g id="LANGUAGE">%s</xliff:g>"</string>
    <string name="support_phone_international_format" msgid="2143528744844720829">"<xliff:g id="LANGUAGE">%s</xliff:g> (<xliff:g id="PHONE">%s</xliff:g>)"</string>
    <string name="support_international_phone_title" msgid="1308334014138718455">"Kas reisite välismaale?"</string>
    <string name="support_international_phone_summary" msgid="208231793637026927">"Rakenduda võivad rahvusvaheliste kõnede tasud"</string>
    <string name="support_escalation_by_phone" msgid="4843223043487058711">"Telefon"</string>
    <string name="support_escalation_by_chat" msgid="977019859110763749">"Vestlus"</string>
    <string name="support_tips_and_tricks_title" msgid="4153466795695447828">"Avastage nõuandeid ja nippe"</string>
    <string name="support_help_feedback_title" msgid="693440287222186718">"Otsige abist ja saatke tagasisidet"</string>
    <string name="support_sign_in_required_title" msgid="1367187789121480440">"Toega ühenduse võtmine"</string>
    <string name="support_sign_in_button_text" msgid="3054769428620671241">"Logi sisse"</string>
    <string name="support_sign_in_required_help" msgid="5200654782405538114">"Kas te ei saa sisse logida?"</string>
    <string name="support_disclaimer_title" msgid="4825302018208770031">"Süsteemiteabe saatmine"</string>
    <string name="support_disclaimer_content" msgid="6702447747744624871">"Teie probleemi kiireks lahendamiseks vajame diagnoosimiseks süsteemiteavet."</string>
    <string name="support_disclaimer_do_not_show" msgid="3378367075323727539">"Ära kuva enam"</string>
    <string name="managed_profile_settings_title" msgid="2729481936758125054">"Tööprofiili seaded"</string>
    <string name="managed_profile_contact_search_title" msgid="6034734926815544221">"Kontaktiotsing"</string>
    <string name="managed_profile_contact_search_summary" msgid="5431253552272970512">"Lubage organisatsioonile helistajate ja kontaktide tuvastamiseks kontaktiotsingud"</string>
    <plurals name="hours" formatted="false" msgid="7020844602875333472">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> tundi</item>
      <item quantity="one">1 tund</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="4666832442068789413">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minutit</item>
      <item quantity="one">1 minut</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="3876307354560025025">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sekundit</item>
      <item quantity="one">1 sekund</item>
    </plurals>
    <string name="support_estimated_wait_time" msgid="6523081420029378051">"Ooteaeg umbes <xliff:g id="ESTIMATE">%1$s</xliff:g>"</string>
    <string name="bluetooth_talkback_computer" msgid="4875089335641234463">"Arvuti"</string>
    <string name="bluetooth_talkback_headset" msgid="5140152177885220949">"Peakomplekt"</string>
    <string name="bluetooth_talkback_phone" msgid="4260255181240622896">"Telefon"</string>
    <string name="bluetooth_talkback_imaging" msgid="551146170554589119">"Pildindus"</string>
    <string name="bluetooth_talkback_headphone" msgid="26580326066627664">"Kõrvaklapid"</string>
    <string name="bluetooth_talkback_input_peripheral" msgid="5165842622743212268">"Sisestatud välisseade"</string>
    <string name="bluetooth_talkback_bluetooth" msgid="5615463912185280812">"Bluetooth"</string>
    <string name="automatic_storage_manager_settings" msgid="7819434542155181607">"Salvestusruumi haldamine"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"Salvestusruumi vabastamiseks eemaldab salvestusruumi haldur varundatud fotod ja videod teie seadmest."</string>
    <string name="automatic_storage_manager_days_title" msgid="2017913896160914647">"Fotode ja videote eemaldamine"</string>
    <string name="automatic_storage_manager_preference_title" msgid="5753702798151073383">"Salvestusruumi haldur"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automaatne"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Käsitsi"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Vabastage ruumi"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Liigutused"</string>
    <string name="gesture_preference_summary" msgid="8627850388011956901">"Kiirliigutused telefoni juhtimiseks"</string>
    <string name="double_tap_power_for_camera_title" msgid="2993443929413421363">"Ava kaamera"</string>
    <string name="double_tap_power_for_camera_summary" msgid="6988157149749655988">"Kaamera kiireks avamiseks topeltpuudutage toitenuppu. See töötab igal ekraanil"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Kaamera vahetamine"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="ambient_display_title" msgid="7369291941168001738">"Kiire ekraanikontroll"</string>
    <string name="ambient_display_summary" msgid="3606386731704368561">"Telefoni kontrollimiseks seda täielikult äratamata topeltpuudutage seda või võtke see kätte"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2750203868053669600">"Pühkimine märguannete kontrollimiseks"</string>
    <string name="fingerprint_swipe_for_notifications_summary" msgid="5274050434459511239">"Märguannete kontrollimiseks pühkige telefoni tagaküljel oleval sõrmejäljeanduril alla"</string>
    <string name="gesture_setting_on" msgid="3455094265233870280">"Sees"</string>
    <string name="gesture_setting_off" msgid="5230169535435881894">"Väljas"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4265541229765635629">"Buudilaadur on juba avatud"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="415954951226204461">"Looge esmalt Interneti-ühendus"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="5884723935668892613">"Looge Interneti-ühendus või võtke ühendust operaatoriga"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"Ei ole operaatori lukustatud seadmetes saadaval"</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"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>
</resources>
