<?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="dev_settings_disabled_warning" msgid="4909448907673974370">"Lubage esmalt arendaja valikud."</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="eab_provisioned_switch_string" msgid="3482272907448592975">"EAB/Presence\'i ettevalmistatud"</string>
    <string name="radio_info_radio_power" msgid="7187666084867419643">"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_getIMS" msgid="185171476413967831">"IMS-teenuse olek"</string>
    <string name="radio_info_ims_reg_status_title" msgid="16971785902696970">"IMS-i olek"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="5614116179751126247">"Registreeritud"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="4438054067642750717">"Ei ole registreeritud"</string>
    <string name="radio_info_ims_feature_status_available" msgid="3687807290327566879">"Saadaval"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="4606182208970114368">"Pole saadaval"</string>
    <string name="radio_info_ims_reg_status" msgid="7534612158445529715">"IMS-i registreerimine: <xliff:g id="STATUS">%1$s</xliff:g>\nHäälvestlus LTE kaudu: <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nHäälvestlus WiFi kaudu: <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nVideokõne: <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nUT-liides: <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</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 kuvatavat tekst suuremaks või väiksemaks."</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="2846183528684496723">"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_pairing_pref_title" msgid="4601203665214962983">"Uue seadme sidumine"</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_footer_mac_message" msgid="7829164289195116782">"Bluetoothi MAC-aadress: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</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_ask_enablement" msgid="3387222809404177525">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi sisse lülitada"</string>
    <string name="bluetooth_ask_disablement" msgid="5890386255790160573">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi välja lülitada"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="1644353686104482763">"Rakendus soovib Bluetoothi sisse lülitada"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="9218830122674868548">"Rakendus soovib Bluetoothi välja lülitada"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4791779658660357386">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib <xliff:g id="TIMEOUT">%2$d</xliff:g> sekundiks teie tahvelarvuti teistele Bluetoothi seadmetele nähtavaks muuta."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="1308225382575535366">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib <xliff:g id="TIMEOUT">%2$d</xliff:g> sekundiks teie telefoni teistele Bluetoothi seadmetele nähtavaks muuta."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="225715443477752935">"Rakendus soovib <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks teie tahvelarvuti teistele Bluetoothi seadmetele nähtavaks muuta."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="4949152735544109994">"Rakendus soovib <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks teie telefoni teistele Bluetoothi seadmetele nähtavaks muuta."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8528329166577187961">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib teie tahvelarvuti teistele Bluetoothi seadmetele nähtavaks muuta. Seda saate hiljem Bluetoothi seadetes muuta."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="4398738575307583138">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib teie telefoni teistele Bluetoothi seadmetele nähtavaks muuta. Seda saate hiljem Bluetoothi seadetes muuta."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="1702590641426207062">"Rakendus soovib teie tahvelarvuti teistele Bluetoothi seadmetele nähtavaks muuta. Seda saate hiljem Bluetoothi seadetes muuta."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="8549952177383992238">"Rakendus soovib teie telefoni teistele Bluetoothi seadmetele nähtavaks muuta. Seda saate hiljem Bluetoothi seadetes muuta."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="1141843490422565755">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi sisse lülitada ja <xliff:g id="TIMEOUT">%2$d</xliff:g> sekundiks teie tahvelarvuti teistele seadmetele nähtavaks muuta."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="5195836980079191473">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi sisse lülitada ja <xliff:g id="TIMEOUT">%2$d</xliff:g> sekundiks teie telefoni teistele seadmetele nähtavaks muuta."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="7009338445281693765">"Rakendus soovib Bluetoothi sisse lülitada ja <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks teie tahvelarvuti teistele seadmetele nähtavaks muuta."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="8386904242279878734">"Rakendus soovib Bluetoothi sisse lülitada ja <xliff:g id="TIMEOUT">%1$d</xliff:g> sekundiks teie telefoni teistele seadmetele nähtavaks muuta."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="2279471426575892686">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi sisse lülitada ja teie tahvelarvuti teistele seadmetele nähtavaks muuta. Seda saate hiljem Bluetoothi seadetes muuta."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6961969825475461450">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi sisse lülitada ja teie telefoni teistele seadmetele nähtavaks muuta. Seda saate hiljem Bluetoothi seadetes muuta."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="692477613671555006">"Rakendus soovib Bluetoothi sisse lülitada ja teie tahvelarvuti teistele seadmetele nähtavaks muuta. Seda saate hiljem Bluetoothi seadetes muuta."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="6374480121751597648">"Rakendus soovib Bluetoothi sisse lülitada ja teie telefoni teistele seadmetele nähtavaks muuta. Seda saate hiljem Bluetoothi seadetes muuta."</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="8930347091018455505">"Seade <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib juurdepääsu teie kontaktidele ja kõneajaloole. Kas anda seadmele <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> juurdepää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="bluetooth_device_name_summary" msgid="4418784300859596202">"Teistele seadmetele nähtav seadmena <xliff:g id="DEVICE_NAME">^1</xliff:g>"</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Teie seadmed"</string>
    <string name="bluetooth_pairing_page_title" msgid="5218444163161190061">"Bluetoothi seadme sidumine"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Kuupäev ja kellaaeg"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Ajavööndi valimine"</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="activity_list_empty" msgid="6428823323471264836">"Sobivat tegevust ei leitud."</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="1838624369870907268">"WiFi, Bluetoothi, lennurežiimi ja mobiilsidevõrkude ning VPN-ide haldamine"</string>
    <string name="cellular_data_title" msgid="6835451574385496662">"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="4660351864416939504">"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="6392489775303464905">"Administraatori keelatud"</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="4918904614964215087">"Turvalisus ja asukoht"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Krüpteerimine ja mandaat"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Telefon on krüpteeritud"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Seade on krüpteeritud"</string>
    <string name="lockscreen_settings_title" msgid="3922976395527087455">"Lukustuskuva eelistused"</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="2881269890053568809">"Privaatsus"</string>
    <string name="disabled_by_administrator_summary" msgid="1601828700318996341">"Administraatori keelatud"</string>
    <string name="security_status_title" msgid="5848766673665944640">"Turvalisuse olek"</string>
    <string name="security_dashboard_summary" msgid="6757421634477554939">"Ekraanilukk, sõrmejälg"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="8129641548372335540">"Ekraanilukk"</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_title_unlock_disabled" msgid="7066417934622827305">"Sõrmejälje kasutamine"</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_unlock_disabled" msgid="4193477159493347679">"Ostude volitamiseks või rakendustesse sisselogimiseks peate puudutama vaid sõrmejäljeandurit. Olge sõrmejälgede lisamisel ettevaatlik. Neid toiminguid saab teha isegi ühe lisatud sõrmejäljega.\n\nMärkus. Te ei saa sõrmejälge kasutada selle seadme avamiseks. Lisateabe saamiseks võtke ühendust organisatsiooni administraatoriga."</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="7846871823167357942">" Ekraaniluku valik on keelatud. Küsige lisateavet organisatsiooni administraatorilt. "<annotation id="admin_details">"Rohkem üksikasju"</annotation>\n\n"Saate ka edaspidi sõrmejäljega oste volitada ja rakendustele juurde pääseda. "<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="fingerprint_add_max" msgid="1020927549936895822">"Saate lisada kuni <xliff:g id="COUNT">%d</xliff:g> sõrmejälge"</string>
    <string name="fingerprint_intro_error_max" msgid="6864066984678078441">"Olete lisanud maksimaalse arvu sõrmejälgi"</string>
    <string name="fingerprint_intro_error_unknown" msgid="1905692132326523040">"Rohkem sõrmejälgi ei saa lisada"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Kas eemaldada kõik sõrmejäljed?"</string>
    <string name="fingerprint_last_delete_message" msgid="7852321001254275878">"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="6521520787746771912">"Te ei saa oma sõrmejälgi kasutades tööprofiili avada, oste volitada ega töörakendustesse sisse logida"</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="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Ekraaniluku valikud"</string>
    <!-- no translation found for setup_lock_settings_options_dialog_title (5058207955455973917) -->
    <skip />
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Ekraanilukk"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5967714169972542586">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / kohe pärast unerežiimi"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4696710373399258413">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> pärast unerežiimi"</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="fingerprint_unlock_skip_fingerprint" msgid="1441077909803666681">"Jätkamine ilma salvestusruumita"</string>
    <string name="fingerprint_unlock_title" msgid="2826226740306003991">"Telefoni saate avada oma sõrmejäljega. Turvalisuse tagamiseks nõuab see valik varuekraanilukku."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2051593894736282302">"Administraator, krüpteerimiseeskirjad või mandaatide salvestusruum on selle keelanud"</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>
    <!-- no translation found for lock_failed_attempts_before_wipe (2219711062197089783) -->
    <skip />
    <!-- no translation found for lock_last_attempt_before_wipe_warning_title (4277765862798876826) -->
    <skip />
    <!-- no translation found for lock_last_pattern_attempt_before_wipe_device (4999108263936246210) -->
    <skip />
    <!-- no translation found for lock_last_pin_attempt_before_wipe_device (2191214314973933300) -->
    <skip />
    <!-- no translation found for lock_last_password_attempt_before_wipe_device (6526655065466746563) -->
    <skip />
    <!-- no translation found for lock_last_pattern_attempt_before_wipe_user (7851504071368235547) -->
    <skip />
    <!-- no translation found for lock_last_pin_attempt_before_wipe_user (4049024921333961715) -->
    <skip />
    <!-- no translation found for lock_last_password_attempt_before_wipe_user (4660886542496781672) -->
    <skip />
    <!-- no translation found for lock_last_pattern_attempt_before_wipe_profile (2437716252059050291) -->
    <skip />
    <!-- no translation found for lock_last_pin_attempt_before_wipe_profile (5799931839127476913) -->
    <skip />
    <!-- no translation found for lock_last_password_attempt_before_wipe_profile (6786586046975042158) -->
    <skip />
    <!-- no translation found for lock_failed_attempts_now_wiping_device (1951676829299522277) -->
    <skip />
    <!-- no translation found for lock_failed_attempts_now_wiping_user (6188180643494518001) -->
    <skip />
    <!-- no translation found for lock_failed_attempts_now_wiping_profile (1745475043685915442) -->
    <skip />
    <!-- no translation found for lock_failed_attempts_now_wiping_dialog_dismiss (8246716090548717312) -->
    <skip />
    <string name="lockpassword_password_too_short" msgid="2726090378672764986">"Peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> tähemärki"</string>
    <string name="lockpassword_pin_too_short" msgid="3638188874397727648">"PIN-kood peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> numbrit"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Jätka"</string>
    <string name="lockpassword_password_too_long" msgid="4591720174765403476">"Peab olema lühem kui <xliff:g id="NUMBER">%d</xliff:g> tähemärki"</string>
    <string name="lockpassword_pin_too_long" msgid="2079396149560490458">"Peab olema lühem kui <xliff:g id="NUMBER">%d</xliff:g> numbrit"</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="7284664023164191198">"Tohib sisaldada ainult numbreid 0–9."</string>
    <string name="lockpassword_pin_recently_used" msgid="1401569207976460727">"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="9013132344745898400">
      <item quantity="other">Peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> tähte</item>
      <item quantity="one">Peab sisaldama vähemalt 1 tähte</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2626327674921055486">
      <item quantity="other">Peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> 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="7860796359913920356">
      <item quantity="other">Peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> suurtähte</item>
      <item quantity="one">Peab sisaldama vähemalt 1 suurtähte</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="1967587658356336828">
      <item quantity="other">Peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> numbrit</item>
      <item quantity="one">Peab sisaldama vähemalt 1 numbrit</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="6751305770863640574">
      <item quantity="other">Peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> erisümbolit</item>
      <item quantity="one">Peab sisaldama vähemalt 1 erisümbolit</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="4440596998172043055">
      <item quantity="other">Peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> 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="942665351220525547">"Seadme administraator ei luba kasutada hiljutist parooli"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"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="manage_device_admin" msgid="537804979483211453">"Seadme administraatori rakendused"</string>
    <string name="number_of_device_admins_none" msgid="7185056721919496069">"Aktiivseid rakendusi ei ole"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="3361891840111523393">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aktiivset rakendust</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> aktiivne rakendus</item>
    </plurals>
    <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="1475819820389620546">"Mitte ükski"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="3935182396726101824">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aktiivset usaldusväärset agenti</item>
      <item quantity="one">1 aktiivne usaldusväärne agent</item>
    </plurals>
    <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_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 olevaid 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="wifi_ask_enable" msgid="2795469717302060104">"Rakendus <xliff:g id="REQUESTER">%s</xliff:g> soovib WiFi sisse lülitada"</string>
    <string name="wifi_ask_disable" msgid="728366570145493573">"Rakendus <xliff:g id="REQUESTER">%s</xliff:g> soovib WiFi välja lülitada"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Lubab andmevahetuse, kui tahvelarvuti puudutab teist seadet"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Lubab andmevahetuse, 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="1810540319385192758">"Kui see funktsioon on sisse lülitatud, saate rakenduse sisu teise NFC-toega seadmesse saata, kui hoiate seadmeid üksteise lähedal. Nii saate edastada näiteks veebilehti, YouTube\'i videoid, kontakte ja muud.\n\nLihtsalt hoidke seadmeid lähestikku (tavaliselt tagakülgi koos) ja seejärel puudutage seadme ekraani. Rakendus määrab, mida edastatakse."</string>
    <string name="wifi_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_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="76298880708051981">"Märguanne avatud võrgu kohta"</string>
    <string name="wifi_notify_open_networks_summary" msgid="2761326999921366960">"Teavita, kui kvaliteetne avalik võrk on saadaval"</string>
    <string name="wifi_wakeup" msgid="8815640989361538036">"Lülita WiFi automaatselt sisse"</string>
    <string name="wifi_wakeup_summary" msgid="2530814331062997163">"WiFi lülitub uuesti sisse kvaliteetsete salvestatud võrkude, näiteks teie koduse võrgu läheduses"</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="7247227922074840445">"Pole saadaval, kuna WiFi skannimine on välja lülitatud"</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="use_open_wifi_automatically_title" msgid="6851951242903078588">"Loo ühendus avatud võrkudega"</string>
    <string name="use_open_wifi_automatically_summary" msgid="2982091714252931713">"Loo automaatselt ühendus kvaliteetsete avalike võrkudega"</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_text_scanning_off" msgid="3426075479272242098">"Asukoha täpsuse parandamiseks lülitage <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>skannimisseadetes<xliff:g id="LINK_END_1">LINK_END</xliff:g> sisse WiFi-võrkude skannimine."</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="1707247692180853058">"Kui WiFi kaotab juurdepääsu Internetile, lülita mobiilsele andmesidele."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8753386877755616476">"Lülita automaatselt mobiilsele andmesidele"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="6375399280719867214">"Kui WiFi-l puudub Internetile juurdepääs, kasutatakse mobiilset andmesidet. Andmekasutus võib olla tasuline."</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Võrgu lisamine"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2913345003906899146">"WiFi-eelistused"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="646393113104367290">"WiFi lülitub automaatselt tagasi sisse"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="2782566279864356713">"WiFi ei lülitu automaatselt uuesti sisse"</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_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_advanced_toggle_description_expanded" msgid="2380600578544493084">"Rippmenüü loend Täpsemad valikud. Topeltpuudutage ahendamiseks."</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="1463812308429197263">"Rippmenüü loend Täpsemad valikud. Topeltpuudutage laiendamiseks."</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="9029649339816197345">"Kui WiFi-ühendus on halb, võite aktiveerida mobiilsidevõrgu. Andmekasutus võib olla tasuline."</string>
    <string name="lost_internet_access_switch" msgid="2262459569601190039">"Lülita 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_saved_access_points_titlebar" msgid="2996149477240134064">"Salvestatud võrgud"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="6094679048871529675">
      <item quantity="other">%d võrku</item>
      <item quantity="one">1 võrk</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Täpsemad WiFi-seaded"</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_details_subnet_mask" msgid="6720279144174924410">"Alamvõrgu mask"</string>
    <string name="wifi_details_dns" msgid="8648826607751830768">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="6734119149106422148">"IPv6-aadressid"</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">"Mobiilne WiFi-kuumkoht"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"WiFi-leviala"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="5347703013899354452">"Kasuta WiFi-võrgu loomiseks mobiilse andmeside ühendust"</string>
    <string name="wifi_hotspot_off_subtext" product="tablet" msgid="2745508221200463254">"Tahvelarvuti Interneti-ühendust ei jagata leviala kaudu"</string>
    <string name="wifi_hotspot_off_subtext" product="default" msgid="7746761268472599794">"Telefoni Interneti-ühendust ei jagata mobiilse kuumkoha kaudu"</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="7842111748046063857">"<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-kuumkoha seadistamine"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"WiFi-leviala seadistamine"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"AndroidAP WPA2 PSK leviala"</string>
    <string name="wifi_tether_configure_subtext" msgid="2050196439900426456">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g> leviala"</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 name="wifi_calling_roaming_mode_title" msgid="1565039047187685115">"Rändluse eelistus"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (8642014873060687717) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="7800926602662078576">"Rändluse eelistus"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="2124257075906188844">"WiFi eelistusega"</item>
    <item msgid="1335127656328817518">"Eelistatud on mobiilne andmeside"</item>
    <item msgid="3132912693346866895">"Ainult WiFi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="742988808283756263">"WiFi"</item>
    <item msgid="7715869266611010880">"Mobiilne andmeside"</item>
    <item msgid="2838022395783120596">"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="5074515506087318555">"Eelistatud on mobiilne andmeside"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"WiFi"</item>
    <item msgid="1118703915148755405">"Mobiilne andmeside"</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="wifi_calling_off_explanation_2" msgid="2329334487851497223"></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="display_settings_title" msgid="1708697328627382561">"Ekraan"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Heli"</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="1357721012342357037">"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="search_settings_no_results" msgid="8799027492641230999">"Tulemusi ei ole"</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="auto_brightness_summary_off" msgid="2802336459335410626">"Väljas"</string>
    <string name="auto_brightness_summary_very_low" msgid="6483976609035853764">"Eelistatav heledus on väga tume"</string>
    <string name="auto_brightness_summary_low" msgid="5609877905833960427">"Eelistatav heledus on tume"</string>
    <string name="auto_brightness_summary_default" msgid="7225666614394726845">"Eelistatav heledus on vaikeseade"</string>
    <string name="auto_brightness_summary_high" msgid="7172304165631136027">"Eelistatav heledus on hele"</string>
    <string name="auto_brightness_summary_very_high" msgid="979277812582279078">"Eelistatav heledus on väga hele"</string>
    <string name="auto_brightness_off_title" msgid="2996864829946190795">"Väljas"</string>
    <string name="auto_brightness_very_low_title" msgid="8252988638614126320">"Väga tume"</string>
    <string name="auto_brightness_low_title" msgid="1632186441514863377">"Tume"</string>
    <string name="auto_brightness_default_title" msgid="936771997353506620">"Vaikeseade"</string>
    <string name="auto_brightness_high_title" msgid="2527853305981497345">"Hele"</string>
    <string name="auto_brightness_very_high_title" msgid="8867164854439331022">"Väga hele"</string>
    <string name="auto_brightness_subtitle" msgid="6454652530864093466">"Teie eelistatud heleduse tase"</string>
    <string name="auto_brightness_off_summary" msgid="7629228736838155268">"Ära kohanda valgustingimuste järgi"</string>
    <string name="auto_brightness_very_high_summary" msgid="4551003097086220709">"Suurem akukasutus"</string>
    <string name="auto_brightness_disclaimer" msgid="871436423746343406">"Heledust optimeeritakse valgustingimuste järgi. Kui funktsioon on sisse lülitatud, saate heledust siiski ajutiselt reguleerida."</string>
    <string name="night_display_title" msgid="2626451512200357686">"Öövalgus"</string>
    <string name="night_display_text" msgid="1837277457033025056">"Funktsioon Öövalgus toonib ekraani kollaseks. Nii on hämaras ekraani mugavam vaadata ja sellelt teksti lugeda. See võib aidata teil ka hõlpsamini magama jääda."</string>
    <string name="night_display_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_temperature_title" msgid="1435292789272017136">"Intensiivsus"</string>
    <string name="night_display_summary_off" msgid="7009821232380000786">"Väljas. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="2305501561697289620">"Ei lülitu kunagi automaatselt sisse."</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="1548073080728058384">"Lülitub automaatselt sisse kell <xliff:g id="ID_1">%1$s</xliff:g>."</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="2737328390752018845">"Lülitub automaatselt sisse päikeseloojangul."</string>
    <string name="night_display_summary_on" msgid="6626224414971753417">"Sees. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="5217396859715040056">"Ei lülitu kunagi automaatselt välja."</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="887702685252504739">"Lülitub automaatselt välja kell <xliff:g id="ID_1">%1$s</xliff:g>."</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8574989770628425398">"Lülitub automaatselt välja päikesetõusu ajal."</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_settings_summary_default" msgid="3395741565658711416">"Vaikeseade"</string>
    <string name="wallpaper_settings_summary_custom" msgid="515035303981687172">"Kohandatud"</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="7302740999250873332">"Laadimise ajal või dokis"</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_never" msgid="5165622985174349585">"Mitte kunagi"</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="7262410541382890146">"Alustamise aeg"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Praegune ekraanisäästja"</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="doze_always_on_title" msgid="1046222370442629646">"Alati sees"</string>
    <string name="doze_always_on_summary" msgid="1254238982577776475">"Näitamise aeg, märguande ikoonid ja muu teave"</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="6242052161214271091">"SIM-kaardi lukk"</string>
    <string name="sim_lock_settings_summary_off" msgid="8028944267104896401">"Väljas"</string>
    <string name="sim_lock_settings_summary_on" msgid="39103355956342985">"Lukus"</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="2698176447067691396">"Valige SIM-kaart, mida eelistate kasutada mobiilse andmeside puhul."</string>
    <string name="sim_change_data_title" msgid="294357201685244532">"Muuta andmeside SIM-kaarti?"</string>
    <string name="sim_change_data_message" msgid="5854582807996717811">"Kas kasutada mobiilse andmeside puhul vana SIM-kaardi <xliff:g id="OLD_SIM">%2$s</xliff:g> asemel uut SIM-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="8466930554330635780">"<xliff:g id="NEW_SIM">%1$s</xliff:g> on ainuke seadmes olev SIM-kaart. Kas soovite mobiilse andmeside, kõnede ja SMS-sõnumite puhul kasutada seda SIM-kaarti?"</string>
    <string name="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_info" msgid="1952009518045740889">"Mudel"</string>
    <string name="hardware_info" msgid="2605080746512527805">"Mudel ja riistvara"</string>
    <string name="hardware_revision" msgid="8893547686367095527">"Riistvara versioon"</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="3279383550222116235">"Mobiilsidevõrgu tüüp"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Operaatori teave"</string>
    <string name="status_data_state" msgid="5503181397066522950">"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="8907101974576694793">"Muu hõlmab rakenduste salvestatud jagatud faile, Internetist või Bluetoothi kaudu allalaaditud faile, Androidi faile jne. \n\nSeadmes <xliff:g id="NAME">^1</xliff:g> nähtava sisu nägemiseks puudutage nuppu Avastage."</string>
    <string name="storage_detail_dialog_system" msgid="862835644848361569">"Jaotis Süsteem hõlmab Androidi versiooni <xliff:g id="VERSION">%s</xliff:g> käitamiseks vajalikke faile"</string>
    <string name="storage_detail_dialog_user" msgid="3267254783294197804">"Kasutajal <xliff:g id="USER_0">^1</xliff:g> võib olla salvestatud fotosid, muusikat, rakendusi või muid andmeid, mis võtavad <xliff:g id="SIZE">^2</xliff:g> ruumi. \n\nÜksikasjade vaatamiseks valige kasutaja <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>
    <!-- no translation found for error_adding_apn_type (4181334016628549645) -->
    <skip />
    <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_dashboard_title" msgid="4412694650600342973">"Lähtesta"</string>
    <string name="reset_network_title" msgid="4557113742173895074">"Võrguseadete lähtestamine"</string>
    <string name="reset_network_desc" msgid="5547979398298881406">"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="master_clear_title" msgid="5907939616087039756">"Tehaseandmete lähtestamine"</string>
    <plurals name="master_clear_with_account_summary" formatted="false" msgid="5911377203778818712">
      <item quantity="other"><xliff:g id="ACCOUNT_COUNT">%1$d</xliff:g> kontot lähtestatakse</item>
      <item quantity="one">1 konto lähtestatakse</item>
    </plurals>
    <string name="master_clear_summary" msgid="6902443944660426951">"Sisemine salvestusruum ja kõik andmed lähtestatakse"</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 rakenduste 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="erase_esim_storage" msgid="1886761972867390123">"Kustuta eSIM-kaardid"</string>
    <string name="erase_esim_storage_description" product="default" msgid="708691303677321598">"Kustutab kõik telefonis olevad eSIM-kaardid. See ei tühista teie mobiilsideteenuse paketti."</string>
    <string name="erase_esim_storage_description" product="tablet" msgid="1780953956941209107">"Kustutab kõik tahvelarvutis olevad eSIM-kaardid. See ei tühista teie mobiilsideteenuse paketti."</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">"Jagamine Bluetoothiga"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Jagamine"</string>
    <string name="tether_settings_title_all" msgid="3058586928118801157">"Kuumkoht ja jagamine"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="930464462687425777">"Leviala on sees, jagamine"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Leviala on sees"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="1618256180720077354">"Jagamine"</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">"Jagamine Bluetoothiga"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="2092766774943506688">"Tahvelarvuti Interneti-üh. jagam. Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="313873759999970236">"Telefoni Interneti-ühenduse jag. Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="6388191062495199481">"Tahvelarv. Interneti-üh. jag. Bluetoothi kaudu ühe seadmega"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="5970460338828861091">"Telef. Interneti-ühenduse jag. Bluetoothi kaudu ühe seadmega"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="3253150865825199632">"Tahvelarvuti Interneti-üh. jagam. Bluetoothi kaudu <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> seadmega"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8268867745495039177">"Telefoni Interneti-ühenduse jag. Bluetoothi kaudu <xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g> seadmega"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6326877798974938021">"Seadme <xliff:g id="DEVICE_NAME">%1$d</xliff:g> Interneti-ühenduse jag. Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="1889565070769307732">"Tahvelarv. Interneti-üh. ei jag. Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="1838503633450298902">"Telefoni Interneti-ühendust ei jagata Bluetoothi kaudu"</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_footer_info" msgid="7287131664937054043">"Muudele seadmetele Interneti-ühenduse pakkumiseks mobiilse andmesideühenduse kaudu kasutage ühenduse jagamise funktsiooni mobiilse kuumkohaga."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Abi"</string>
    <string name="network_settings_title" msgid="2876509814832830757">"Mobiilsidevõrk"</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_picker_title" msgid="6383879578279046456">"Võrgukvaliteedi hinnangute pakkuja"</string>
    <string name="network_scorer_picker_none_preference" msgid="9028375117241790936">"Mitte ükski"</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="9053814051811634125">"Operaatoril <xliff:g id="OPERATOR">%1$s</xliff:g> pole ettevalmistuse 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_app_level_permissions" msgid="1825588230817081339">"Rakendusetasemel load"</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="3453010562265338113">"Asukoha määramine GPS-i, WiFi-, Bluetoothi või mobiilsidevõrgu abil"</string>
    <string name="location_mode_battery_saving_description" msgid="2365298246603348985">"Asukoha määramine WiFi-, Bluetoothi või mobiilsidevõrgu abil"</string>
    <string name="location_mode_sensors_only_description" msgid="7247994752324805202">"Kasuta asukoha tuvastamiseks GPS-i ja seadme andureid"</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="9134175479520582215">"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="8525014571806471216">"Kolmanda osapoole 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="7128305504872026659">"Seade kasutab teie tööprofiili ekraanilukku. Mõlema luku puhul kehtivad tööreeglid."</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="5281808652705396152">"Rakenduste teave"</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>
    <!-- no translation found for recent_app_category_title (7212519567652392872) -->
    <skip />
    <!-- no translation found for see_all_apps_title (2428036869072119705) -->
    <skip />
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"Teie tahvelarvuti ja isiklikud andmed on tundmatute rakenduste rünnakute suhtes haavatavamad. Sellest allikast rakendusi installides nõustute, et vastutate tahvelarvuti kahjude ja andmekao eest, mis võib selliste rakenduste kasutamisest tuleneda."</string>
    <string name="install_all_warning" product="default" msgid="1952257127370115988">"Teie telefon ja isiklikud andmed on tundmatute rakenduste rünnakute suhtes haavatavamad. Sellest allikast rakendusi installides nõustute, et vastutate telefoni kahjude ja andmekao eest, mis võib selliste rakenduste kasutamisest tuleneda."</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">"Rakenduste 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="7376689739076506885">"Rakenduse suurus"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Rakendus USB-mäluseadmel"</string>
    <string name="data_size_label" msgid="6117971066063850416">"Kasutajaandmed"</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="8899612398848280352">"Kõik rakendused"</string>
    <string name="filter_apps_disabled" msgid="5862632369555319938">"Keelatud rakendused"</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="installed" msgid="3070865169422600098">"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="8673026002690505763">"Seadme administraatori rakendust ei saa installida välisele andmekandjale"</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="5632072173181990531">"Rakenduse keelamisel ei pruugi Android ja 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="5832078825810635913">"Rakenduse keelamisel ei pruugi Android ja muud rakendused enam ootuspäraselt töötada. Ka 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="instant_app_details_summary" msgid="4529934403276907045">"Lisateavet leiate teenusest <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">"Vaba"</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="input_assistance" msgid="7577795275222555487">"Sisestusabi"</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="4837897357002495384">"Kuva paroolid"</string>
    <string name="show_password_summary" msgid="3365397574784829969">"Sisestamisel kuvatakse korraks tähemärgid"</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="keyboard_and_input_methods_category" msgid="6035224122054465137">"Klaviatuur ja sisendid"</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_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="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="accessibility_settings_summary" msgid="981260486011624939">"Ekraanilugejad, ekraan, interaktsiooni juhtnupud"</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="screen_reader_category_title" msgid="7739154903913400641">"Ekraanilugejad"</string>
    <string name="audio_and_captions_category_title" msgid="3420727114421447524">"Heli ja ekraanil kuvatud tekst"</string>
    <string name="display_category_title" msgid="685461049938269166">"Ekraan"</string>
    <string name="interaction_control_category_title" msgid="7836591031872839151">"Interaktsiooni juhtnupud"</string>
    <string name="user_installed_services_category_title" msgid="6426376488922158647">"Allalaaditud teenused"</string>
    <string name="experimental_category_title" msgid="5272318666666893547">"Katseline"</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="select_to_speak_summary" msgid="4282846695497544515">"Ekraanil olevate üksuste ettelugemise kuulmiseks puudutage neid"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Tiitrid"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Suurendus"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Kolme puudutusega suurendamine"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="7141753038957538230">"Nupuga suurendamine"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="2760906043221923793">"Nupu ja kolmikpuudutusega suurendamine"</string>
    <string name="accessibility_preference_magnification_summary" msgid="5867883657521404509">"Suumige ekraanil sisse"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Suumimiseks puudutage kolm korda"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="3693116360267980492">"Suumimiseks puudutage nuppu"</string>
    <string name="accessibility_screen_magnification_summary" msgid="5258868553337478505"><b>"Suumimiseks"</b>" puudutage ekraani kiiresti kolm korda.\n"<ul><li>"Kerimiseks lohistage vähemalt kahe sõrmega"</li>\n<li>"Suumi reguleerimiseks suruge vähemalt kaht sõrme kokku"</li></ul>\n\n<b>"Ajutiselt suumimiseks"</b>" puudutage ekraani kiiresti kolm korda ja hoidke pärast kolmandat puudutust sõrme ekraanil.\n"<ul><li>"Lohistage ekraanil liikumiseks"</li>\n<li>"Väljasuumimiseks tõstke sõrm ekraanilt"</li></ul>\n\n"Klaviatuuril ja navigeerimisribal ei saa suumida."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="1996584694050087161">"Kui suurendus on sisse lülitatud, saate ekraani alaosas oleva juurdepääsetavuse nupuga kiiresti suurendada.\n\n"<b>"Suumimiseks"</b>" puudutage juurdepääsetavuse nuppu ja seejärel mis tahes punkti ekraanil.\n"<ul><li>"Kerimiseks lohistage vähemalt kahe sõrmega"</li>\n<li>"Suumi reguleerimiseks suruge vähemalt kaht sõrme kokku"</li></ul>\n\n<b>"Ajutiselt suumimiseks"</b>" puudutage juurdepääsetavuse nuppu ning seejärel puudutage ja hoidke mis tahes punkti ekraanil.\n"<ul><li>"Lohistage ekraanil liikumiseks"</li>\n<li>"Väljasuumimiseks tõstke sõrm ekraanilt"</li></ul>\n\n"Klaviatuuril ja navigeerimisribal ei saa suumida."</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="70533120652758190">"Juurdepääsetavuse nupu jaoks on valitud seade <xliff:g id="SERVICE">%1$s</xliff:g>. Suurenduse kasutamiseks puudutage ja hoidke juurdepääsetavuse nuppu ning seejärel valige suurendus."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="6752037184140789970">"Juurdepääsetavuse otsetee"</string>
    <string name="accessibility_shortcut_service_title" msgid="4779360749706905640">"Otsetee teenus"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="5490636079625489534">"Lukustuskuval lubamine"</string>
    <string name="accessibility_shortcut_description" msgid="6488524140219209763">"Kui otsetee on sisse lülitatud, võite hoida mõlemat helitugevuse nuppu kolm sekundit all, et käivitada juurdepääsetavusfunktsioon."</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_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="7052959202195368109">"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="accessibility_summary_default_combination" msgid="90096949592817459">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="accessibility_summary_state_enabled" msgid="8359913912320966304">"SEES"</string>
    <string name="accessibility_summary_state_disabled" msgid="2241315620132005595">"VÄLJAS"</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> teeb järgmist:"</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">"Märguannete vastuvõtmine rakenduse kasutamise ajal."</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_no_service_selected" msgid="2840969718780083998">"Ükski teenus ei ole valitud"</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>
    <string name="print_settings_summary_no_service" msgid="6354322414246865875">"Väljas"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="6005468025646083029">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> printimisteenust on sisse lülitatud</item>
      <item quantity="one">1 printimisteenus on sisse lülitatud</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="5810106725778525400">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> 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="background_activity_title" msgid="8618384801540759730">"Tegevus taustal"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Lubatakse rakenduse taustal käitamine"</string>
    <string name="background_activity_summary_on" msgid="649282072540085599">"Kui rakendust ei kasutata, võib see taustal töötada"</string>
    <string name="background_activity_summary_off" msgid="7666330699090632040">"Kui rakendust ei kasutata, on selle tegevus taustal piiratud"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"Rakendusel ei ole lubatud taustal töötada"</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Ekraani kasutus alates täislaadimisest"</string>
    <string name="device_screen_consumption" msgid="4607589286438986687">"Ekraani energiatarve"</string>
    <string name="device_cellular_network" msgid="4724773411762382950">"Mobiilivõrgustiku skannimine"</string>
    <string name="power_last_full_charge_summary" msgid="532845389094620657">"<xliff:g id="TIME">^1</xliff:g> tagasi"</string>
    <string name="power_usage_list_summary" msgid="6775339745194635000">"Rakenduste kasutus alates täislaadimisest (<xliff:g id="TIME">^1</xliff:g> tagasi)"</string>
    <string name="power_usage_list_summary_device" msgid="7036566616386864302">"Seadme kasutus alates täislaadimisest (<xliff:g id="TIME">^1</xliff:g> tagasi)"</string>
    <string name="screen_usage_summary" msgid="6687403051423153550">"Ekraani töötamise aeg alates viimasest täislaadimisest"</string>
    <string name="device_usage_list_summary" msgid="5623036661468763251">"Seadme 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="4137799310329041341">"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="advanced_battery_title" msgid="2068039111517508622">"Akukasutuse täpsemad andmed"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Ajaloo üksikasjad"</string>
    <string name="battery_details_title" msgid="6101394441569858580">"Akukasutus"</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="battery_abnormal_details_title" msgid="7803612642167433678">"Rakenduse ebatavaline käitumine"</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="3392999761958982492">"Mobiilsidevõrk on ooterežiimis"</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="power_apps" msgid="2043554781293951327">"Rakendused"</string>
    <string name="power_service" msgid="1599661212370831780">"Teenused"</string>
    <string name="power_system" msgid="8290455327965307383">"Süsteem"</string>
    <string name="power_user" msgid="1889728099253018005">"Kasutaja"</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">"Rakenduste 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="battery_used_for" msgid="2690821851327075443">"Kasutatud <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="6537658662149713585">"Ekraanikasutus: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="1135316757755282999">"<xliff:g id="APP">%2$s</xliff:g> kasutab <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="2093409063297375436">"<xliff:g id="PERCENT">%1$s</xliff:g> kogu akumahust"</string>
    <string name="battery_detail_since_full_charge" msgid="7515347842046955855">"Üksikasjalik teave alates viimasest täislaadimisest"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Viimane täislaadimine"</string>
    <string name="battery_footer_summary" msgid="4701358808575132647">"Aku järelejäänud tööaeg on ligikaudne ja võib olenevalt kasutusest muutuda."</string>
    <string name="battery_detail_foreground" msgid="3350401514602032183">"Aktiivse kasutamise ajal"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"Taustal"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Akukasutus"</string>
    <string name="battery_detail_power_percentage" msgid="8064814503316094497">"<xliff:g id="PERCENT">%1$s</xliff:g> kõigi rakenduste akukasutusest (<xliff:g id="POWER">%2$d</xliff:g>mAh)"</string>
    <string name="battery_detail_info_title" msgid="8227822131405620369">"Alates viimasest täislaadimisest"</string>
    <string name="battery_detail_manage_title" msgid="9094314252105828014">"Akukasutuse haldamine"</string>
    <string name="estimated_time_left" msgid="7514194472683370877">"Hinnanguline järelejäänud aeg"</string>
    <string name="estimated_charging_time_left" msgid="5614442409326164691">"Täislaadimiseni"</string>
    <string name="estimated_time_description" msgid="8760210909000037089">"Prognoos võib olenevalt kasutusest muutuda"</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="8665950426992057191">"aku taseme <xliff:g id="PERCENT">%1$s</xliff:g> juures"</string>
    <string name="battery_percentage" msgid="723291197508049369">"Aku laetuse protsent"</string>
    <string name="battery_percentage_description" msgid="8511658577507384014">"Olekuribal kuvatakse aku laetuse protsent"</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">"Vaba"</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_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_engine_preference_title" msgid="1578826947311494239">"Eelistatud kõnesünteesi mootor"</string>
    <string name="tts_engine_settings_title" msgid="6886964122861384818">"Kõnesünteesi mootori seaded"</string>
    <string name="tts_sliders_title" msgid="992059150784095263">"Kõne kiirus ja helikõrgus"</string>
    <string name="tts_engine_section_title" msgid="6289240207677024034">"Kõnesünteesi mootor"</string>
    <string name="tts_install_voice_title" msgid="6275828614052514320">"Hääled"</string>
    <string name="tts_spoken_language" msgid="5542499183472504027">"Hääle keel"</string>
    <string name="tts_install_voices_title" msgid="8808823756936022641">"Häälte installimine"</string>
    <string name="tts_install_voices_text" msgid="5292606786380069134">"Häälte installimiseks avage rakendus <xliff:g id="TTS_APP_NAME">%s</xliff:g>"</string>
    <string name="tts_install_voices_open" msgid="667467793360277465">"Ava rakendus"</string>
    <string name="tts_install_voices_cancel" msgid="4711492804851107459">"Tühista"</string>
    <string name="tts_reset" msgid="2661752909256313270">"Lähtesta"</string>
    <string name="tts_play" msgid="2628469503798633884">"Esita"</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="credential_for_vpn_and_apps" msgid="4168197158768443365">"Installitud VPN-i ja rakenduste jaoks"</string>
    <string name="credential_for_wifi" msgid="6228425986551591864">"Installitud WiFi jaoks"</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_title" msgid="2978878794187459190">"Varundamine"</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">"Varunduskonto"</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="685838037986644604">"Varundusteenus 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="4960761799560705902">"Seadme administraatori seaded"</string>
    <string name="active_device_admin_msg" msgid="578748451637360192">"Seadme administraatori rakendus"</string>
    <string name="remove_device_admin" msgid="9207368982033308173">"Inaktiveeri seadme administraatori rakendus"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Desinstalli rakendus"</string>
    <string name="remove_and_uninstall_device_admin" msgid="3837625952436169878">"Inaktiveeri ja desinstalli"</string>
    <string name="select_device_admin_msg" msgid="7347389359013278077">"Seadme administraatori rakendused"</string>
    <string name="no_device_admins" msgid="4846602835339095768">"Saadaval ei ole ühtki seadme administraatori rakendust"</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="1501847129819382149">"Kas aktiveerida administraatori rakenduse?"</string>
    <string name="add_device_admin" msgid="4192055385312215731">"Aktiveeri seadme administraatori rakendus"</string>
    <string name="device_admin_add_title" msgid="3140663753671809044">"Seadme administraator"</string>
    <string name="device_admin_warning" msgid="7482834776510188134">"Selle administraatori rakenduse aktiveerimisel lubatakse rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid."</string>
    <string name="device_admin_status" msgid="7234814785374977990">"See administraatori rakendus on aktiivne ja lubab rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid."</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Kas aktiveerida profiilihaldur?"</string>
    <string name="adding_profile_owner_warning" msgid="1354474524852805802">"Kui jätkate, haldab teie kasutajat edaspidi administraator, kes saab võib-olla talletada peale teie isiklike andmete ka seotud andmeid.\n\nTeie administraator saab jälgida ja hallata selle kasutajaga seotud seadeid, juurdepääsu, rakendusi ja andmeid, sealhulgas veebitegevusi ja seadme asukohateavet."</string>
    <string name="admin_disabled_other_options" msgid="7712694507069054530">"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="3901397272647112455">"Administraator on selle muudatuse keelanud"</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">"RAKENDUSTE TEAVE"</string>
    <string name="data_usage_cellular_data" msgid="9168928285122125137">"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="8339835014751511300">"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="8656552431969276305">"Kas lülitada mobiilne andmeside välja?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Seadke mobiilandmeside 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="454140350007299045">"Mobiil"</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="5588685410495019866">"Mobiilne"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Mitte ükski"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"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="5853552187570622572">"Luba taustal mobiilse andmeside kasutus"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"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="1466689968707308512">"Funktsiooni tõttu võivad taustaandmetel põhinev rakendus töötamast lakata, kui saadaval on ainult mobiilsidevõrgud.\n\nAndmekasutuse täpsemad juhtelemendid leiate rakenduse seadetest."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="55012417305745608">"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="4983487893343645667">"Tahvelarvuti lülitab teie määratud piiranguni jõudes mobiilse andmeside välja.\n\nKuna andmekasutust mõõdab tahvelarvuti ja operaator võib andmekasutust teisiti mõõta, kaaluge konservatiivse piirangu määramist."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3926320594049434225">"Telefon lülitab teie määratud piiranguni jõudes mobiilse andmeside välja.\n\nKuna andmekasutust mõõdab telefon ja teie operaator võib 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="434093644726734586">"Kui piirate taustal kasutatavat mobiilset andmesidet, 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="7096707497743363380">"Kui piirate taustal kasutatavat mobiilset andmesidet, siis toimivad mõned rakendused ja teenused ainult siis, kui seade on ühendatud WiFi-võrku.\n\nSee seade mõjutab kõiki selle tahvelarvuti kasutajaid."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="7910798414964288424">"Kui piirate taustal kasutatavat mobiilset andmesidet, siis toimivad mõned rakendused ja teenused ainult siis, kui seade on ühendatud WiFi-võrku.\n\nSee seade mõjutab kõiki selle 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="7655851702771342507">"Kui andmeside kasutus taustal on piiratud, siis koheldakse 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="5423305619126978393">"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_always_on_invalid_reason_type" msgid="7574518311224455825">"Seda tüüpi VPN ei saa olla alati ühendatud"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="477304620899799383">"Alati sisselülitatud VPN toetab ainult numbritest koosnevaid serveriaadresse"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="2226648961940273294">"Alati sisselülitatud VPN-i puhul peab olema määratud DNS-server"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3551394495620249972">"Alati sisselülitatud VPN-i puhul peab DNS-serveri aadress koosnema numbritest"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="5959352052515258208">"Sisestatud teave ei toeta alati sisselülitatud VPN-i"</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="3743970132487505659">"Kas soovite katkestada ühenduse 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_vpn_title" msgid="2963898301277610248">"Kas asendada olemasolev VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="4009987321156037267">"Kas määrata alati sisselülitatud VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="3025322109743675467">"Kui selle seade sisse lülitate, pole teil Interneti-ühendust, kuni VPN-iga ühenduse loomine õnnestub"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="2577928591361606641">"Teie olemasolev VPN asendatakse ja teil pole Interneti-ühendust, kuni VPN-iga ühenduse loomine õnnestub"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="3011818750025879902">"Teil juba on ühendus alati sisselülitatud VPN-iga. Kui jätkate mõne teisega, asendatakse teie olemasolev VPN ja alati sisselülitatud režiim lülitatakse välja."</string>
    <string name="vpn_replace_vpn_message" msgid="5611635724578812860">"Teil juba on ühendus VPN-iga. Kui jätkate mõne teisega, asendatakse teie olemasolev VPN."</string>
    <string name="vpn_turn_on" msgid="2363136869284273872">"Lülita sisse"</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="1352832123114214283">"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="5002741367858707244">"Ühtegi VPN-i pole lisatud"</string>
    <string name="vpn_always_on_summary" msgid="2821344524094363617">"Säilita alati ühendus VPN-iga"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="592304911378771510">"Rakendus ei toeta seda"</string>
    <string name="vpn_always_on_summary_active" msgid="8800736191241875669">"Valik Alati sees on aktiivne"</string>
    <string name="vpn_require_connection" msgid="8388183166574269666">"VPN-ita ühenduste blokeerimine"</string>
    <string name="vpn_require_connection_title" msgid="159053539340576331">"Kas vajate VPN-i ühendust?"</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_disconnected" msgid="280531508768927471">"Ühendus VPN-iga katkestati"</string>
    <string name="vpn_disconnected_summary" msgid="3082851661207900606">"Mitte ükski"</string>
    <string name="vpn_missing_cert" msgid="5357192202207234745">"Sertifikaat puudub. Proovige profiili muuta."</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="credential_contains" msgid="3984922924723974084">"See kirje sisaldab:"</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="1954061209643070652">"Mandaadi üksikasjad"</string>
    <string name="user_credential_removed" msgid="6514189495799401838">"Mandaat eemaldati: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="3729607560420971841">"Ühtegi kasutaja mandaati ei ole installitud"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Õigekirjakontroll"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Sisestage oma täieliku varunduse praegune parool siia"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Sisestage täielike varunduste uus parool siia"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Sisestage siia uuesti oma täieliku varunduse uus parool"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Määra varundusparool"</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="9072312646546364619">"Kasutajate lisamine lukustuskuval"</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="emergency_info_summary" msgid="5062945162967838521">"Kasutaja <xliff:g id="USER_NAME">%1$s</xliff:g> teave ja kontaktid"</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="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 teenuse 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="support_summary" msgid="8276116616493882830">"Abiartiklid, telefoni- ja vestlustugi"</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 märguanded"</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="9109302537004566098">"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>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="5597356221942118048">
      <item quantity="other">Kuva %d peidetud üksust</item>
      <item quantity="one">Kuva %d peidetud üksus</item>
    </plurals>
    <string name="network_dashboard_title" msgid="4771589228992391573">"Võrk ja Internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="3851083934739500429">"mobiil"</string>
    <string name="network_dashboard_summary_data_usage" msgid="3843261364705042212">"andmekasutus"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"leviala"</string>
    <string name="connected_devices_dashboard_title" msgid="2355264951438890709">"Ühendatud seadmed"</string>
    <string name="connected_devices_dashboard_summary" msgid="2390582103384791904">"Bluetooth, Cast, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="9106040742715366495">"Bluetooth, Cast"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Rakendused ja märguanded"</string>
    <string name="app_and_notification_dashboard_summary" msgid="2363314178802548682">"Load, vaikerakendused"</string>
    <string name="account_dashboard_title" msgid="4936890821712178853">"Kasutajad ja kontod"</string>
    <string name="app_default_dashboard_title" msgid="7342549305933047317">"Vaikerakendused"</string>
    <string name="system_dashboard_summary" msgid="5797743225249766685">"Keeled, aeg, varundamine, värskendused"</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="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="8995946622054642367">"mobiilne, mobiil, mobiilioperaator, juhtmeta, 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="keywords_payment_settings" msgid="5220104934130446416">"maksa, puuduta, maksed"</string>
    <string name="keywords_backup" msgid="470070289135403022">"varukoopia, varundamine"</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_dashboard_summary" msgid="3402435125958012986">"Helitugevus, vibreerimine, režiim Mitte segada"</string>
    <string name="sound_settings_summary_vibrate" msgid="1869282574422220096">"Telefonihelin on seatud vibreerima"</string>
    <string name="sound_settings_summary_silent" msgid="5074529767435584948">"Telefonihelin on seatud hääletuks"</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="4468722874617061231">"Märguande vaikeheli"</string>
    <string name="notification_unknown_sound_title" msgid="2535027767851838335">"Rakenduse esitatud heli"</string>
    <string name="notification_sound_default" msgid="565135733949733766">"Märguande vaikeheli"</string>
    <string name="alarm_ringtone_title" msgid="6344025478514311386">"Äratuse vaikeheli"</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_summary_off" msgid="1857165567766351925">"Ükski automaatne reegel ei ole sisse lülitatud"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="1216562765753405784">
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> automaatset reeglit on sisse lülitatud</item>
      <item quantity="one">1 automaatne reegel on sisse lülitatud</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="842308776768942600">"Režiimi Mitte segada eelistused"</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="5105443455143476201">"Režiimi Mitte segada reeglid"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="4732808039946935657">"Helid ja värinad on piiratud"</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="sound_work_settings" msgid="6774324553228566442">"Tööprofiili helid"</string>
    <string name="work_use_personal_sounds_title" msgid="1148331221338458874">"Kasuta isikl. profiili helisid"</string>
    <string name="work_use_personal_sounds_summary" msgid="6207040454949823153">"Isikliku ja tööprofiili helid on samad"</string>
    <string name="work_ringtone_title" msgid="5806657896300235315">"Töötelefoni helin"</string>
    <string name="work_notification_ringtone_title" msgid="6081247402404510004">"Töömärguande vaikeheli"</string>
    <string name="work_alarm_ringtone_title" msgid="1441926676833738891">"Tööalarmi vaikeheli"</string>
    <string name="work_sound_same_as_personal" msgid="3123383644475266478">"Sama mis isiklikul profiilil"</string>
    <string name="work_sync_dialog_title" msgid="7123973297187354813">"Kas soovite helid asendada?"</string>
    <string name="work_sync_dialog_yes" msgid="7243884940551635717">"Asenda"</string>
    <string name="work_sync_dialog_message" msgid="7841728953710863208">"Tööprofiili puhul kasutatakse teie isikliku profiili helisid"</string>
    <string name="ringtones_install_custom_sound_title" msgid="5948792721161302255">"Kas soovite lisada kohandatud heli?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="2195581481608512786">"Fail kopeeritakse kausta <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="5675912303120102366">"Helinad"</string>
    <string name="other_sound_category_preference_title" msgid="2521096636124314015">"Muud helid ja vibratsioonid"</string>
    <string name="configure_notification_settings" msgid="7616737397127242615">"Märguanded"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Täpsemad"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Töö märguanded"</string>
    <!-- no translation found for notification_badging_title (5938709971403474078) -->
    <skip />
    <string name="notification_pulse_title" msgid="1905382958860387030">"Vilkuv 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_channel_title" msgid="2260666541030178452">"Märguande kategooria"</string>
    <string name="notification_importance_title" msgid="848692592679312666">"Tähtsus"</string>
    <string name="notification_importance_unspecified" msgid="2196023702875112081">"Lubage rakendusel otsustada"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Ära kunagi kuva märguandeid"</string>
    <string name="notification_importance_min" msgid="5455049524984686275">"Heli ja visuaalne katkestus puudub"</string>
    <string name="notification_importance_low" msgid="8881468429453766553">"Heli puudub"</string>
    <string name="notification_importance_default" msgid="5958338024601957516">"Esita heli"</string>
    <string name="notification_importance_high" msgid="2082429479238228527">"Esita heli ja tõsta märguanne esile"</string>
    <string name="notification_importance_min_title" msgid="6974673091137544803">"Madal"</string>
    <string name="notification_importance_low_title" msgid="8131254047772814309">"Keskmine"</string>
    <string name="notification_importance_default_title" msgid="9120383978536089489">"Kõrge"</string>
    <string name="notification_importance_high_title" msgid="3058778300264746473">"Kiireloomuline"</string>
    <string name="allow_sound" msgid="1820188704793497324">"Heli lubamine"</string>
    <string name="show_silently_summary" msgid="7616604629123146565">"Ära tee heli, vibreeri ega kuva neid märguandeid praeguse ekraani servas."</string>
    <string name="default_notification_assistant" msgid="7631945224761430146">"Märguannete abi"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Juurdepääs märguannetele"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8748026238701253040">"Juurdepääs tööprofiili märguannetele on blokeeritud"</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 juurdepääsu märguannetele."</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">"VR-abilise teenused"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Ükski installitud rakendus pole taotlenud VR-abilise teenusena käitamist."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Kas lubada VR-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="8104485269504335481">"Kui seade on VR-režiimis"</string>
    <string name="display_vr_pref_low_persistence" msgid="5707494209944718537">"Vähenda hägusust (soovitatav)"</string>
    <string name="display_vr_pref_off" msgid="2190091757123260989">"Vähenda värelemist"</string>
    <string name="picture_in_picture_title" msgid="5824849294270017113">"Pilt pildis"</string>
    <string name="picture_in_picture_empty_text" msgid="685224245260197779">"Ükski installitud rakendus ei toeta funktsiooni Pilt pildis"</string>
    <string name="picture_in_picture_keywords" msgid="8361318686701764690">"pip pildis"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4080800421316791732">"Pilt pildis"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="1131910667023738296">"Luba režiim Pilt pildis"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="7942592478427522244">"Lubage rakendusel luua pilt pildis aken ajal, mil rakendus on avatud, või pärast sellest väljumist (näiteks video vaatamise jätkamiseks). Aken kuvatakse muude kasutatavate rakenduste peal."</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Mitte segada juurdepääs"</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_notifications_off_desc" msgid="4882445501376722969">"Android blokeerib selle rakenduse märguannete kuvamise selles seadmes"</string>
    <string name="channel_notifications_off_desc" msgid="5899225298718840635">"Android blokeerib selle märguandekategooria kuvamise selles seadmes"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Kategooriad"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Muu"</string>
    <string name="no_channels" msgid="3077375508177744586">"See rakendus pole postitanud ühtegi märguannet"</string>
    <string name="app_settings_link" msgid="8894946007543660906">"Lisaseaded rakenduses"</string>
    <string name="app_notification_listing_summary_zero" msgid="6482582965081108108">"Kõigi rakenduste jaoks sisse lülitatud"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="5668835155965827890">
      <item quantity="other">Välja lülitatud <xliff:g id="COUNT_1">%d</xliff:g> rakenduse jaoks</item>
      <item quantity="one">Välja lülitatud <xliff:g id="COUNT_0">%d</xliff:g> rakenduse jaoks</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="8028574302599397935">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategooriat on kustutatud</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategooria on kustutatud</item>
    </plurals>
    <string name="notification_toggle_on" msgid="650145396718191048">"Sees"</string>
    <string name="notification_toggle_off" msgid="2142010737190671762">"Väljas"</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Blokeeri kõik"</string>
    <string name="app_notification_block_summary" msgid="4744020456943215352">"Ära kunagi näita neid märguandeid"</string>
    <string name="notification_content_block_title" msgid="5854232570963006360">"Kuva märguanded"</string>
    <string name="notification_content_block_summary" msgid="7746185794438882389">"Ära kuva märguandeid kunagi märguandealal ega välisseadmetes"</string>
    <!-- no translation found for notification_badge_title (6370122441168519809) -->
    <skip />
    <!-- no translation found for notification_channel_badge_title (2240827899882847087) -->
    <skip />
    <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="notification_show_lights_title" msgid="7671781299688190532">"Vilkuv tuli"</string>
    <string name="notification_vibrate_title" msgid="1646667807969755957">"Vibreerimine"</string>
    <string name="notification_channel_sound_title" msgid="3899212238513507941">"Heli"</string>
    <string name="zen_mode_rule_delete_button" msgid="903658142711011617">"Kustuta"</string>
    <string name="zen_mode_rule_rename_button" msgid="4642843370946599164">"Nimeta ümber"</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="7459154136384467057">"Lisa veel"</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">"Mitte kelleltki"</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 eelvaated 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="1085834515677448072">"Sisestage administraatori PIN-kood"</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 sees, saab ekraanikuva kinnitada. Nii jääb kuva avatuks, kuni selle tühistate.\n\nKuva kinnitamiseks tehke järgmist.\n\n1. Veenduge, et ekraanikuva kinnitamine oleks sisse lülitatud.\n\n2. Avage kuva, mille soovite kinnitada.\n\n3. Puudutage Ülevaade.\n\n4. Pühkige üles ja puudutage 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="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="2317181134653424679">"Seadme tõhusamaks kaitsmiseks saate nõuda PIN-koodi sisestamist, enne kui seade käivitub. Enne käivitumist ei saa seadmega kõnesid, sõnumeid ega märguandeid, sealhulgas alarme, vastu võtta. \n\nSee aitab kaitsta kaotsiläinud või varastatud seadmetes olevaid andmeid. Kas soovite nõuda seadme käivitamiseks PIN-koodi sisestamist?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="7081249914068568570">"Seadme tõhusamaks kaitsmiseks saate nõuda mustri sisestamist, enne kui seade käivitub. Enne käivitumist ei saa seadmega kõnesid, sõnumeid ega märguandeid, sealhulgas alarme, vastu võtta. \n\nSee aitab kaitsta kaotsiläinud või varastatud seadmetes olevaid andmeid. Kas soovite nõuda seadme käivitamiseks mustri sisestamist?"</string>
    <string name="encryption_interstitial_message_password" msgid="7796567133897436443">"Seadme tõhusamaks kaitsmiseks saate nõuda parooli sisestamist, enne kui seade käivitub. Enne käivitumist ei saa seadmega kõnesid, sõnumeid ega märguandeid, sealhulgas alarme, vastu võtta. \n\nSee aitab kaitsta kaotsiläinud või varastatud seadmetes olevaid andmeid. Kas soovite nõuda seadme käivitamiseks parooli sisestamist?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="4550632760119547492">"Peale sõrmejäljega avamise funktsiooni saate seadme tõhusamaks kaitsmiseks nõuda PIN-koodi sisestamist, enne kui seade käivitub. Enne käivitumist ei saa seadmega kõnesid, sõnumeid ega märguandeid, sealhulgas alarme, vastu võtta. \n\nSee aitab kaitsta kaotsiläinud või varastatud seadmetes olevaid andmeid. Kas soovite nõuda seadme käivitamiseks PIN-koodi sisestamist?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="932184823193006087">"Peale sõrmejäljega avamise funktsiooni saate seadme tõhusamaks kaitsmiseks nõuda mustri sisestamist, enne kui seade käivitub. Enne käivitumist ei saa seadmega kõnesid, sõnumeid ega märguandeid, sealhulgas alarme, vastu võtta. \n\nSee aitab kaitsta kaotsiläinud või varastatud seadmetes olevaid andmeid. Kas soovite nõuda seadme käivitamiseks mustri sisestamist?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="5560954719370251702">"Lisaks sellele, et saate seadme avamiseks kasutada sõrmejälge, saate oma seadet veelgi paremini kaitsta, nõudes käivitamisel parooli. Enne seadme käivitumist ei saa te vastu võtta kõnesid, sõnumeid ega märguandeid, sh alarme.\n\nSee aitab kaitsta kaotatud või varastatud seadmetes olevaid andmeid. Kas küsida seadme käivitamisel parooli?"</string>
    <string name="encryption_interstitial_yes" msgid="4439509435889513411">"Jah"</string>
    <string name="encryption_interstitial_no" msgid="8935031349097025137">"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="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="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="8543457911148619898">"Rakenduse märguanded"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Sees"</string>
    <string name="notifications_disabled" msgid="334416731283131597">"Kõik on välja lülitatud"</string>
    <string name="notifications_partly_blocked" msgid="592071133950126656">"<xliff:g id="COUNT_0">%1$d</xliff:g> kategooriat <xliff:g id="COUNT_1">%2$d</xliff:g>-st on väljas"</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>
    <string name="notification_summary_channel" msgid="5831124672372023524">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</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="5395727306799456250">"Installitud rakendused"</string>
    <string name="filter_instant_apps" msgid="574277769963965565">"Installimata avat. rakendused"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Isiklik"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Töö"</string>
    <string name="filter_notif_all_apps" msgid="2299049859443680242">"Rakendused: kõik"</string>
    <string name="filter_notif_blocked_apps" msgid="3300375727887991342">"Rakendused: välja lülitatud"</string>
    <string name="filter_notif_urgent_channels" msgid="3972473613117159653">"Kategooriad: kiireloomuline"</string>
    <string name="filter_notif_low_channels" msgid="4128487387390004604">"Kategooriad: vähetähtis"</string>
    <string name="filter_notif_blocked_channels" msgid="5880190882221644289">"Kategooriad: välja lülitatud"</string>
    <string name="filter_notif_dnd_channels" msgid="1817930848881696728">"Kategooriad: alist. Mitte seg."</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">"Rakenduste load"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Rakendused, millel on rakenduse <xliff:g id="APPS">%1$s</xliff:g> luba"</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>
    <string name="domain_urls_apps_summary_off" msgid="1833056772600031220">"Ükski rakendus ei ava toetatud linke"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="240214361240709399">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> rakendust, mis avavad toetatud linke</item>
      <item quantity="one">Üks rakendus, mis avab 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="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="additional_battery_info" msgid="4754099329165411970">"Teated kasutuse kohta"</string>
    <string name="show_all_apps" msgid="1512506948197818534">"Kuva seadme kogu kasutusteave"</string>
    <string name="hide_extra_apps" msgid="5016497281322459633">"Kuva rakenduse kasutusteave"</string>
    <string name="power_high_usage_title" msgid="6027369425057347826">"Suur kasutus"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="467347882627862744">
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> rakendust käitub ebatavaliselt</item>
      <item quantity="one"><xliff:g id="APP">%1$s</xliff:g> käitub ebatavaliselt</item>
    </plurals>
    <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>
    <string name="high_power_prompt_title" msgid="6358673688590282655">"Kas soovite lubada rakendusel pidevalt taustal töötada?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"Kui lubate rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> pidevalt taustal töötada, võib see vähendada aku tööiga.\n\nSaate seda hiljem muuta jaotises Seaded &gt; Rakendused ja märguanded."</string>
    <string name="battery_summary" msgid="8044042095190688654">"Kasutus alates viimasest täislaadimisest on <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_power_management" msgid="5571519699679107523">"Toitehaldus"</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="3461232831015575152">"Laadige ühendatud seadet. Töötab ainult seadmetes, mis toetavad USB kaudu laadimist."</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="usb_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Seadme laadimine"</string>
    <string name="usb_summary_power_only" msgid="3629517713817003738">"Toiteallikas"</string>
    <string name="usb_summary_file_transfers" msgid="6435943692610175111">"Failide edastamine"</string>
    <string name="usb_summary_photo_transfers" msgid="8440204169576585250">"Fotode edastamine (PTP)"</string>
    <string name="usb_summary_MIDI" msgid="5687906612187885908">"Seadme kasutamine MIDI-režiimis"</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="2918050775124911939">"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" msgid="6564116025404257047">"Muude rakenduste peal kuvamine"</string>
    <string name="system_alert_window_settings" msgid="8466613169103527868">"Muude rakenduste peal kuvamine"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Rakendused"</string>
    <string name="system_alert_window_access_title" msgid="6297115362542361241">"Muude rakenduste peal kuvamine"</string>
    <string name="permit_draw_overlay" msgid="7456536798718633432">"Luba muude rakenduste peal kuvamine"</string>
    <string name="app_overlay_permission_preference" msgid="9039432222453006038">"Rakenduse peal kuvamise luba"</string>
    <string name="allow_overlay_description" msgid="8961670023925421358">"Lubage see rakendus kuvada muude kasutatavate rakenduste peal. See võib häirida nende rakenduste kasutamist või muuta nende käitumist või kuvamisviisi."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"VR virtuaalreaalne kuulaja stereo abiline teenus"</string>
    <string name="keywords_system_alert_window" msgid="5049498015597864850">"süsteem teatis aken dialoog muude rakenduste peal kuvamine"</string>
    <string name="overlay_settings" msgid="6930854109449524280">"Muude rakenduste peal kuvamine"</string>
    <string name="system_alert_window_summary" msgid="602892301318324492">"<xliff:g id="COUNT_0">%1$d</xliff:g> rakendusel <xliff:g id="COUNT_1">%2$d</xliff:g>-st on lubatud muude rakenduste peal kuvada"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Loaga rakendused"</string>
    <string name="app_permission_summary_allowed" msgid="1505409933012886711">"Lubatud"</string>
    <string name="app_permission_summary_not_allowed" msgid="2592617058101882802">"Pole lubatud"</string>
    <string name="install_other_apps" msgid="6986686991775883017">"Tundmatute rakenduste installimine"</string>
    <string name="keywords_install_other_apps" msgid="761078076051006558">"rakenduste installimine tundmatutest allikatest"</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">%1$d</xliff:g> <xliff:g id="COUNT_1">%2$d</xliff:g>-st rakendusest võivad muuta süsteemiseadeid"</string>
    <string name="filter_install_sources_apps" msgid="3102976274848199118">"Saab installida teisi rakendusi"</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="external_source_switch_title" msgid="3621381992793251070">"Luba sellest allikast"</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="disconnected" msgid="4836600637485526329">"Ühendus puudub"</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="3941492005316143599">
      <item quantity="other">Välja lülitatud <xliff:g id="COUNT">%d</xliff:g> rakenduse jaoks</item>
      <item quantity="one">Välja lülitatud 1 rakenduse jaoks</item>
    </plurals>
    <string name="notification_summary_none" msgid="4586376436702610">"Sisse lülitatud kõigi rakenduste jaoks"</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="3801281635351732202">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> on kasutatud – <xliff:g id="FREE_SPACE">%2$s</xliff:g> on vaba"</string>
    <string name="storage_summary_with_sdcard" msgid="3290457009629490121">"Sisemine salvestusruum: <xliff:g id="PERCENTAGE">%1$s</xliff:g> kasutatud, <xliff:g id="FREE_SPACE">%2$s</xliff:g> vaba"</string>
    <string name="display_summary" msgid="6737806235882127328">"Pärast <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> tegevusetut olekut lülitatakse unerežiimi"</string>
    <string name="display_dashboard_summary" msgid="4145888780290131488">"Taustapilt, unerežiim, fondi suurus"</string>
    <string name="display_summary_example" msgid="9102633726811090523">"Lülita unerežiimi pärast 10-minutilist tegevuseta olekut"</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="users_and_accounts_summary" msgid="245282689646897882">"Praegune kasutaja: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="users_summary" msgid="1674864467098487328">"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="924181828102801010">"Android värskendati versioonile <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Keelatud toiming"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="7399450998356045023">"Helitugevust ei saa muuta"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="7919816644946067058">"Helistamine ei ole lubatud"</string>
    <string name="disabled_by_policy_title_sms" msgid="5733307423899610340">"SMS-id ei ole lubatud"</string>
    <string name="disabled_by_policy_title_camera" msgid="6225008536855644874">"Kaamera ei ole lubatud"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="4066913623298047094">"Ekraanipildi tegemine ei ole lubatud"</string>
    <string name="default_admin_support_msg" msgid="2853684309779513863">"Toiming on keelatud. Küsige lisateavet organisatsiooni administraatorilt."</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Rohkem üksikasju"</string>
    <string name="admin_profile_owner_message" msgid="5860816886981109626">"Teie administraator saab jälgida ja hallata teie tööprofiiliga seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_profile_owner_user_message" msgid="3842630535450382172">"Teie administraator saab jälgida ja hallata selle kasutajaga seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_device_owner_message" msgid="6232893638259790789">"Teie administraator saab jälgida ja hallata selle seadmega seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="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">"Lennurežiim on sees"</string>
    <string name="condition_airplane_summary" msgid="5561586417832393666">"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="1327317003797575735">"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="5443722724310650381">"Ekraan on toonitud kollaseks. 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="telephony_monitor_toast" msgid="7003764250271195384">"Teenuse Telephony Monitor muudatuse rakendamiseks taaskäivitage seade"</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="2155683719898158203">"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="405684854174361041">"<xliff:g id="AMOUNT">^1</xliff:g> mobiilset andmesidet"</string>
    <string name="wifi_data_template" msgid="6265570748799357386">"<xliff:g id="AMOUNT">^1</xliff:g> WiFi-andmeid"</string>
    <string name="ethernet_data_template" msgid="5782476509881033590">"<xliff:g id="AMOUNT">^1</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_fragment_summary" msgid="8231066353654583106">"Iga kuu <xliff:g id="ID_1">%1$s</xliff:g>. päeval"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Võrgupiirangud"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="4301618027244595839">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> piirangut</item>
      <item quantity="one">1 piirang</item>
    </plurals>
    <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="set_data_warning" msgid="6115364758236594593">"Andmekasutuse hoiatuse määramine"</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="952796077540228711">"Piiramata andmed"</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_badge" msgid="3258183328267662285">"saab kuvada märgi"</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="3458780842491881155">"Rakenduste erijuurdepääs"</string>
    <plurals name="special_access_summary" formatted="false" msgid="260765309935675867">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> rakendusel on piiranguteta juurdepääs andmesidele</item>
      <item quantity="one">1 rakendusel on piiranguteta juurdepääs andmesidele</item>
    </plurals>
    <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_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="2456198532288640046">"Ei ole teiste seadmete jaoks nähtav"</string>
    <string name="bluetooth_connected_summary" msgid="7672528674593152862">"Ühendatud seadmega <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="9173661896296663932">"Ühendatud mitme seadmega"</string>
    <string name="demo_mode" msgid="2798762752209330277">"Süsteemi kasutajaliidese demorežiim"</string>
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Arendaja kiirseadete paanid"</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">%1$s</xliff:g> – <xliff:g id="LANGUAGE">%2$s</xliff:g>"</string>
    <string name="support_phone_international_format" msgid="2143528744844720829">"<xliff:g id="LANGUAGE">%1$s</xliff:g> (<xliff:g id="PHONE">%2$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_do_not_show" msgid="3378367075323727539">"Ära kuva enam"</string>
    <string name="support_account_request_prefix" msgid="6387847874661861650">"Taotlemine kasutajana"</string>
    <string name="support_account_picker_add_account" msgid="5076277544846506214">"Konto lisamine"</string>
    <string name="support_system_information_title" msgid="3439905790018934773">"Süsteemiteave"</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="4033736910560673690">"Liigutuspõhised otseteed"</string>
    <string name="gesture_preference_summary" product="default" msgid="8627850388011956901">"Kiirliigutused telefoni juhtimiseks"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4717535378272065510">"Kiirliigutused tahvelarvuti juhtimiseks"</string>
    <string name="gesture_preference_summary" product="device" msgid="4205941452664950852">"Kiirliigutused seadme juhtimiseks"</string>
    <string name="double_tap_power_for_camera_title" msgid="64716226816032800">"Kaamera avamine"</string>
    <string name="double_tap_power_for_camera_summary" msgid="242037150983277829">"Kaamera kiireks avamiseks vajutage toitenuppu kaks korda. 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" product="default" msgid="5144814600610448504">"Topeltpuudutage telefoni kontrollimiseks"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Topeltpuudutage tahvelarvuti kontrollimiseks"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Topeltpuudutage seadme kontrollimiseks"</string>
    <string name="ambient_display_summary" msgid="2521630136233865893">"Märguannete kiireks kontrollimiseks topeltpuudutage ekraani."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="818688002837687268">"Telefoni kontrollimiseks tõstmine"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="4455864282995698097">"Tahvelarvuti kontrollimiseks tõstke seda"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="5380534405773531175">"Seadme kontrollimiseks tõstke seda"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="8696432220086951466">"Märguannete kiireks kontrollimiseks võtke telefon kätte."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="2442551819015699120">"Märguannete kiireks kontrollimiseks võtke tahvelarvuti kätte."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="2369325441608811599">"Märguannete kiireks kontrollimiseks võtke seade kätte."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Sõrmejälje pühkimine märguannete vaatamiseks"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="1770661868393713922">"Märguannete kontrollimiseks pühkige telefoni tagaküljel oleval sõrmejäljeanduril alla."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="902719947767712895">"Märguannete kontrollimiseks pühkige tahvelarvuti tagaküljel oleval sõrmejäljeanduril alla."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="5372926094116306647">"Märguannete kontrollimiseks pühkige seadme tagaküljel oleval sõrmejäljeanduril alla."</string>
    <string name="camera_lift_trigger_title" msgid="2758206307949942951">"Tõstke kaamera avamiseks"</string>
    <string name="camera_lift_trigger_summary" msgid="8580625412416846375">"Kaamera automaatseks avamiseks tõstke oma telefon foto jäädvustamise asendisse (maastiku- või portreevõte). Töötab ka siis, kui telefon on unerežiimis või lukustatud."</string>
    <!-- no translation found for camera_lift_trigger_suggestion_summary (7209899898244722404) -->
    <skip />
    <string name="assist_gesture_title" msgid="7746563137898655539">"Abiliigutus"</string>
    <string name="assist_gesture_summary" msgid="7575773425455374300"></string>
    <string name="assist_gesture_sensitivity_title" msgid="8424299091547331080">"Tundlikkus"</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>
    <string name="web_action_enable_title" msgid="4051513950976670853">"Installimata avatavad rakendused"</string>
    <string name="web_action_enable_summary" msgid="3108127559723396382">"Lingid avatakse rakendustes isegi siis, kui need pole installitud"</string>
    <string name="web_action_section_title" msgid="7364647086538399136">"Installimata avatavad rakendused"</string>
    <string name="instant_apps_account" msgid="1433620209791992528">"Installimata avatavate rakenduste konto"</string>
    <string name="domain_url_section_title" msgid="7046835219056428883">"Installitud rakendused"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="6353100011690933254">"Teie salvestusruumi haldab nüüd salvestusruumi haldur"</string>
    <string name="account_for_section_header" msgid="5356566418548737121">"Kasutaja <xliff:g id="USER_NAME">%1$s</xliff:g> kontod"</string>
    <string name="configure_section_header" msgid="7391183586410814450">"Seadistamine"</string>
    <string name="auto_sync_account_title" msgid="898796354710116383">"Sünkrooni andmed automaatselt"</string>
    <string name="auto_sync_personal_account_title" msgid="8496263182646100610">"Sünkrooni isiklikud andmed automaatselt"</string>
    <string name="auto_sync_work_account_title" msgid="4489172450037434152">"Sünkrooni tööandmed automaatselt"</string>
    <string name="auto_sync_account_summary" msgid="692499211629185107">"Luba rakendustel andmeid automaatselt värskendada"</string>
    <string name="account_sync_title" msgid="7214747784136106491">"Konto sünkroonimine"</string>
    <string name="enterprise_privacy_settings" msgid="1177106810374146496">"Hallatava seadme teave"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5853292305730761128">"Teie organisatsiooni hallatavad muudatused ja seaded"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="4266234968317996188">"Organisatsiooni <xliff:g id="ORGANIZATION_NAME">%s</xliff:g> hallatavad muudatused ja seaded"</string>
    <string name="enterprise_privacy_header" msgid="7402406406883832509">"Teie tööandmetele juurdepääsu andmiseks võib teie organisatsioon muuta seadeid ja installida seadmesse tarkvara. \n\nLisateabe saamiseks võtke ühendust organisatsiooni administraatoriga."</string>
    <string name="enterprise_privacy_exposure_category" msgid="7313392680107938517">"Teie organisatsiooni nähtava teabe tüübid"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="9079283547182933771">"Teie organisatsiooni administraatori tehtud muudatused"</string>
    <string name="enterprise_privacy_device_access_category" msgid="5423434164248819058">"Teie juurdepääs sellele seadmele"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="2773968662865848413">"Teie töökontoga seotud andmed, nt e-post ja kalender"</string>
    <string name="enterprise_privacy_installed_packages" msgid="2313698828178764590">"Teie seadmes olevate rakenduste loend"</string>
    <string name="enterprise_privacy_usage_stats" msgid="4398411405572759370">"Iga rakenduse kasutamise aeg ja kasutatud andmemaht"</string>
    <string name="enterprise_privacy_network_logs" msgid="161722817268849590">"Uusim võrguliikluse logi"</string>
    <string name="enterprise_privacy_bug_reports" msgid="843225086779037863">"Kõige viimane veaaruanne"</string>
    <string name="enterprise_privacy_security_logs" msgid="5377362481617301074">"Kõige viimane turvalogi"</string>
    <string name="enterprise_privacy_none" msgid="7706621148858381189">"Mitte kunagi"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="6353757812144878828">"Installitud rakendused"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7433213592572082606">"Rakenduste arv on hinnanguline. See ei pruugi hõlmata muudest allikatest kui Play poest installitud rakendusi."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="3005116533873542976">
      <item quantity="other">Vähemalt <xliff:g id="COUNT_1">%d</xliff:g> rakendust</item>
      <item quantity="one">Vähemalt <xliff:g id="COUNT_0">%d</xliff:g> rakendus</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="4158197200885270634">"Asukohale juurdepääsu load"</string>
    <string name="enterprise_privacy_microphone_access" msgid="5717375623568864441">"Mikrofoni load"</string>
    <string name="enterprise_privacy_camera_access" msgid="4858146118537519375">"Kaamera load"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="3288495615791128724">"Vaikerakendused"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="2765037387436064893">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> rakendust</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> rakendus</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="6531350246850814920">"Vaikeklaviatuur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="4941106433683067953">"Määratud valikule <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="4409098287763221215">"Alati sees VPN on sisse lülitatud"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="9217774730260037434">"Alati sees VPN on teie isiklikul profiilil sisse lülitatud"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="7244472958208315814">"Alati sees VPN on teie tööprofiilil sisse lülitatud"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="7936664553416257333">"Üldine HTTP-puhverserver on seadistatud"</string>
    <string name="enterprise_privacy_ca_certs" msgid="5885892204903688909">"Usaldusväärsed mandaadid"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="526375234629534165">
      <item quantity="other">Vähemalt <xliff:g id="COUNT_1">%d</xliff:g> CA-sertifikaati</item>
      <item quantity="one">Vähemalt <xliff:g id="COUNT_0">%d</xliff:g> CA-sertifikaat</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="8791656477097208540">"Administraator saab seadme lukustada ja parooli lähtestada"</string>
    <string name="enterprise_privacy_wipe_device" msgid="2821960015797241790">"Administraator saab kustutada kõik seadme andmed"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="1001255609345002878">"Parooli sisestamise ebaõnnestunud katsete arv enne seadmes olevate kõigi andmete kustutamist"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="4040565826652951057">"Parooli sisestamise ebaõnnestunud katsete arv enne tööprofiilil olevate andmete kustutamist"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="5279099270351036696">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> katset</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> katse</item>
    </plurals>
    <string name="do_disclosure_generic" msgid="8653670456990823307">"Seda seadet haldab teie organisatsioon."</string>
    <string name="do_disclosure_with_name" msgid="1141081465968481380">"Seda seadet haldab <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="3558079393757238670">" "</string>
    <string name="do_disclosure_learn_more" msgid="2416766240581561009">"Lisateave"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="1134677050353971363">
      <item quantity="other">Kaamerarakendused</item>
      <item quantity="one">Kaamerarakendus</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="3545972964391065220">"Kalendrirakendus"</string>
    <string name="default_contacts_app_title" msgid="3497370557378660098">"Rakendus Kontaktid"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="42826975161049245">
      <item quantity="other">Meilikliendirakendused</item>
      <item quantity="one">Meilikliendirakendus</item>
    </plurals>
    <string name="default_map_app_title" msgid="7560143381633608567">"Kaardirakendus"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="6714041230953195024">
      <item quantity="other">Telefonirakendused</item>
      <item quantity="one">Telefonirakendus</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="4309216198909946380">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="8949045544491604376">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_photos_videos" msgid="319854636702241898">"Fotod ja videod"</string>
    <string name="storage_music_audio" msgid="789779084825206838">"Muusika ja heli"</string>
    <string name="storage_games" msgid="7703159201697117621">"Mängud"</string>
    <string name="storage_other_apps" msgid="5524321740031718083">"Muud rakendused"</string>
    <string name="storage_files" msgid="8581083146777364063">"Failid"</string>
    <string name="storage_size_large_alternate" msgid="3550744227788333060">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" <xliff:g id="UNIT">^2</xliff:g>"</small>""</string>
    <string name="storage_volume_total" msgid="3499221850532701342">"Kasutatud <xliff:g id="TOTAL">%1$s</xliff:g>-st"</string>
    <string name="storage_percent_full" msgid="6095012055875077036">"kasut."</string>
    <string name="clear_instant_app_data" msgid="2004222610585890909">"Tühjenda rakendus"</string>
    <string name="clear_instant_app_confirmation" msgid="7451671214898856857">"Kas soovite selle installimata avatava rakenduse eemaldada?"</string>
    <string name="game_storage_settings" msgid="3410689937046696557">"Mängud"</string>
    <string name="audio_files_title" msgid="4777048870657911307">"Helifailid"</string>
    <string name="app_info_storage_title" msgid="5554719444625611987">"Kasutatav ruum"</string>
    <string name="webview_uninstalled_for_user" msgid="1819903169194420983">"(desinstall. kasutaja <xliff:g id="USER">%s</xliff:g> jaoks)"</string>
    <string name="webview_disabled_for_user" msgid="1216426047631256825">"(keelatud kasutaja <xliff:g id="USER">%s</xliff:g> jaoks)"</string>
    <string name="autofill_app" msgid="7338387238377914374">"Automaattäite teenus"</string>
    <string name="autofill_keywords" msgid="7485591824120812710">"automaatne, täide, automaattäide"</string>
    <string name="autofill_confirmation_message" msgid="2784869528908005194">"&lt;b&gt;Veenduge, et rakendus oleks usaldusväärne&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google\'i automaatne täitmine&gt;%1$s&lt;/xliff:g&gt; kasutab automaatse täitmise sisestuse määramiseks ekraanil kuvatut."</string>
    <string name="device_theme" msgid="4571803018917608588">"Seadme teema"</string>
    <string name="default_theme" msgid="7085644992078579076">"Vaikeseade"</string>
    <string name="storage_manager_indicator" msgid="1516810749625915020">"Salvestusruumi haldur: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="7488057587180724388">"Väljas"</string>
    <string name="storage_manager_indicator_on" msgid="8625551710194584733">"Sees"</string>
    <string name="install_type_instant" msgid="3174425974536078647">"Installimata avatav rakendus"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="5605210730828410482">"Kas soovite salvestusruumi halduri välja lülitada?"</string>
    <string name="storage_movies_tv" msgid="5498394447562086890">"Filmi- ja TV-rakendused"</string>
    <string name="carrier_provisioning" msgid="4398683675591893169">"Operaatori ettevalmistamise teave"</string>
    <string name="trigger_carrier_provisioning" msgid="3434865918009286187">"Operaatori ettevalmistamise päästik"</string>
</resources>
