<?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="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_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="cbrs_data_switch_string" msgid="2811485394350106691">"CBRS-i andmed"</string>
    <string name="dsds_switch_string" msgid="4832797810509029243">"Luba DSDS"</string>
    <string name="dsds_dialog_title" msgid="4031918551366689574">"Kas soovite seadme taaskäivitada?"</string>
    <string name="dsds_dialog_message" msgid="8593083316067158412">"Selle seade muutmiseks peate seadme taaskäivitama."</string>
    <string name="dsds_dialog_confirm" msgid="2853118984344309612">"Taaskäivita"</string>
    <string name="dsds_dialog_cancel" msgid="654653450305828711">"Tühista"</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="7830252930348734303">"Kas katkestada seadme ühendus?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="8208712728668714199">"Teie telefon katkestab ühenduse seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="6611038575213485336">"Teie tahvelarvuti katkestab ühenduse seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="3995834526315103965">"Teie seade katkestab ühenduse seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="3308586619539119106">"Katk. üh."</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="7429413067477968637">"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" product="default" msgid="1109366350000220283">"Telefoni Bluetoothi aadress: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="6807634484499166486">"Tahvelarvuti Bluetoothi aadress: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="8413944740341742061">"Seadme Bluetoothi 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_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="3144149432555230410">"Vastuvõetud failid"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="5445105773989432594">"Bluetoothi kaudu saadud failid"</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_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="522235742194965734">"Teistele seadmetele nähtav seadmena „<xliff:g id="DEVICE_NAME">^1</xliff:g>”"</string>
    <string name="bluetooth_off_footer" msgid="8406865700572772936">"Teiste seadmetega ühendamiseks lülitage Bluetooth sisse."</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Teie seadmed"</string>
    <string name="bluetooth_pairing_page_title" msgid="7712127387361962608">"Uue seadme sidumine"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3520035819421024105">"Lubage oma tahvelarvutil lähedalasuvate Bluetoothi seadmetega suhelda"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2205100629387332862">"Lubage oma seadmel lähedalasuvate Bluetoothi seadmetega suhelda"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="782032074675157079">"Lubage telefonil suhelda lähedalasuvate Bluetoothi seadmetega"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="4936610906348223810">"Keela Bluetoothi A2DP riistvara mahalaadimine"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="4340101417209145308">"Kas taaskäivitada seade?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8827019472003234568">"Selle seade muutmiseks peate seadme taaskäivitama."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="2053793518537051975">"Taaskäivita"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="2382443064737856652">"Loobu"</string>
    <string name="connected_device_available_media_title" msgid="2560067541413280645">"Saadaolevad meediaseadmed"</string>
    <string name="connected_device_available_call_title" msgid="697154660967595684">"Saadaolevad helistamisseadmed"</string>
    <string name="connected_device_connected_title" msgid="5871712271201945606">"Praegu ühendatud"</string>
    <string name="connected_device_saved_title" msgid="688364359746674536">"Salvestatud seadmed"</string>
    <string name="connected_device_add_device_summary" msgid="4041865900298680338">"Bluetooth lülitatakse sidumiseks sisse"</string>
    <string name="connected_device_connections_title" msgid="5988939345181466770">"Ühenduse eelistused"</string>
    <string name="connected_device_previously_connected_title" msgid="491765792822244604">"Varem ühendatud seadmed"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="6196066429488377795">"Eelnevalt ühendatud"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="5683648191381637533">"Bluetooth on sisse lülitatud"</string>
    <string name="previous_connected_see_all" msgid="3626779872898778415">"Kuva kõik"</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_subid" msgid="204582608052503412">"Praegune alam-ID:"</string>
    <string name="radio_info_dds" msgid="5471937791273237508">"Andmete vaike-SIM-kaardi alam-ID:"</string>
    <string name="radio_info_dl_kbps" msgid="6894556071523815984">"DL ribalaius (kbit/s):"</string>
    <string name="radio_info_ul_kbps" msgid="946464073571185678">"UL ribalaius (kbit/s):"</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Kärje asukohateave (tugi on katkestatud):"</string>
    <string name="radio_info_phy_chan_config" msgid="7133247058801474028">"LTE füüsilise kanali konfiguratsioon:"</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_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="phone_index_label" msgid="1934407597576454430">"Telefoni registri valimine"</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="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="apply" msgid="1577045208487259229">"Rakenda"</string>
    <string name="share" msgid="6791534619806355910">"Jaga"</string>
    <string name="add" msgid="3709942705501136412">"Lisa"</string>
    <string name="settings_label" msgid="1626402585530130914">"Seaded"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Seaded"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Seadete otsetee"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Lennurežiim"</string>
    <string name="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="1262096900483238572">"Luba 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="2619521775007402005">"Rä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">"See võib põhjustada suuri andmesidetasusid."</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 andmesiderä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="4290527098376721491">"Kasuta võrgu pakutud kellaaega"</string>
    <string name="zone_auto_title" msgid="3217703906014135437">"Kasuta võrgu pakutud ajavööndit"</string>
    <string name="date_time_24hour_auto" msgid="6276269188890332084">"Kasuta lokaadi vaikeseadet"</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">"Kellaaeg"</string>
    <string name="time_format_category_title" msgid="736190761036057769">"Kellaaja vorming"</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_search_region" msgid="2478334699004021972">"Otsingupiirkond"</string>
    <string name="date_time_select_region" msgid="5434001881313168586">"Piirkond"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="6084375085203448645">"UTC-nihke valimine"</string>
    <string name="zone_change_to_from_dst" msgid="118656001224045590">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> algab kuupäeval <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="1359698475641349336">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="164876167707284017">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="4192803402331390389">"Kasutab ajavööndit <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> algab kuupäeval <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8652423870143056964">"Kasutab ajavööndit <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Suveaega pole."</string>
    <string name="zone_time_type_dst" msgid="8850494578766845276">"Suveaeg"</string>
    <string name="zone_time_type_standard" msgid="3462424485380376522">"Aeg"</string>
    <string name="zone_menu_by_region" msgid="8370437123807764346">"Vali piirkonna alusel"</string>
    <string name="zone_menu_by_offset" msgid="7161573994228041794">"Vali ajavöönd UTC suhtes"</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="3041497579354520533">"Lukustamine pärast ekraani ajalõppu"</string>
    <string name="lock_after_timeout_summary" msgid="6446294520193562658">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast ajalõppu"</string>
    <string name="lock_immediately_summary_with_exception" msgid="4887058374400817711">"Kohe pärast ajalõppu, välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> hoiab seadme avatuna"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5693037914721259546">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast ajalõppu, välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> hoiab seadme avatuna"</string>
    <string name="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="lockdown_settings_title" msgid="7393790212603280213">"Kuva lukustamise valik"</string>
    <string name="lockdown_settings_summary" msgid="4359438673563318171">"Kuvatakse toitenupu valik, mis lülitab funktsiooni Smart Lock, biomeetrilise avamise ja lukustuskuval kuvatavad märguanded välja"</string>
    <string name="trust_lost_locks_screen_title" msgid="2992742466966021682">"Lukusta ekraan usalduse kadumisel"</string>
    <string name="trust_lost_locks_screen_summary" msgid="693784434582021206">"Kui see on lubatud, lukustub seade, kui viimane usaldusväärne agent kaotab usalduse"</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 Martini 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="location_settings_master_switch_title" msgid="3560242980335542411">"Kasuta asukohta"</string>
    <string name="location_settings_summary_location_off" msgid="794370259612167176">"Väljas"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="5513447650619485188">
      <item quantity="other">Sees – <xliff:g id="COUNT_1">%1$d</xliff:g> rakendusel on asukohale juurdepääs</item>
      <item quantity="one">Sees – <xliff:g id="COUNT_0">%1$d</xliff:g> rakendusel on asukohale juurdepääs</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="8523775367089431611">"Laadimine …"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Kontod"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Turvalisus"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Krüpteerimine ja mandaadid"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Telefon on krüpteeritud"</string>
    <string name="decryption_settings_summary" product="default" msgid="5671817824042639849">"Telefon ei ole krüpteeritud"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Seade on krüpteeritud"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="5794135636155570977">"Seade ei ole krüpteeritud"</string>
    <string name="lockscreen_settings_title" msgid="1099738951060387656">"Lukustuskuva seaded"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="278055252361575926">"Mida näidata?"</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_face" msgid="268234254306703218">"Ekraanilukk, Face Unlock"</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_face_preference_summary" msgid="1290187225482642821">"Nägu on lisatud"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5596571291522936724">"Seadistage Face Unlock"</string>
    <string name="security_settings_face_preference_title" msgid="5277300443693527785">"Face Unlock"</string>
    <string name="security_settings_face_profile_preference_title" msgid="3906383224724942953">"Face unlock töö jaoks"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6027417312490791135">"Funktsiooni Face Unlock seadistamine"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="4233918594329755623">"Face Unlocki seadistamine"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="4697363240703556987">"Kasutage autentimiseks oma nägu"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4401918487764636333"></string>
    <string name="security_settings_face_enroll_education_start" msgid="6186306855277346454">"Alustamine"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="7784083491315229721">"Kasuta juurdepääset. seadistust"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="5924018301323255439"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="4455532390587307262"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7075186169796301461"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="4277182322482408514">"Tühista"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="2694505011712885439">"Avage oma näoga"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="8180330567034286589">"Kasutage autentimiseks oma nägu"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="6150611993438981458">"Kasutage oma nägu telefoni avamiseks, ostude volitamiseks või rakendustesse sisselogimiseks."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="6393270235632444857">"Kasutage telefoni avamiseks või ostude kinnitamiseks oma nägu.\n\nMärkus: te ei saa kasutada oma nägu selle seadme avamiseks. Lisateabe saamiseks võtke ühendust oma organisatsiooni administraatoriga."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="5704661081718707858">"Kasutage oma nägu telefoni avamiseks, ostude volitamiseks või rakendustesse sisselogimiseks"</string>
    <string name="security_settings_face_enroll_introduction_footer_part_0" msgid="3316520154949466889"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_1" msgid="5594630288374571903"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_2" msgid="7576241712527601978"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_3" msgid="7355240941877607603"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4019853239039918762">"Hoidke oma nägu ringi keskel"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5808832403353263368">"Jäta vahele"</string>
    <string name="face_add_max" msgid="4408683751143942949">"Lisada saab kuni <xliff:g id="COUNT">%d</xliff:g> nägu"</string>
    <string name="face_intro_error_max" msgid="160022811747660581">"Olete lisanud maksimaalse arvu nägusid"</string>
    <string name="face_intro_error_unknown" msgid="6367721696446677261">"Rohkem nägusid ei saa lisada"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2869110702072655323">"Registreerimist ei lõpetatud"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="2980238861223265089">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="1701191960569185087">"Näo registreerimisaeg lõppes. Proovige uuesti."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3825066262969499407">"Näo registreerimine ei toiminud."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="8268014305067971249">"Kõik on valmis. Kõik on korras."</string>
    <string name="security_settings_face_enroll_done" msgid="6670735678797960484">"Valmis"</string>
    <string name="security_settings_face_settings_use_face_category" msgid="4087133372842623883">"Kasuta Face Unlocki:"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="8780794239930621913">"Telefoni avamine"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="5751549943998662469">"Rakendusse sisselog. ja maksed"</string>
    <string name="security_settings_face_settings_require_category" msgid="2523822050054597822">"Funktsiooni Face Unlock nõuded"</string>
    <string name="security_settings_face_settings_require_attention" msgid="8523824066748480516">"Nõua avatud silmi"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="6595676992796133643">"Telefoni avamiseks peavad teie silmad avatud olema"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="2559602923985027572">"Nõua alati kinnitust"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="6466094680756211420">"Face Unlocki kasutamisel rakendustes nõutakse alati kinnitustoimingut"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="304401377141467791">"Kustuta näoandmed"</string>
    <string name="security_settings_face_settings_enroll" msgid="495403103503629382">"Funktsiooni Face Unlock seadistamine"</string>
    <string name="security_settings_face_settings_footer" msgid="1233594882557106034">"Kasutage Face Unlocki oma seadme avamiseks, rakendustesse sisselogimiseks ja maksete kinnitamiseks.\n\nTasub teada.\nTelefoni vaatamisel võib see soovimatult avaneda.\n\nKeegi teine võib teie telefoni avada, kui seda hoitakse teie näo ees. Seda isegi siis, kui teie silmad on suletud.\n\nTelefoni saab avada teiega sarnane inimene, nt teie identne vend/õde."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="4829278778459836075">"Kas soovite näoandmed kustutada?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="1959642447512807205">"Face Unlocki kasutatud kujutised ja biomeetrilised andmed kustutatakse jäädavalt ning turvaliselt. Pärast eemaldamist vajate telefoni avamiseks, rakendustesse sisselogimiseks ja maksete kinnitamiseks PIN-koodi, mustrit või parooli."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="4381276009777294566">"Kasutage oma telefoni avamiseks funktsiooni Face Unlock"</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="1550756694054944874">"Kasutage telefoni avamiseks või ostude kinnitamiseks oma sõrmejälge.\n\nMärkus: te ei saa kasutada oma sõrmejälge selle seadme avamiseks. Lisateabe saamiseks võtke ühendust oma organisatsiooni administraatoriga."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="6817326798834882531">"Kasutage telefoni avamiseks või ostude kinnitamiseks oma sõrmejälge.\n\nMärkus: teie sõrmejälg võib olla ebaturvalisem kui tugev 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="1961957425135180242">"Järgmine"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="362050541117362034">"Kas jätta sõrmejälg vahele?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="958990414356204763">"Sõrmejälje seadistamiseks kulub vaid paar minutit. Kui selle vahele jätate, saab sõrmejälje hiljem lisada menüüs Seaded."</string>
    <string name="lock_screen_intro_skip_title" msgid="4988210105913705679">"Kas jätta ekraanilukk vahele?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1581834104051243425">"Seadme kaitsefunktsioone ei lülitata sisse. Te ei saa tahvelarvuti kaotsimineku, varguse või lähtestamise puhul teistel selle kasutamist takistada."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4629503416877189572">"Seadme kaitsefunktsioone ei lülitata sisse. Te ei saa seadme kaotsimineku, varguse või lähtestamise puhul teistel selle kasutamist takistada."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2423428240245737909">"Seadme kaitsefunktsioone ei lülitata sisse. Te ei saa telefoni kaotsimineku, varguse või lähtestamise puhul teistel selle kasutamist takistada."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="5219287483885558525">"Seadme kaitsefunktsioone ei lülitata sisse. Te ei saa tahvelarvuti kaotsimineku või varguse puhul teistel selle kasutamist takistada."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="1466238255429527112">"Seadme kaitsefunktsioone ei lülitata sisse. Te ei saa seadme kaotsimineku või varguse puhul teistel selle kasutamist takistada."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3008526710555416125">"Seadme kaitsefunktsioone ei lülitata sisse. Te ei saa telefoni kaotsimineku või varguse puhul teistel selle kasutamist takistada."</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="skip_lock_screen_dialog_button_label" msgid="7478349557867790778">"Jäta vahele"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="4525833484240246349">"Tühista"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="3051496861358227199">"Puudutage andurit"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="8793966374365960368">"See asub telefoni tagaküljel. Kasutage oma nimetissõrme."</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="2068961812439460133">"Puudutage andurit"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Asetage oma sõrm andurile ja kui tunnete värinat, siis tõstke see üles"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="2819679722403209778">"Tõstke, seejärel puudutage uuesti"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="6158989350522518586">"Tõstke sõrme, et lisada sõrmejälje eri osad"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="7567276170287972230">"Sõrmejälg on lisatud"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8970048776120548976">"Kui näete seda ikooni, kasutage tuvastamiseks või ostude kinnitamiseks oma sõrmejälge"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3710211704052369752">"Teen seda hiljem"</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="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="7914950545902198894">"Kaitske oma tahvelarvutit ekraanilukuga, et keegi ei saaks seda kasutada, kui see kaotsi läheb või varastatakse. Ekraaniluku valikut on vaja ka sõrmejälje seadistamiseks. Puudutage käsku Tühista, seejärel määrake PIN-kood, muster või parool."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="2300047476104528001">"Kaitske oma seadet ekraanilukuga, et keegi ei saaks seda kasutada, kui see kaotsi läheb või varastatakse. Ekraaniluku valikut on vaja ka sõrmejälje seadistamiseks. Puudutage käsku Tühista, seejärel määrake PIN-kood, muster või parool."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="5823994499768751994">"Kaitske oma telefoni ekraanilukuga, et keegi ei saaks seda kasutada, kui see kaotsi läheb või varastatakse. Ekraaniluku valikut on vaja ka sõrmejälje seadistamiseks. Puudutage käsku Tühista, seejärel määrake PIN-kood, muster või parool."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="2053646029913482047">"Kaitstes oma tahvelarvuti ekraaniluku valikuga, ei saa keegi seda kasutada, kui see kaotsi läheb või varastatakse. Ekraaniluku valikut on vaja ka Face Unlocki seadistamiseks. Tagasiminemiseks puudutage valikut Tühista."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="8884769457436280503">"Kaitstes oma seadme ekraaniluku valikuga, ei saa keegi seda kasutada, kui see kaotsi läheb või varastatakse. Ekraaniluku valikut on vaja ka Face Unlocki seadistamiseks. Tagasiminemiseks puudutage valikut Tühista."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="1752907123591111728">"Kaitstes oma telefoni ekraaniluku valikuga, ei saa keegi seda kasutada, kui see kaotsi läheb või varastatakse. Ekraaniluku valikut on vaja ka Face Unlocki seadistamiseks. Tagasiminemiseks puudutage valikut Tühista."</string>
    <string name="lock_screen_pin_skip_title" msgid="8064328201816780457">"Kas jätta PIN-koodi määramine vahele?"</string>
    <string name="lock_screen_password_skip_title" msgid="4155009417576409182">"Kas jätta parooli määramine vahele?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="6467327818577283960">"Kas jätta mustri määramine vahele?"</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="2989019978041986175">"Puud. telefoni tagaküljel asuvat andurit. Kasut. oma nimetissõrme."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="3618021988442639280">"Registreerimist 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_delete_title" msgid="1368196182612202898">"Sõrmejälje „<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>” eemaldamine"</string>
    <string name="fingerprint_delete_message" msgid="8597787803567398131">"Kas soovite selle sõrmejälje kustutada?"</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="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="8498743819223200961">"Tagage oma telefoni turvalisus"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="2296800316150748710">"Määrake tahvelarvuti kaitsmiseks ekraanilukk"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="7562847814806365373">"Määrake seadme kaitsmiseks ekraanilukk"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="1526355348444658181">"Määrake telefoni kaitsmiseks ekraanilukk"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="2174553391551398081">"Avamiseks lisage sõrmejälg"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="5738274583658668124"></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="lock_settings_picker_biometrics_added_security_message" msgid="1507307757032207572">"Lisaturvalisuse huvides 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="lock_settings_picker_face_message" msgid="197106534637556054">"Valige oma ekraaniluku varumeetod"</string>
    <string name="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Ekraaniluku valikud"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="5058207955455973917">"Ekraaniluku valikud"</string>
    <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="face_unlock_set_unlock_pattern" msgid="4077659104229192018">"Face Unlock + muster"</string>
    <string name="face_unlock_set_unlock_pin" msgid="1359249613033276716">"Face Unlock + PIN-kood"</string>
    <string name="face_unlock_set_unlock_password" msgid="7135335310498158870">"Face Unlock + parool"</string>
    <string name="face_unlock_skip_face" msgid="3481956557015165094">"Jätka ilma Face Unlockita"</string>
    <string name="face_unlock_title" msgid="9042382084472444316">"Telefoni võite avada oma näoga. 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="2986105377420905314">"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 nendega oma telefoni avada, oste volitada ega 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="3370462835533123695">"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 nendega oma telefoni avada, oste volitada ega 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="3595476296430536798">"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 nendega oma telefoni avada, oste volitada ega 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="3679351662094349506">"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 nendega oma telefoni avada, oste volitada ega 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="6718155854303231675">"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="4209564603132870532">"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="2994300676764706047">"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="4994062501123299418">"Profiili kaitsefunktsioonid ei tööta ilma teie ekraanilukuta.<xliff:g id="EMPTY_LINE">

</xliff:g>Profiililt eemaldatakse ka teie salvestatud sõrmejäljed ja te ei saa nendega oma profiili avada, oste volitada ega rakendustesse sisse logida."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Jah, eemalda"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Avamismustri muutmine"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Muuda avamise PIN-koodi"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Avamisparooli muutmine"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="7529087063617325912">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab keerukat PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="4195620619469851350">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="428655972363263817">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut mustrit, PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="6275441987228550440">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut ekraanilukku"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="2219711062197089783">"Proovige uuesti. Katse <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>/<xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="4277765862798876826">"Teie andmed kustutatakse"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="1688030823464420974">"Kui sisestate järgmisel katsel vale mustri, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="5350785938296254352">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="6208035114731421034">"Kui sisestate järgmisel katsel vale parooli, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="7851504071368235547">"Kui sisestate järgmisel katsel vale mustri, kustutatakse see kasutaja"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="4049024921333961715">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse see kasutaja"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="4660886542496781672">"Kui sisestate järgmisel katsel vale parooli, kustutatakse see kasutaja"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2437716252059050291">"Kui sisestate järgmisel katsel vale mustri, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="5799931839127476913">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="6786586046975042158">"Kui sisestate järgmisel katsel vale parooli, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="5047439819181833824">"Liiga palju valesid katseid. Selle seadme andmed kustutatakse."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="6188180643494518001">"Liiga palju valesid katseid. See kasutaja kustutatakse."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="1745475043685915442">"Liiga palju valesid katseid. See tööprofiil ja selle andmed kustutatakse."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="8246716090548717312">"Loobu"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="1957883871187697796">
      <item quantity="other">Peab sisaldama vähemalt <xliff:g id="COUNT_1">%d</xliff:g> tähemärki</item>
      <item quantity="one">Peab sisaldama vähemalt <xliff:g id="COUNT_0">%d</xliff:g> tähemärki</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="5019935246875659237">
      <item quantity="other">PIN-kood peab sisaldama vähemalt <xliff:g id="COUNT_1">%d</xliff:g> numbrit</item>
      <item quantity="one">PIN-kood peab sisaldama vähemalt <xliff:g id="COUNT_0">%d</xliff:g> numbrit</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Jätka"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="4581209996591221075">
      <item quantity="other">Peab olema alla <xliff:g id="NUMBER_1">%d</xliff:g> tähemärgi</item>
      <item quantity="one">Peab olema alla <xliff:g id="NUMBER_0">%d</xliff:g> tähemärgi</item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="185568652740755131">
      <item quantity="other">Peab olema alla <xliff:g id="NUMBER_1">%d</xliff:g> numbri</item>
      <item quantity="one">Peab olema alla <xliff:g id="NUMBER_0">%d</xliff:g> numbri</item>
    </plurals>
    <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_pin_blacklisted_by_admin" msgid="8563366383328811472">"IT-administraator on levinud PIN-koodid blokeerinud. Proovige muud 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_password_blacklisted_by_admin" msgid="9105101266246197027">"IT-administraator on levinud paroolid blokeerinud. Proovige muud parooli."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"Kasvavad, kahanevad või korduvad numbrijadad on keelatud"</string>
    <string name="lockpassword_confirm_label" msgid="8176726201389902380">"Kinnita"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Tühista"</string>
    <string name="lockpassword_clear_label" msgid="5724429464960458155">"Kustuta"</string>
    <string name="lockpassword_credential_changed" msgid="581649578639853343">"Ekraanilukk on juba muudetud. Proovige uue ekraanilukuga veel kord."</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 admin. 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="9082518313285787097">"Luba juurdepääs 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_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_found_media_devices" msgid="1617401232446299411">"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="bluetooth_scanning_on_info_message" msgid="824285504325592644">"Kui Bluetooth on sisse lülitatud, saab teie seade suhelda teiste läheduses olevate Bluetoothi seadmetega.\n\nSeadme kasutuskogemuse täiustamiseks saavad rakendused ja teenused endiselt igal ajal otsida läheduses olevaid seadmeid isegi siis, kui Bluetooth on välja lülitatud. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Seda saab muuta "<annotation id="link">"otsimise seadetes"</annotation>"."</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_failed" msgid="4500234659813241053">"Ühendust ei õnnestunud luua. Proovige uuesti."</string>
    <string name="device_details_title" msgid="6576953269221085300">"Seadme üksikasjad"</string>
    <string name="bluetooth_device_mac_address" msgid="2513724313558236181">"Seadme Bluetoothi aadress: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="38467834196432400">"Kas unustada seade?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="9087609557757135712">"Teie telefon ei ole enam seotud seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="7785695793007576501">"Teie tahvelarvuti ei ole enam seotud seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="251257782642157557">"Teie seade ei ole enam seotud seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_untethered_unpair_dialog_body" msgid="5932168717642676140">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ei ole enam seotud ühegi selle kontoga lingitud seadmega"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="3829370108973879006">"Unusta seade"</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="8355910926439312604">"Tahvelarvuti Interneti-ühenduse jagamine seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> katkestatakse."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="6251611115860359886">"Telefoni Interneti-ühenduse jagamine seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> 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="6436258151814414028">"Interneti kasutamiseks seadmega ühend."</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1322694224800769308">"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="bluetooth_max_connected_audio_devices_string" msgid="6752690395207847881">"Maksimaalne arv ühendatud Bluetoothi heliseadmeid"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="5936561749790095473">"Maksimaalse arvu ühendatud Bluetoothi heliseadmete valimine"</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="wifi_sign_in_button_text" msgid="8404345621836792112">"Logi sisse"</string>
    <string name="wifi_tap_to_sign_in" msgid="6990161842394669054">"Puudutage siin, et võrku sisse logida"</string>
    <string name="tx_link_speed" msgid="6139577455916971837">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="rx_link_speed" msgid="5729003360923133988">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbit/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="art_verifier_for_debuggable_title" msgid="6029838014407791341">"Silutavate rakenduste baidikoodi kinnitamine"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="2250352478065428399">"Luba ART silutavate rakenduste baidikoodi kinnitamiseks"</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="nfc_secure_settings_title" msgid="150400737244061585">"NFC turve"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="2135032222065627938">"NFC kasutuse lubamine makseteks ja ühistranspordiks vaid siis, kui ekraan on avatud"</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="nfc_disabled_summary" msgid="3507017304297395467">"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_master_switch_title" msgid="4746267967669683259">"WiFi kasutus"</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_no_location" msgid="7494539594649967699">"Pole saadaval, sest asukoha otsimine on välja lülitatud. Lülitage valik "<annotation id="link">"Asukoht"</annotation>" sisse."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="7247227922074840445">"Pole saadaval, kuna WiFi-skannimine on välja lülitatud"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="108339002136866897">"Funktsiooni kasutamiseks valige võrgukvaliteedi hinnangute pakkuja"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Väldi halbu ühendusi"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7016103106105907127">"Ära kasuta WiFi-võrku, kui selle Interneti-ühendus on halb"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="1644292503152790501">"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="use_open_wifi_automatically_summary_scoring_disabled" msgid="593964217679325831">"Funktsiooni kasutamiseks valige võrgukvaliteedi hinnangute pakkuja"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="8472122600853650258">"Funktsiooni kasutamiseks valige sobiv võrgukvaliteedi hinnangute pakkuja"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Sertifikaatide installimine"</string>
    <string name="wifi_scan_notify_text" msgid="5544778734762998889">"Asukoha täpsuse parandamiseks võivad rakendused ja teenused siiski alati otsida WiFi-võrke isegi siis, kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Seda saab muuta <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>otsimise seadetes<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> WiFi-skannimine sisse."</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="8593144541347373394">"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="1403505355490119307">"Kui WiFi-l puudub Internetile juurdepääs, kasutatakse mobiilset andmesidet. Rakenduda võivad andmekasutustasud."</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_more_options" msgid="2448097861752719396">"Rohkem valikuid"</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_empty_list_wifi_off" msgid="8056223875951079463">"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_settings_scanning_required_title" msgid="3815269816331500375">"Kas lülitada WiFi-skannimine sisse?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="6352918945128328916">"WiFi automaatseks sisselülitamiseks peate esmalt lülitama WiFi-skannimise sisse."</string>
    <string name="wifi_settings_scanning_required_info" msgid="3155631874578023647">"WiFi-skannimine lubab rakendustel ja teenustel alati otsida WiFi-võrke, isegi kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1364287182804820646">"Lülita sisse"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="5527653791584018157">"WiFi-skannimine on lülitatud sisse"</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_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_hidden_network" msgid="973162091800925000">"Peidetud võrk"</string>
    <string name="wifi_hidden_network_warning" msgid="6674068093531603452">"Kui teie ruuter ei edasta võrgu-ID-d, kuid soovite võrguga tulevikus ühenduse luua, võite võrgu peita.\n\nSee võib tekitada turvariski, kuna teie telefon edastab võrgu leidmiseks pidevalt signaali.\n\nVõrgu peitmisel ruuteri seadeid ei muudeta."</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Signaali tugevus"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Olek"</string>
    <string name="tx_wifi_speed" msgid="2994278184097786511">"Edastuslingi kiirus"</string>
    <string name="rx_wifi_speed" msgid="7206089638282839236">"Vastuvõtmislingi 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_sae_password_id" msgid="1697832722221765763">"SAE parooli identifikaator"</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_auto" msgid="2677800651271769965">"Automaatne"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"2,4 GHz riba"</string>
    <string name="wifi_ap_choose_5G" msgid="8813128641914385634">"5,0 GHz riba"</string>
    <string name="wifi_ap_prefer_5G" msgid="2501070491623803139">"Eelistatud on 5,0 GHz riba"</string>
    <string name="wifi_ap_2G" msgid="8378132945192979364">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="4020713496716329468">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="3476254666116431650">"Valige WiFi-kuumkoha lubamiseks vähemalt üks sagedusriba:"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"IP-seaded"</string>
    <string name="wifi_privacy_settings" msgid="5500777170960315928">"Privaatsus"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="1539659414108891004">"Juhuslik MAC-aadress"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="8674936581557695411">"Seadme lisamine"</string>
    <string name="wifi_dpp_center_qr_code" msgid="6244508369721032655">"Seadme võrku „<xliff:g id="SSID">%1$s</xliff:g>” lisamiseks paigutage allolev QR-kood aknas keskele"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="4794621158747044107">"QR-koodi skannimine"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="4371771604088014396">"Võrguga „<xliff:g id="SSID">%1$s</xliff:g>” ühenduse loomiseks paigutage allolev QR-kood aknas keskele"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="8096370383700478819">"Liituge WiFi-võrguga, skannides QR-koodi"</string>
    <string name="wifi_dpp_share_wifi" msgid="9065890131734833809">"WiFi jagamine"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="5854392840857123065">"Skannige see QR-kood, et luua ühendus võrguga „<xliff:g id="SSID">%1$s</xliff:g>” ja jagada parooli"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="4436318319178361543">"Võrguga „<xliff:g id="SSID">%1$s</xliff:g>” ühenduse loomiseks skannige see QR-kood"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="3372757783382381044">"Proovige uuesti. Kui see probleem jätkub, võtke ühendust seadme tootjaga"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="2829930473520603740">"Midagi läks valesti"</string>
    <string name="wifi_dpp_failure_timeout" msgid="5228320772245820458">"Veenduge, et seade oleks ühendatud, laetud ja sisse lülitatud"</string>
    <string name="wifi_dpp_failure_generic" msgid="8030831192606098356">"Veenduge, et seade oleks ühendatud, laetud ja sisse lülitatud. Kui see probleem jätkub, võtke ühendust seadme tootjaga"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2643768115109632725">"See seade ei toeta SSID „<xliff:g id="SSID">%1$s</xliff:g>” lisamist"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="2632966336733361805">"Kontrollige ühendust ja proovige uuesti"</string>
    <string name="wifi_dpp_choose_network" msgid="7139308800110200281">"Võrgu valimine"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4025269026652486605">"Oma seadme ühendamiseks valige võrk"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5459084866460319042">"Kas lisada see seade võrku „<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="7669684043486750097">"WiFi-t jagatakse seadmega"</string>
    <string name="wifi_dpp_add_another_device" msgid="8415243205104666929">"Lisa teine seade"</string>
    <string name="wifi_dpp_choose_different_network" msgid="4081965219206680361">"Valige mõni teine võrk"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="1598945041477461501">"Seadet ei õnnestunud lisada"</string>
    <string name="wifi_dpp_device_found" msgid="8618134150169810107">"Leiti seade"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="5579154298588011712">"WiFi-võrgu jagamine selle seadmega …"</string>
    <string name="wifi_dpp_connecting" msgid="7111851118215580428">"Ühendamine …"</string>
    <string name="wifi_dpp_share_hotspot" msgid="762408459341741405">"Kuumkoha jagamine"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="8401802203867904622">"Kinnitage oma isik"</string>
    <string name="wifi_dpp_wifi_password" msgid="4938294574591503213">"WiFi-võrgu parool: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="4120419278831581613">"Kuumkoha parool: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_add_device" msgid="4072206063308645677">"Lisa seade"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="3887335309163999665">"Kasutage sellesse võrku seadme lisamiseks QR-koodi"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="3700087439867692944">"QR-kood ei ole sobilik vorming"</string>
    <string name="retry" msgid="6472609612090877557">"Proovi uuesti"</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_ssid_too_long" msgid="3474753269579895244">"Võrgu nimi on liiga pikk."</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_carrier_connect" msgid="8174696557882299911">"Operaatori WiFi-võrk"</string>
    <string name="wifi_carrier_content" msgid="4634077285415851933">"Ühendage operaatori <xliff:g id="NAME">%1$s</xliff:g> kaudu"</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_turn_on_message_unknown" msgid="6162424298483845679">"Täpsema asukoha ja muude toimingute jaoks tahab tundmatu rakendus võrkude skannimise sisse lülitada, isegi kui WiFi on välja lülitatud.\n\nKas lubada see kõigi rakenduste jaoks, mis skannida tahavad?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Väljalülitamiseks avage ületäitemenüüs valik Täpsemad."</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="5926979351959279577">"Sellel võrgul puudub juurdepääs Internetile. Kas soovite ühenduse säilitada?"</string>
    <string name="partial_connectivity_text" msgid="1287030663891772340">"Mõned rakendused ja teenused ei pruugi piiratud ühenduse tõttu töötada. Kas soovite siiski kasutada?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"Ära selle võrgu puhul uuesti küsi"</string>
    <string name="lost_internet_access_title" msgid="5779478650636392426">"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_turned_on_message" msgid="4432839393213448846">"WiFi on sisse lülitatud"</string>
    <!-- no translation found for wifi_connected_to_message (2265022072754345638) -->
    <skip />
    <string name="wifi_connecting" msgid="8760426806460651215">"Ühendamine …"</string>
    <!-- no translation found for wifi_disconnect (3445234285136039895) -->
    <skip />
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Võrguga ühenduse loomine ebaõnnestus"</string>
    <string name="wifi_not_in_range_message" msgid="6616864204007424228">"Te ei ole võrgu levialas"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Unusta"</string>
    <string name="wifi_modify" msgid="6100248070440710782">"Muuda"</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_forget_dialog_title" msgid="6224151903586192426">"Kas unustada võrk?"</string>
    <string name="wifi_forget_dialog_message" msgid="2337060138532166680">"Kõik selle võrgu paroolid kustutatakse"</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>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="8256430439661111672">
      <item quantity="other">%d tellimust</item>
      <item quantity="one">Üks tellimus</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="2504425359919617586">
      <item quantity="other">%d võrku ja tellimust</item>
      <item quantity="one">1 võrk ja tellimus</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Täpsemad WiFi-seaded"</string>
    <string name="wifi_advanced_ssid_title" msgid="1552309166043760291">"SSID"</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_title" msgid="8954667664081737098">"Võrgu üksikasjad"</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_subscribed_access_points_tab" msgid="6480224551765489055">"Tellimused"</string>
    <!-- no translation found for wifi_saved_access_points_tab (2659675386657663705) -->
    <skip />
    <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_hotspot_checkbox_text" msgid="7763495093333664887">"WiFi-kuumkoht"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2199911382555864644">"Interneti-ühendust ega sisu ei jagata teiste seadmetega"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5936710887156133458">"Tahvelarvuti Interneti-ühendust jagatakse kuumkoha kaudu"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5556202634866621632">"Telefoni Interneti-ühendust jagatakse kuumkoha kaudu"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="5017191966153008">"Rakendus jagab sisu. Interneti-ühenduse jagamiseks lülitage kuumkoht välja ja seejärel uuesti sisse."</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="353306131026431089">"Parool on määramata"</string>
    <string name="wifi_hotspot_name_title" msgid="8237000746618636778">"Kuumkoha nimi"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="3378299995508671967">"Võrgu <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g> sisselülitamine …"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="3888672084861445362">"Teised seadmed saavad luua ühenduse võrguga <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="8676859981917573801">"Kuumkoha parool"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="1165801173359290681">"Pääsupunkti sagedusriba"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="4789553667374849566">"Teiste seadmete jaoks WiFi-võrgu loomiseks kasutage kuumkohta. Kuumkoht kasutab Interneti pakkumiseks mobiilset andmesideühendust. Rakenduda võivad mobiilse andmeside tasud."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="857988412470694109">"Rakendused saavad luua kuumkoha, et jagada läheduses olevate seadmetega sisu."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="1590313508558948079">"Lülita kuumkoht automaatselt välja"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="5858098059725925084">"Kui ükski seade pole ühendatud, lülitatakse WiFi-kuumkoht välja"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Kuumkoha sisselülitamine ..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Kuumkoha 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">"Mobiilse WiFi-kuumkoha 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-kuumkoha seadistamine"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"AndroidAP WPA2 PSK-kuumkoht"</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="5702964371483390024">"Suurendage WiFi abil helistamisulatust"</string>
    <string name="wifi_calling_suggestion_summary" msgid="1331793267608673739">"Lülitage WiFi-kõned sisse, et ulatust suurendada"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Kõne-eelistus"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="7105195222267749226">"Kõne-eelistus"</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_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_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"WiFi"</item>
    <item msgid="1118703915148755405">"Mobiilne andmeside"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="9092988115148569860">"Kasuta mobiilsidevõrku, kui WiFi ei ole saadaval"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="240885549023046403">"Kasuta WiFi-ühendust, kui mobiilsidevõrk ei ole saadaval"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3688265826855460036">"Helistage WiFi-võrgu kaudu. WiFi-ühenduse katkemisel kõne lõpeb."</string>
    <string name="wifi_calling_off_explanation" msgid="564780186974911501">"Kui WiFi-kõned on sisse lülitatud, saab telefon olenevalt eelistustest ja signaalitugevusest kõnesid marsruutida WiFi-võrkude või teie operaatori võrgu kaudu. Enne selle funktsiooni sisselülitamist uurige operaatorilt tasude ja muude üksikasjade kohta. <xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="932729250447887545">"Hädaolukorra aadress"</string>
    <string name="emergency_address_summary" msgid="7751971156196115129">"Seda kasutatakse WiFi kaudu hädaabikõne tegemisel teie asukohana"</string>
    <string name="private_dns_help_message" msgid="3299567069152568958"><annotation id="url">"Lisateave"</annotation>" privaatse DNS-i funktsioonide kohta"</string>
    <string name="private_dns_mode_on" msgid="5882613439541371003">"Sees"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="6845711858866828986">"Seadet haldab operaator"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="7492509632478260955">"Aktiveerige WiFi-kõned"</string>
    <string name="wifi_calling_turn_on" msgid="1171403510313983983">"Lülitage WiFi-kõned sisse"</string>
    <string name="wifi_calling_not_supported" msgid="7878640438907807754">"Operaator %1$s ei toeta WiFi-kõnesid"</string>
    <string name="carrier" msgid="5264014738689761132">"Operaator"</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="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">"Äratused"</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="display_settings" msgid="7965901687241669598">"Ekraan"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Pööra ekraani automaatselt"</string>
    <string name="color_mode_title" msgid="9186249332902370471">"Värvid"</string>
    <string name="color_mode_option_natural" msgid="5013837483986772758">"Loomulikud"</string>
    <string name="color_mode_option_boosted" msgid="8588223970257287524">"Võimendatud"</string>
    <string name="color_mode_option_saturated" msgid="4569683960058798843">"Küllastatud"</string>
    <string name="color_mode_option_automatic" msgid="7996505473528529568">"Kohanduv"</string>
    <string name="color_mode_summary_natural" msgid="6624188642920403099">"Kasuta ainult täpseid värve"</string>
    <string name="color_mode_summary_automatic" msgid="4669516973360709431">"Eredate ja täpsete värvide vahel kohandamine"</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">"Ereduse 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 eredus"</string>
    <string name="auto_brightness_summary" msgid="5652108419977937800">"Ekraanikuva eredus kohandub vastavalt keskkonnale"</string>
    <string name="auto_brightness_summary_on" msgid="3519854265558828744">"Sees"</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="auto_brightness_description" msgid="7310335517128283729">"Teie ekraanikuva eredust kohandatakse automaatselt teie keskkonna ja tegevuste järgi. Võite liugurit käsitsi liigutada, et aidata kohanduval eredusel teie eelistusi õppida."</string>
    <string name="display_white_balance_title" msgid="4093966473741329340">"Ekraani valge tasakaal"</string>
    <string name="display_white_balance_summary" msgid="2432539678792029039"></string>
    <string name="adaptive_sleep_title" msgid="455088457232472047">"Ekraanivaatamise tuvastus"</string>
    <string name="adaptive_sleep_summary_on" msgid="410222811715459549">"Sees / ekraan jääb sisselülitatuks, kui seda vaatate"</string>
    <string name="adaptive_sleep_summary_off" msgid="3099674463517017514">"Väljas"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="7893003608238361004">"Vajalik on kaamera juurdepääs"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="2875851728693203108">"Puudutage, et hallata seadme isikupärastamise teenuste lube"</string>
    <string name="adaptive_sleep_description" msgid="3741651460279997459">"Takistab ekraani väljalülitamist, kui seda vaatate"</string>
    <string name="adaptive_sleep_privacy" msgid="5335695648960686765">"Ekraanivaatamise tuvastuse funktsioon kontrollib esikaamera abil, kas keegi vaatab ekraani. See töötab ainult seadmes ja pilte ei salvestata kunagi ega saadeta Google\'ile."</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="6922838078388927214">"Ekraan jääb vaatamise ajal sisselülitatuks"</string>
    <string name="night_display_title" msgid="2626451512200357686">"Öövalgus"</string>
    <string name="night_display_text" msgid="1837277457033025056">"Funktsioon Öövalgus toonib ekraani oranžkollaseks. Nii on hämaras ekraani mugavam vaadata ja sellelt teksti lugeda. See võib aidata teil ka hõlpsamini magama jääda."</string>
    <string name="night_display_auto_mode_title" msgid="6574111412154833409">"Ajastamine"</string>
    <string name="night_display_auto_mode_never" msgid="2483761922928753400">"Mitte kunagi"</string>
    <string name="night_display_auto_mode_custom" msgid="2379394568898721765">"Lülitub sisse kohandatud ajal"</string>
    <string name="night_display_auto_mode_twilight" msgid="589042813708244059">"Lülitub sisse loojangust tõ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_status_title" msgid="1784041143360286267">"Olek"</string>
    <string name="night_display_temperature_title" msgid="1435292789272017136">"Intensiivsus"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Väljas / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="3583590137322963513">"Ei lülitu kunagi automaatselt sisse"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6365668239253173208">"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="3596291693781757392">"Lülitub automaatselt sisse päikeseloojangul"</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Sees / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="9117830821363119835">"Ei lülitu kunagi automaatselt välja"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="5510753572245577263">"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="852270120144683507">"Lülitub automaatselt välja päikesetõusul"</string>
    <string name="night_display_activation_on_manual" msgid="277343561277625826">"Lülita kohe sisse"</string>
    <string name="night_display_activation_off_manual" msgid="4074557720918572883">"Lülita kohe välja"</string>
    <string name="night_display_activation_on_twilight" msgid="6976051971534953845">"Lülita sisse päikesetõusuni"</string>
    <string name="night_display_activation_off_twilight" msgid="7196227685059907233">"Lülita välja päikeseloojanguni"</string>
    <string name="night_display_activation_on_custom" msgid="5472029024427933598">"Lülita sisse kuni <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="6169984658293744715">"Lülita välja kuni <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6273540991113206401">"Öövalgus pole praegu sees"</string>
    <string name="screen_timeout" msgid="4882669461447531301">"Ekraani ajalõpp"</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="style_and_wallpaper_settings_title" msgid="3608097576881470764">"Stiilid ja taustapildid"</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="style_suggestion_title" msgid="4710867417147087928">"Pixeli kohandamine"</string>
    <string name="style_suggestion_summary" msgid="1811974280164432649">"Proovige eri stiile, taustapilte ja muud"</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="ambient_display_screen_title" msgid="4252755516328775766">"Säästlik ekraan"</string>
    <string name="ambient_display_category_triggers" msgid="4359289754456268573">"Millal kuvada?"</string>
    <string name="doze_title" msgid="2375510714460456687">"Uued märguanded"</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="6978257596231155345">"Kuva kellaaeg, märguandeikoonid ja muu teave. Suurem akukasutus."</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_pin_disable_failed" msgid="7932981135799678220">"PIN-koodi ei saa keelata."</string>
    <string name="sim_pin_enable_failed" msgid="3414621075632931753">"PIN-koodi ei saa lubada."</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="5045967581557404143">"Kas kasutada <xliff:g id="CARRIER">%1$s</xliff:g> andmesidet?"</string>
    <string name="sim_change_data_message" msgid="4307243848083368600">"Kasutate operaatori <xliff:g id="CARRIER2_0">%2$s</xliff:g> mobiilset andmesidet. Kui aktiveerite operaatori <xliff:g id="CARRIER1">%1$s</xliff:g>, ei kasutata enam operaatori <xliff:g id="CARRIER2_1">%2$s</xliff:g> mobiilset andmesidet."</string>
    <string name="sim_change_data_ok" msgid="7929746101841679535">"Kasuta operaatorit <xliff:g id="CARRIER">%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="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="model_summary" msgid="8306235877567782987">"Mudel: %1$s"</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="module_version" msgid="7329118610303805859">"Google Play süsteemivärskendus"</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_settings_for_app" msgid="1922207623125501014">"Salvestusruum ja vahemälu"</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="imei_multi_sim" msgid="6387012961838800539">"IMEI (SIM-kaardi pesa %1$d)"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5948892105546651296">"Telefoninumber"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="2755592991367858860">"MDN (SIM-kaardi pesa %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="1898212200138025729">"Telefonin. (SIM-i pesa %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="1367110147304523864">"MDN SIM-kaardil"</string>
    <string name="status_number_sim_status" product="default" msgid="9123351360569466330">"Telefoninumber SIM-kaardil"</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="meid_multi_sim" msgid="748999971744491771">"MEID (SIM-kaadri pesa %1$d)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="5262263689045962681">"Nii WiFi kui ka Bluetoothi skannimine on sisse lülitatud"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="2115399719199757550">"WiFi-skannimine on sees, Bluetoothi skannimine on väljas"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="3212656150021004088">"Bluetoothi skannimine on sees, WiFi-skannimine on väljas"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="6381094990708345188">"Nii WiFi kui ka Bluetoothi skannimine on välja lülitatud"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_data_network_type" msgid="7570837037428932780">"Mobiilse andmesidevõrgu tüüp"</string>
    <string name="status_voice_network_type" msgid="5663112239742353547">"Mobiilse häälvõ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_esim_id" msgid="6456255368300906317">"EID"</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_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="8845766044697204852">"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 vaatamiseks 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="3983764797223576658">"Ä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="6553867088682695655">"Seade <xliff:g id="NAME">^1</xliff:g> on kasutamiseks 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_unlock" msgid="1526216561023200694">"Andmete teisaldamiseks peate avama kasutaja <xliff:g id="APP">^1</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="storage_wizard_init_v2_title" msgid="8858395869710288372">"Kuidas seadet <xliff:g id="NAME">^1</xliff:g> kasutate?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="4315585580670552654">"Kasuta tahvelar. lisasalvestusr."</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="570443086512059390">"Ainult selles tahvelarv. olevate raken., failide ja meedia jaoks"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="7760758592993284143">"Tahvelarvuti salvestusruum"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="8373070138732653456">"Kasuta telefoni lisasalvestusr."</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="685194340141573218">"Ainult selles telef. olevate rakenduste, failide ja meedia jaoks"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="904425171564310150">"Telefoni salvestusruum"</string>
    <string name="storage_wizard_init_v2_or" msgid="1958295749349454436">"Või"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="3565348221712759463">"Kasuta kaasask. salv.ruumi jaoks"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="801198071793584445">"Failide ja meedia edastamiseks seadmete vahel"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="8662451480642784031">"Kaasaskantav salvestusruum"</string>
    <string name="storage_wizard_init_v2_later" msgid="1080613420170749130">"Seadista hiljem"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="5744790239994621663">"Kas vormindada seade <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="4614199613500900975">"Seade <xliff:g id="NAME_0">^1</xliff:g> tuleb vormindada, et rakendusi, faile ja meediat salvestada. \n\nVormindamisel kustutatakse kogu seadmes <xliff:g id="NAME_1">^2</xliff:g> olev sisu. Sisu kaotsimineku vältimiseks varundage see teise salvestusseadmesse <xliff:g id="NAME_2">^3</xliff:g> või mõnda muusse seadmesse."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="8258363472135537500">"Vorminda seade <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="31406330052996898">"Kas teisaldada sisu seadmesse <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4476553430145054781">"Failid, meedia ja teatud rakendused saab teisaldada seadmesse <xliff:g id="NAME">^1</xliff:g>. \n\nSellega vabastatakse <xliff:g id="SIZE">^2</xliff:g> teie tahvelarvuti salvestusruumist ja see võib võtta umbes <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="744760728669284385">"Failid, meedia ja teatud rakendused saab teisaldada seadmesse <xliff:g id="NAME">^1</xliff:g>. \n\nSellega vabastatakse <xliff:g id="SIZE">^2</xliff:g> teie telefoni salvestusruumist ja see võib võtta umbes <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="1239103359606165360">"Teisaldamise ajal pidage silmas järgmist."</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="7176991995007075843">"Ärge eemaldage seadet <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="3671266712947078734">"Mõni rakendus ei pruugi töötada"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="346012901366624052">"Hoidke tahvelarvuti laetuna"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="3061158350109289521">"Hoidke telefon laetuna"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="1279041707982039591">"Teisalda sisu"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="8201360307047198853">"Teisalda sisu hiljem"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="1323344099111423785">"Sisu teisaldamine …"</string>
    <string name="storage_wizard_slow_v2_title" msgid="1318285829973607727">"Aeglane seade <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="6897444467730463117">"Võite seadet <xliff:g id="NAME_0">^1</xliff:g> siiski kasutada, kuid see võib olla aeglane. \n\nSeadmesse <xliff:g id="NAME_1">^2</xliff:g> salvestatud rakendused ei pruugi õigesti töötada ja sisu teisaldamine võib kaua aega võtta. \n\nKasutage kiiremat seadet <xliff:g id="NAME_2">^3</xliff:g> või selle asemel seda seadet <xliff:g id="NAME_3">^4</xliff:g> kaasaskantava salvestusruumina."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="4126873669723115805">"Alusta uuesti"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="49399942893518218">"Jätka"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="11937346870534608">"Sisu saab teisaldada seadmesse <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="4658433206901211269">"Sisu teisaldamiseks seadmesse <xliff:g id="NAME">^1</xliff:g> tehke valikud "<b>"Seaded &gt; Salvestusruum"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="6239886818487538806">"Sisu teisaldati seadmesse <xliff:g id="NAME_0">^1</xliff:g>. \n\nSeadme <xliff:g id="NAME_1">^2</xliff:g> haldamiseks tehke valikud "<b>"Seaded &gt; Salvestusruum"</b>"."</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ääsupunktid"</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ääsupunkt"</string>
    <string name="menu_save" msgid="8109345640668285399">"Salvesta"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Loobu"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Nimeväli ei tohi tühi olla."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"APN ei saa olla tühi."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"MCC-väli peab olema kolmekohaline."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"MNC-väli peab olema kahe- või kolmekohaline."</string>
    <string name="error_adding_apn_type" msgid="4181334016628549645">"Operaator ei luba tüübiga %s APN-ide lisamist."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"APN-i vaikeseadete taastamine."</string>
    <string name="menu_restore" msgid="8260067415075573273">"Lähtesta vaikeseadetele"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"APN-i vaikeseadete lähtestamine on lõpule viidud."</string>
    <string name="reset_dashboard_title" msgid="6254873816990678620">"Lähtestamise valikud"</string>
    <string name="reset_dashboard_summary" msgid="4851012632493522755">"Võrgu, rakendused või seadme saab lähtestada"</string>
    <string name="reset_network_title" msgid="6166025966016873843">"Lähtesta WiFi, mobiilne andmeside ja Bluetooth"</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_esim_title" msgid="1979762943163078939">"Kustuta allalaaditud SIM-id"</string>
    <string name="reset_esim_desc" msgid="5940105242448544634">"Asendus-SIM-kaartide allalaadimiseks võtke ühendust operaatoriga. See ei tühista mobiilsideteenuse pakette."</string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Lähtesta seaded"</string>
    <string name="reset_network_final_desc" msgid="4690205209934596665">"Kas soovite kõik võrguseaded lähtestada? Seda toimingut ei saa tagasi võtta."</string>
    <string name="reset_network_final_desc_esim" msgid="6641433458865914227">"Kas soovite kõik võrguseaded lähtestada ja allalaaditud SIM-id kustutada? 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="reset_esim_error_title" msgid="2679159494023044398">"SIM-kaarte ei saa kustutada"</string>
    <string name="reset_esim_error_msg" msgid="1356899750645220749">"Allalaaditud SIM-kaarte ei saa vea tõttu kustutada.\n\nTaaskäivitage seade ja proovige uuesti."</string>
    <string name="master_clear_title" msgid="3531267871084279512">"Kõigi andmete kustutamine (tehaseseadetele lähtestamine)"</string>
    <string name="master_clear_short_title" msgid="8652450915870274285">"Kust. andmed (tehases. läht.)"</string>
    <string name="master_clear_desc" product="tablet" msgid="2314458161059569301">"See kustutab teie tahvelarvuti "<b>"sisemälust"</b>" kõik andmed, 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="7647628092266675099">"See kustutab teie telefoni "<b>"sisemälust"</b>" kõik andmed, sh järgmised.\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_also_erases_esim" msgid="6008213558725767177"><li>"eSIM-id"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="5460926449093211144">\n\n"See ei tühista teie mobiilsideteenuse paketti."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Muusika, piltide ja muu kasutajateabe kustutamiseks tuleb tühjendada ka "<b>"USB-mäluseade"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Muusika, piltide ja muude kasutajaandmete kustutamiseks tuleb tühjendada ka "<b>"SD-kaart"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Kustuta USB-mäluseade"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Kustuta SD-kaart"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Sisemiselt USB-mäluseadmelt kõikide andmete (nt muusika või fotode) kustutamine"</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"SD-kaardilt kõigi andmete (nt muusika või fotode) kustutamine"</string>
    <string name="master_clear_button_text" product="tablet" msgid="1893179883931194922">"Kustuta kõik andmed"</string>
    <string name="master_clear_button_text" product="default" msgid="1893179883931194922">"Kustuta kõik andmed"</string>
    <string name="master_clear_final_desc" msgid="8219087639717327355">"Kõik teie isiklikud andmed ja allalaaditud rakendused kustutatakse. Seda toimingut ei saa tagasi võtta."</string>
    <string name="master_clear_final_desc_esim" msgid="4580223096319568030">"Kõik teie isiklikud andmed, sealhulgas allalaaditud rakendused ja SIM-id kustutatakse. 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="1134724452049918413">"Kas kustutada kõik andmed?"</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">"Mobiilne kuumkoht"</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">"Kuumkoht on sees, jagamine"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Kuumkoht 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 andmemahu säästja on sisse lülitatud, siis ei saa jagada ega kasutada teisaldatavat kuumkohta"</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"USB jagamine"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3711893746716442706">"Telefoni Interneti-ühenduse jagamine USB kaudu"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="2292916486612255069">"Tahvelarvuti Interneti-ühenduse jagamine USB kaudu"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Jagamine Bluetoothiga"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="8828883800511737077">"Tahvelarvuti Interneti-ühenduse jagamine Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="1904667146601254812">"Telefoni Interneti-ühenduse jagamine Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="376389105752995580">"Seadme <xliff:g id="DEVICE_NAME">%1$d</xliff:g> Interneti-ühenduse jagamine Bluetoothi kaudu"</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="7112228674056306147">"Teistele seadmetele mobiilse andmesidevõrgu kaudu Interneti-ühenduse pakkumiseks kasutage kuumkohta ja ühenduse jagamist. Samuti saavad kuumkoha luua rakendused, et jagada sisu läheduses olevate seadmetega."</string>
    <string name="tethering_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-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 hinnangupakkuja"</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_category_recent_location_requests" msgid="1938721350424447421">"Hiljutised asukohapäringud"</string>
    <string name="location_recent_location_requests_see_all" msgid="9063541547120162593">"Kuva kõik"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Asukohateenused"</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_app_level_permissions" msgid="2777033567595680764">"Rakenduste load"</string>
    <string name="location_app_permission_summary_location_off" msgid="2790918244874943070">"Asukoht on välja lülitatud"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="5336807018727349708">
      <item quantity="other"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> rakendusel <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g>-st on asukohale juurdepääs</item>
      <item quantity="one"> <xliff:g id="PERMITTED_LOCATION_APP_COUNT_0">%1$d</xliff:g> rakendusel <xliff:g id="TOTAL_LOCATION_APP_COUNT_1">%2$d</xliff:g>-st on asukohale juurdepääs</item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="4911449278675337490">"Hiljutine juurdepääs asukohale"</string>
    <string name="location_recent_location_access_view_details" msgid="1955078513330927035">"Kuva üksikasjad"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Ükski rakendus pole hiljuti asukohateavet küsinud"</string>
    <string name="location_no_recent_accesses" msgid="7489449862187886009">"Ükski rakendus ei ole hiljuti asukohale juurde pääsenud"</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_scanning_screen_title" msgid="2297479353298444503">"WiFi ja Bluetoothi skannimine"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"WiFi-skannimine"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="2691110218127379249">"Lubage rakendustel ja teenustel alati otsida WiFi-võrke, isegi kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Bluetoothi skannimine"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="1285526059945206128">"Lubage rakendustel ja teenustel alati otsida läheduses olevaid seadmeid, isegi kui Bluetooth on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="managed_profile_location_services" msgid="4723268446874715222">"Asukohateenused töö jaoks"</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="device" msgid="6717640957897546887">"Teave seadme 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="module_license_title" msgid="258743239066841860">"Google Play süsteemivärskenduse litsentsid"</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="142307697309858185">"Teil ei ole andmesideühendust. Selle teabe praegu vaatamiseks minge Interneti-ühendusega arvutis aadressile %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Laadimine ..."</string>
    <string name="confirm_device_credential_pin" msgid="5308435093406166355">"Kasuta PIN-koodi"</string>
    <string name="confirm_device_credential_pattern" msgid="1350321840134412900">"Kasuta mustrit"</string>
    <string name="confirm_device_credential_password" msgid="2195705238498478704">"Kasuta parooli"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="2942199737559900752">"Ekraaniluku seadistamine"</string>
    <string name="lockpassword_choose_your_password_message" msgid="5377842480961577542">"Turvalisuse huvides määrake parool"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="6624409510609085450">"Sõrmejälje kasutamiseks määrake parool"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="5901096361617543819">"Sõrmejälje kasutamiseks määrake muster"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="6658264750811929338">"Turvalisuse huvides määrake PIN-kood"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="765344692615917183">"Sõrmejälje kasutamiseks määrake PIN-kood"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="8631545254345759087">"Turvalisuse huvides määrake muster"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="1266027268220850931">"Sisestage oma parool uuesti"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="7744513791910572550">"Sisestage oma PIN-kood uuesti"</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_draw_your_pattern_again_header" msgid="2872194349688886781">"Joonistage oma muster uuesti"</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_choose_your_password_header_for_face" msgid="6696331060928616331">"Face Unlocki kasutamiseks määrake parool"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="3981667199682290816">"Face Unlocki kasutamiseks määrake muster"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="3692990199320431002">"Face Unlocki kasutamiseks määrake PIN"</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_device_pattern" msgid="530802132223800623">"Lisaturvalisuse jaoks kasutage seadme mustrit"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="7829294830078036417">"Lisaturvalisuse jaoks sisestage oma seadme PIN-kood"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="3552644641574796973">"Lisaturvalisuse jaoks sisestage oma seadme parool"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="3003781907040522053">"Lisaturvalisuse jaoks kasutage oma tööprofiili mustrit"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="3367491332598821552">"Lisaturvalisuse jaoks sisestage oma tööprofiili PIN-kood"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="8159775129968582940">"Lisaturvalisuse jaoks sisestage oma tööprofiili parool"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6757336656791723193">"Teie telefon lähtestati tehaseseadetele. Selle telefoni kasutamiseks sisestage oma eelmine muster."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="826520613445990470">"Teie telefon lähtestati tehaseseadetele. Selle telefoni kasutamiseks sisestage oma eelmine PIN-kood."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="8944081074615739040">"Teie telefon lähtestati tehaseseadetele. Selle telefoni kasutamiseks sisestage oma eelmine parool."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="2898036091609128286">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="4141601774778898803">"PIN-koodi kinnitamine"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="3762615419295360480">"Parooli kinnitamine"</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">"Lukustamine toitenupuga"</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>
    <string name="recent_app_category_title" msgid="6673071268966003928">"Hiljuti avatud rakendused"</string>
    <string name="see_all_apps_title" msgid="1317153498074308438">"Kuva kõik <xliff:g id="COUNT">%1$d</xliff:g> rakendust"</string>
    <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="install_all_warning" product="device" msgid="3648003301476423145">"Teie seade ja isiklikud andmed on tundmatute rakenduste rünnakute suhtes haavatavamad. Sellest allikast rakendusi installides nõustute, et vastutate seadme kõigi kahjude ja andmekao eest, mis võivad 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="355574089263023363">"Tühjenda salvestusruum"</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="sort_order_recent_notification" msgid="6064103501358974282">"Kõige hiljutisemad"</string>
    <string name="sort_order_frequent_notification" msgid="1733204081305830670">"Kõige sagedasemad"</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ähtesta rakenduste eelistused"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Lähtestada rakenduste eelistused?"</string>
    <string name="reset_app_preferences_desc" msgid="731757609326016760">"See lähtestab kõik järgmised eelistused.\n\n"<li>"Keelatud rakendused"</li>\n<li>"Keelatud rakenduste märguanded"</li>\n<li>"Toimingute vaikerakendused"</li>\n<li>"Rakenduste taustaandmete piirangud"</li>\n<li>"Mis tahes lubade piirangud"</li>\n\n"Rakenduste 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="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="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_failed_dlg_text" msgid="8651231637137025815">"Rakenduse salvestusruumi ei õnnestunud tühjendada."</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="computing_size" msgid="1599186977475211186">"Arvutamine ..."</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Paketi suurust ei saanud arvutada."</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="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="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="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_positive" msgid="7375627244201714263">"Keela rakendus"</string>
    <string name="app_disable_dlg_text" msgid="1234624266290478136">"Selle rakenduse keelamisel ei pruugi Android ja muud rakendused enam ootuspäraselt töötada. Pange tähele, et seda rakendust ei saa kustutada, kuna see on seadmesse eelinstallitud. Rakenduse keelamisel lülitatakse see välja ja peidetakse seadmes."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Kas lülitada teatised välja?"</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_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_input_gesture_title" msgid="8749227808244881255">"Keeled, sisestus ja liigutused"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="7219895055450633449"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="756147879200943161"></string>
    <string name="language_input_gesture_summary_off" msgid="4617198819416948217"></string>
    <string name="language_settings" msgid="8758655933029560944">"Keeled ja sisend"</string>
    <string name="language_empty_list_user_restricted" msgid="5984015900102140696">"Teil pole luba seadme keele muutmiseks."</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Keeled ja sisend"</string>
    <string name="input_assistance" msgid="7392740255874966807">"Tööriistad"</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 hetkeks 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="4580907662493721491">"Klaviatuurid"</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="language_and_input_for_work_category_title" msgid="3825906835886710498">"Tööprofiili klaviatuurid ja tööriistad"</string>
    <string name="virtual_keyboards_for_work_title" msgid="2646946676585390499">"Virtuaalne klaviatuur töö jaoks"</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="421936611134697943">"Vibreerimise ümbersuunamine"</string>
    <string name="vibrate_input_devices_summary" msgid="82093256723774584">"Saadab vibreerimise 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_for_work_title" msgid="7634659414713254169">"Isiklik kataloog töö jaoks"</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="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="vision_settings_suggestion_title" msgid="8058794060304707004">"Fondi suuruse muutmine"</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="feature_flags_dashboard_title" msgid="778619522682769966">"Funktsiooni märgistamised"</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="8068289534732163115">"Subtiitrite eelistused"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Suurendus"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Kolmikpuudutusega suurendamine"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="4203215572713684224">"Otsetee abil suurendamine"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8416035446297644642">"Otsetee 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="6700716275347612310">"Kui suurendusfunktsioon on sisse lülitatud, saate oma ekraanikuval sisse suumida.\n\n"<b>"Suumimiseks"</b>" käivitage suurendusfunktsioon ja puudutage siis ekraanikuval mis tahes kohta.\n"<ul><li>"Kerimiseks lohistage kahe või enama sõrmega."</li>\n<li>"Suumi kohandamiseks pigistage kahte või enamat sõrme kokku."</li></ul>\n\n<b>"Ajutiseks suumimiseks"</b>" käivitage suurendusfunktsioon ja puudutage siis ekraanikuval pikalt mis tahes kohta.\n"<ul><li>"Ekraanikuval teisaldamiseks lohistage sõrme."</li>\n<li>"Väljasuumimiseks tõstke sõrm ekraanilt."</li></ul>\n\n"Klaviatuuril ega navigeerimisribal ei saa sisse suumida."</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="3682222614034474845">"Kasutage avamiseks juurdepääsetavuse nuppu"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="1342726230497913398">"Kasutage avamiseks liigutust"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8539392614235820285">"Kasutage uut juurdepääsetavuse liigutust"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="4803108127318033537">"Selle teenuse sisse- või väljalülitamiseks puudutage oma ekraanikuva allosas juurdepääsetavuse nuppu <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nTeenuste vahel vahetamiseks vajutage pikalt juurdepääsetavuse nuppu."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_without_talkback" msgid="5331865763478710038">"Selle teenuse sisse- või väljalülitamiseks pühkige kahe sõrmega ekraanikuva allosast üles.\n\nTeenuste vahel vahetamiseks pühkige kahe sõrmega üles ja hoidke."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_with_talkback" msgid="7656710338811226339">"Selle teenuse sisse- või väljalülitamiseks pühkige kolme sõrmega ekraanikuva allosast üles.\n\nTeenuste vahel vahetamiseks pühkige kolme sõrmega üles ja hoidke."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_without_talkback" msgid="3582632565941330367">"Juurdepääsetavuse teenuse sisse- või väljalülitamiseks pühkige kahe sõrmega ekraanikuva allosast üles.\n\nTeenuste vahel vahetamiseks pühkige kahe sõrmega üles ja hoidke."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_with_talkback" msgid="8539343463529744661">"Juurdepääsetavuse teenuse sisse- või väljalülitamiseks pühkige kolme sõrmega ekraanikuva allosast üles.\n\nTeenuste vahel vahetamiseks pühkige kolme sõrmega üles ja hoidke."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="8530755446904847423">"Selge"</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_screen_magnification_gesture_navigation_warning" msgid="5558685139615434791">"See juurdepääsetavuse liigutus on määratud teenusele <xliff:g id="SERVICE">%1$s</xliff:g>. Suurenduse kasutamiseks pühkige kahe sõrmega ekraanikuva allosast üles ja hoidke sõrmi ekraanil. Seejärel tehke valik Suurendus."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="2048884356166982714">"Helitugevuse nupu 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="1765853731190717372">"Kui otsetee on sisse lülitatud, võite hõlbustusfunktsiooni käivitamiseks hoida mõlemat helitugevuse nuppu 3 sekundit all."</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_disable_animations" msgid="5876035711526394795">"Animatsioonide eemaldamine"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Monoheli"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Kanalite ühendamine heli esitamisel"</string>
    <string name="accessibility_toggle_master_balance_title" msgid="551441665399043471">"Heli tasakaal"</string>
    <string name="accessibility_toggle_master_balance_left_label" msgid="840973259765894310">"Vasak"</string>
    <string name="accessibility_toggle_master_balance_right_label" msgid="7349959407092157385">"Parem"</string>
    <string name="accessibility_timeout_default" msgid="8316215621219570607">"Vaikeseade"</string>
    <string name="accessibility_timeout_10secs" msgid="1976492627730727871">"10 sekundit"</string>
    <string name="accessibility_timeout_30secs" msgid="8055710148052265579">"30 sekundit"</string>
    <string name="accessibility_timeout_1min" msgid="6314276027668784112">"1 minut"</string>
    <string name="accessibility_timeout_2mins" msgid="9062685014853095180">"2 minutit"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="870367947690762063">"Aeg toimingu tegemiseks (juurdepääsu ajalõpp)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="3076566452307147390">"Aeg toimingu tegemiseks"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="6557680564604287459">"Valige, kui kaua soovite kuvada sõnumeid, milles palutakse teil toiminguid teha, kuid mis on nähtaval ainult ajutiselt.\n\nKõik rakendused seda seadet ei toeta."</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="2434062071927416098">"Peatumisaeg"</string>
    <string name="accessibility_autoclick_description" msgid="4908960598910896933">"Kui kasutate hiirt, võite kursori seadistada automaatselt mõne toimingu tegema, kui see teatud aja jooksul ei liigu."</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Viide enne klikki"</string>
    <string name="accessibility_vibration_settings_title" msgid="3196059463767462026">"Vibreerimise ja värintagasiside tugevus"</string>
    <string name="accessibility_notification_vibration_title" msgid="3009997451790678444">"Märguanne koos vibreerimisega"</string>
    <string name="accessibility_ring_vibration_title" msgid="5369395955680650778">"Helin koos vibreerimisega"</string>
    <string name="accessibility_touch_vibration_title" msgid="3548641513105226156">"Puudutuste tagasiside"</string>
    <string name="accessibility_service_master_switch_title" msgid="6835441300276358239">"Kasuta teenust"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="8655284637968823154">"Kasuta värvikorrigeerimist"</string>
    <string name="accessibility_caption_master_switch_title" msgid="4010227386676077826">"Kasuta tiitreid"</string>
    <string name="accessibility_caption_preference_summary" msgid="7898443636143430927">"Kõik rakendused seda seadet ei toeta."</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="974461729380409972">"Jätka"</string>
    <string name="accessibility_hearingaid_title" msgid="8312145423610648518">"Kuuldeaparaadid"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="6240237523789614599">"Ühtegi kuuldeaparaati pole ühendatud"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="2947474468412309778">"Lisa kuuldeaparaate"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="3094382949733435414">"Kuuldeaparaatide sidumiseks leidke järgmisel kuval oma seade ja puudutage seda. Veenduge, et kuuldeaparaat oleks sidumisrežiimis."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="3924362383258688984">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> on aktiivne"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="3160782397139295486">
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> salvestatud kuuldeaparaati</item>
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> salvestatud kuuldeaparaat</item>
    </plurals>
    <string name="accessibility_summary_state_enabled" msgid="7914278500885887763">"Sees"</string>
    <string name="accessibility_summary_state_disabled" msgid="2984230257590246745">"Väljas"</string>
    <string name="accessibility_summary_state_stopped" msgid="1144156815350270876">"Ei tööta. Puudutage teabe nägemiseks."</string>
    <string name="accessibility_description_state_stopped" msgid="6953539746047006596">"Selle teenuse töös esineb häireid."</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_vibration_summary" msgid="4272038147476749536">"Helin – <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, märguanne – <xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>, puudutus – <xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="1753566394591809629">"Helina ja märguannete vibreerimine lülitati välja"</string>
    <string name="accessibility_vibration_summary_low" msgid="7628418309029013867">"Helina ja märguannete vibreerimine seati tasemele Nõrk"</string>
    <string name="accessibility_vibration_summary_medium" msgid="3422136736880414093">"Helina ja märguannete vibreerimine seati tasemele Keskmine"</string>
    <string name="accessibility_vibration_summary_high" msgid="3239807793182635729">"Helina ja märguannete vibreerimine seati tasemele Tugev"</string>
    <string name="accessibility_vibration_intensity_off" msgid="4613890213008630847">"Väljas"</string>
    <string name="accessibility_vibration_intensity_low" msgid="2017572546489862987">"Nõrk"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="3782136025830279769">"Keskmine"</string>
    <string name="accessibility_vibration_intensity_high" msgid="2543921139337952491">"Tugev"</string>
    <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="2813477981936919847">"Kas anda teenusele <xliff:g id="SERVICE">%1$s</xliff:g> teie seadme üle täielik kontroll?"</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="accessibility_service_warning" msgid="846312597054899472">"<xliff:g id="SERVICE">%1$s</xliff:g> taotleb seadme täielikku haldusõigust. Teenus saab juurdepääsufunktsioone vajavate kasutajate nimel ekraani lugeda ja tegutseda. See haldusõiguse tase ei ole enamiku rakenduste puhul sobilik."</string>
    <string name="accessibility_service_warning_description" msgid="5678294638592090340">"Täielik haldusõigus sobib rakendustele, mis pakuvad juurdepääsufunktsioone. Enamiku rakenduste puhul seda ei soovitata."</string>
    <string name="accessibility_service_screen_control_title" msgid="1262218781398117580">"Ekraanikuva vaatamine ja haldamine"</string>
    <string name="accessibility_service_screen_control_description" msgid="5263900135083661468">"See saab lugeda kogu ekraanil kuvatud sisu ja kuvada sisu rakenduste peal."</string>
    <string name="accessibility_service_action_perform_title" msgid="3591350033271419253">"Toimingute vaatamine ja tegemine"</string>
    <string name="accessibility_service_action_perform_description" msgid="2402904134246069476">"See saab jälgida teie suhtlust rakenduse või riistvaraanduriga ja teie eest rakendustega suhelda."</string>
    <string name="accessibility_dialog_button_allow" msgid="8427955451281232788">"Luba"</string>
    <string name="accessibility_dialog_button_deny" msgid="4307331121783796869">"Keela"</string>
    <string name="accessibility_dialog_button_stop" msgid="7861331860214808622">"Peata"</string>
    <string name="accessibility_dialog_button_cancel" msgid="5006357240387387028">"Tühista"</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="4593387199926310801">"Nupu <xliff:g id="STOP">%1$s</xliff:g> puudutamisel teenus <xliff:g id="SERVICE">%2$s</xliff:g> peatatakse."</string>
    <string name="accessibility_no_services_installed" msgid="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_configuring_state_title_template" msgid="1228890182762324249">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> seadistamine"</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="8482171736539410135">"Taustal kasutamise piiramine"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Lubatakse rakenduse taustal käitamine"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"Rakendusel ei ole lubatud taustal töötada"</string>
    <string name="background_activity_summary_whitelisted" msgid="1079899502347973947">"Taustal kasutamist ei saa piirata"</string>
    <string name="background_activity_warning_dialog_title" msgid="2216249969149568871">"Kas piirata taustal tegevust?"</string>
    <string name="background_activity_warning_dialog_text" msgid="7049624449246121981">"Kui piirate rakenduse tegevust taustal, võib rakendus valesti käituda."</string>
    <string name="background_activity_disabled_dialog_text" msgid="6133420589651880824">"Kuna rak. pole aku optimeerimine seadistatud, ei saa te seda piirata.\n\nRak. piiramiseks lülit. esmalt sisse aku optimeerimine."</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Ekraani kasutus alates täislaadimisest"</string>
    <string name="power_usage_list_summary" msgid="5584049564906462506">"Akukasutus alates täislaadimisest"</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="6768618303037280828">"Akukasutus"</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_tip_summary_title" msgid="368729969313047399">"Rakendused töötavad tavapäraselt"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="2198778125778121221">"Telefon kasutab akut taustal tavapärases ulatuses"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="1183976728682325345">"Tahvelarvuti kasutab akut taustal tavapärases ulatuses"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="363718204492523920">"Seade kasutab akut taustal tavapärases ulatuses"</string>
    <string name="battery_tip_low_battery_title" msgid="5103420355109677385">"Aku tühjeneb"</string>
    <string name="battery_tip_low_battery_summary" msgid="4702986182940709150">"Aku tööiga on lühike"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2542822112725248683">"Parandage telefoni aku tööiga"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6452567046912954866">"Parandage tahvelarvuti aku tööiga"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4445149029390556382">"Parandage seadme aku tööiga"</string>
    <string name="battery_tip_smart_battery_summary" msgid="2326809294592208069">"Lülitage sisse akuhaldur"</string>
    <string name="battery_tip_early_heads_up_title" msgid="5788492366387119807">"Lülitage akusäästja sisse"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="1639271439914224547">"Aku võib tavapärasest kiiremini tühjaks saada"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4294083319255926811">"Akusäästja on sisse lülitatud"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7054036010928794364">"Mõned funktsioonid võivad olla piiratud"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="1282187115295901930">"Telefoni on kasutatud tavapärasest rohkem"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="7422137233845959351">"Tahvelarvutit on kasutatud tavapärasest rohkem"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="5483320224273724068">"Seadet on kasutatud tavapärasest rohkem"</string>
    <string name="battery_tip_high_usage_summary" msgid="5343363604280323738">"Aku võib tavapärasest kiiremini tühjaks saada"</string>
    <string name="battery_tip_dialog_message" product="default" msgid="797225122502556066">"Teie telefoni on kasutatud tavapärasest rohkem. Aku võib oodatust kiiremini tühjaks saada.\n\nEnim akut kasutanud rakendused:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="49788591262480482">"Teie tahvelarvutit on kasutatud tavapärasest rohkem. Aku võib oodatust kiiremini tühjaks saada.\n\nEnim akut kasutanud rakendused:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="7959652003221931962">"Teie seadet on kasutatud tavapärasest rohkem. Aku võib oodatust kiiremini tühjaks saada.\n\nEnim akut kasutanud rakendused:"</string>
    <string name="battery_tip_dialog_message_footer" msgid="2560019187096011163">"Hõlmab akut koormavaid taustategevusi"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="467228882789275512">
      <item quantity="other">Piira %1$d rakendust</item>
      <item quantity="one">Piira %1$d rakendus</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="2996094393897875408">
      <item quantity="other">%2$d rakendust piirati hiljuti</item>
      <item quantity="one">%1$s rakendust piirati hiljuti</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="5768962491638423979">
      <item quantity="other">%2$d rakendust kasutavad taustal palju akut</item>
      <item quantity="one">%1$s rakendus kasutab taustal palju akut</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="1040488674178753191">
      <item quantity="other">Neid rakendusi ei saa taustal käitada</item>
      <item quantity="one">Seda rakendust ei saa taustal käitada</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="8130618585820429591">
      <item quantity="other">Kas soovite %1$d rakendust piirata?</item>
      <item quantity="one">Kas soovite rakendust piirata?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="7271391929137806299">"Aku säästmiseks peatage rakenduse <xliff:g id="APP">%1$s</xliff:g> jaoks taustal aku kasutamine. See rakendus ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="3175700359860699627">"Aku säästmiseks peatage nende rakenduste jaoks taustal aku kasutamine. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida.\n\nRakendused:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="582641081128076191">"Aku säästmiseks peatage nende rakenduste jaoks taustal aku kasutamine. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida.\n\nRakendused:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="8291115820018013353">"Piira"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="4321334634106715162">"Kas eemaldada piirang?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="6537761705584610231">"See rakendus saab taustal akut kasutada. Aku võib oodatust varem tühjaks saada."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="6022058431218137646">"Eemalda"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="3058235875830858902">"Tühista"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="4628448253185085796">"Teie rakendused kasutavad akut tavapärases ulatuses. Kui rakendused kasutavad liiga palju akut, soovitab telefon teile selle vastu sobilikke meetmeid.\n\nKui aku hakkab tühjaks saama, võite alati akusäästja sisse lülitada."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="8327950887399420971">"Teie rakendused kasutavad akut tavapärases ulatuses. Kui rakendused kasutavad liiga palju akut, soovitab tahvelarvuti teile selle vastu sobilikke meetmeid.\n\nKui aku hakkab tühjaks saama, võite alati akusäästja sisse lülitada."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="6753742263807939789">"Teie rakendused kasutavad akut tavapärases ulatuses. Kui rakendused kasutavad liiga palju akut, soovitab seade teile selle vastu sobilikke meetmeid.\n\nKui aku hakkab tühjaks saama, võite alati akusäästja sisse lülitada."</string>
    <string name="smart_battery_manager_title" msgid="870632749556793417">"Akuhaldur"</string>
    <string name="smart_battery_title" msgid="6218785691872466076">"Halda rakendusi automaatselt"</string>
    <string name="smart_battery_summary" msgid="1339184602000004058">"Akukasutuse piiramine rakenduste puhul, mida te ei kasuta sageli"</string>
    <string name="smart_battery_footer" product="default" msgid="5555604955956219544">"Kui akuhaldur tuvastab, et rakendused kurnavad akut, on teil võimalik nende rakenduste tööd piirata. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="smart_battery_footer" product="tablet" msgid="5555604955956219544">"Kui akuhaldur tuvastab, et rakendused kurnavad akut, on teil võimalik nende rakenduste tööd piirata. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="smart_battery_footer" product="device" msgid="5555604955956219544">"Kui akuhaldur tuvastab, et rakendused kurnavad akut, on teil võimalik nende rakenduste tööd piirata. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="restricted_app_title" msgid="8982477293044330653">"Piiratud rakendused"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="7355687633914223530">
      <item quantity="other">Akukasutust piiratakse %1$d rakenduse jaoks</item>
      <item quantity="one">Akukasutust piiratakse %1$d rakenduse jaoks</item>
    </plurals>
    <string name="restricted_app_time_summary" msgid="6983512391277778623">"Piiratud <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="6739863162364046859">"Need rakendused kasutavad taustal akut. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="battery_auto_restriction_title" msgid="6553271897488963709">"Akuhalduri kasutamine"</string>
    <string name="battery_auto_restriction_summary" msgid="8561335400991281062">"Tuvasta, kui rakendused kurnavad akut"</string>
    <string name="battery_manager_on" msgid="8643310865054362396">"Sees / Tuvastatakse, kui rakendused kurnavad akut"</string>
    <string name="battery_manager_off" msgid="5473135235710343576">"Väljas"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="1026141135861471129">
      <item quantity="other">%1$d rakendust on piiratud</item>
      <item quantity="one">%1$d rakendus on piiratud</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="1766047545950757380">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="dialog_stop_title" msgid="6395127715596746479">"Kas peatada rakendus?"</string>
    <string name="dialog_stop_message" product="default" msgid="4006631636646776488">"Teie telefon ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP">%1$s</xliff:g> hoiab seadet ärkvel.\n\nProbleemi lahendamiseks võite proovida rakenduse peatada.\n\nKui probleem ei lahene, tuleb teil aku tööea pikendamiseks võib-olla rakendus desinstallida."</string>
    <string name="dialog_stop_message" product="tablet" msgid="2369957934555162428">"Teie tahvelarvuti ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP">%1$s</xliff:g> hoiab seadet ärkvel.\n\nProbleemi lahendamiseks võite proovida rakenduse peatada.\n\nKui probleem ei lahene, tuleb teil aku tööea pikendamiseks võib-olla rakendus desinstallida."</string>
    <string name="dialog_stop_message" product="device" msgid="6195430620406365292">"Teie seade ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP">%1$s</xliff:g> hoiab seadet ärkvel.\n\nProbleemi lahendamiseks võite proovida rakenduse peatada.\n\nKui probleem ei lahene, tuleb teil aku tööea pikendamiseks võib-olla rakendus desinstallida."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="1638726742782558262">"Teie telefon ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP_0">%1$s</xliff:g> äratab telefoni sageli.\n\nProbleemi lahendamiseks võite proovida rakenduse <xliff:g id="APP_1">%1$s</xliff:g> peatada.\n\nKui probleem ei lahene, tuleb teil aku tööea pikendamiseks võib-olla rakendus desinstallida."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="8771690983566539742">"Teie tahvelarvuti ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP_0">%1$s</xliff:g> äratab tahvelarvutit sageli.\n\nProbleemi lahendamiseks võite proovida rakenduse <xliff:g id="APP_1">%1$s</xliff:g> peatada.\n\nKui probleem ei lahene, tuleb teil aku tööea pikendamiseks võib-olla rakendus desinstallida."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="2854944538238649520">"Teie seade ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP_0">%1$s</xliff:g> äratab seadet sageli.\n\nProbleemi lahendamiseks võite proovida rakenduse <xliff:g id="APP_1">%1$s</xliff:g> peatada.\n\nKui probleem ei lahene, tuleb teil aku tööea pikendamiseks võib-olla rakendus desinstallida."</string>
    <string name="dialog_stop_ok" msgid="2319777211264004900">"Peata rakendus"</string>
    <string name="dialog_background_check_title" msgid="6936542136153283692">"Kas peatada rakendus ja lülitada taustal kasutamine välja?"</string>
    <string name="dialog_background_check_message" product="default" msgid="4045827746349279563">"Teie telefon ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP_0">%1$s</xliff:g> äratab telefoni sageli.\n\nProbleemi lahendamiseks võite rakenduse <xliff:g id="APP_1">%1$s</xliff:g> peatada ja takistada seda taustal töötamast."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="8348214419901788270">"Teie tahvelarvuti ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP_0">%1$s</xliff:g> äratab tahvelarvutit sageli.\n\nProbleemi lahendamiseks võite rakenduse <xliff:g id="APP_1">%1$s</xliff:g> peatada ja takistada seda taustal töötamast."</string>
    <string name="dialog_background_check_message" product="device" msgid="5847977433118915863">"Teie seade ei saa akut tavapärasel moel hallata, kuna <xliff:g id="APP_0">%1$s</xliff:g> äratab seadet sageli.\n\nProbleemi lahendamiseks võite rakenduse <xliff:g id="APP_1">%1$s</xliff:g> peatada ja takistada seda taustal töötamast."</string>
    <string name="dialog_background_check_ok" msgid="412876934682899659">"Lülita välja"</string>
    <string name="dialog_location_title" msgid="5888917530725874727">"Kas soovite asukohateabe edastamise välja lülitada?"</string>
    <string name="dialog_location_message" product="default" msgid="7774807745601479888">"Teie telefon ei saa akut tavapärasel moel hallata, kuna rakendus <xliff:g id="APP">%1$s</xliff:g> taotleb teie asukohateavet ka ajal, mil te rakendust ei kasuta.\n\nProbleemi lahendamiseks võite oma asukohateabe edastamise selle rakenduse jaoks välja lülitada."</string>
    <string name="dialog_location_message" product="tablet" msgid="118745801732181618">"Teie tahvelarvuti ei saa akut tavapärasel moel hallata, kuna rakendus <xliff:g id="APP">%1$s</xliff:g> taotleb teie asukohateavet ka ajal, mil te rakendust ei kasuta.\n\nProbleemi lahendamiseks võite oma asukohateabe edastamise selle rakenduse jaoks välja lülitada."</string>
    <string name="dialog_location_message" product="device" msgid="6783678153382298295">"Teie seade ei saa akut tavapärasel moel hallata, kuna rakendus <xliff:g id="APP">%1$s</xliff:g> taotleb teie asukohateavet ka ajal, mil te rakendust ei kasuta.\n\nProbleemi lahendamiseks võite oma asukohateabe edastamise selle rakenduse jaoks välja lülitada."</string>
    <string name="dialog_location_ok" msgid="4572391197601313986">"Lülita välja"</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="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_active_for" msgid="2964359540508103032">"Aktiivne <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_full_charge_last" msgid="8892335687734288031">"Täislaaditud seade kestab umbes"</string>
    <string name="battery_footer_summary" msgid="67169726550144016">"Aku kasutuse andmed on ligikaudsed ja võivad sõltuvalt kasutusest muutuda"</string>
    <string name="battery_detail_foreground" msgid="3350401514602032183">"Aktiivselt kasutatud"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"Taustal"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Akukasutus"</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="advanced_battery_graph_subtext" msgid="5621073891377915877">"Aku järelejäänud tööaja prognoos põhineb seadme kasutusel"</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_mediaserver_label" msgid="6500382062945689285">"Meediumiserver"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Rakenduse optimeerimine"</string>
    <string name="battery_saver" msgid="8172485772238572153">"Akusäästja"</string>
    <string name="battery_saver_auto_title" msgid="8368709389419695611">"Lülita automaatselt sisse"</string>
    <string name="battery_saver_auto_no_schedule" msgid="632243833320671052">"Ajakava puudub"</string>
    <string name="battery_saver_auto_routine" msgid="8076053160450346731">"Põhineb teie rutiinil"</string>
    <string name="battery_saver_auto_percentage" msgid="9000542338151528905">"Põhineb protsendil"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3030089882678228374">"Akusäästja lülitub sisse, kui teie aku saab enne tavapärast laadimisaega tõenäoliselt tühjaks"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="3653601117764171846">"Lülitub sisse <xliff:g id="PERCENT">%1$s</xliff:g> juures"</string>
    <string name="battery_saver_schedule_settings_title" msgid="6000660866895036589">"Ajakava määramine"</string>
    <string name="battery_saver_turn_on_summary" msgid="5552800757174173459">"Aku tööea pikendamine"</string>
    <string name="battery_saver_sticky_title_new" msgid="613272902035943099">"Lülita välja, kui aku on täis laetud"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="6659545534053937371">"Akusäästja lülitub välja, kui telefoni aku laetuse tase on <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6537930800784858686">"Akusäästja lülitub välja, kui tahvelarvuti aku laetuse tase on <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8309483774864505603">"Akusäästja lülitub välja, kui seadme aku laetuse tase on <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3795833548145424276) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="1138980155985636295">"Lülita sisse"</string>
    <string name="battery_saver_master_switch_title" msgid="622539414546588436">"Kasuta akusäästjat"</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="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="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_reset_hint" msgid="6297256880896133631">"Kas eemaldada kogu sisu?"</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="usage_access_title" msgid="332333405495457839">"Kasutusjuurdepääsuga rakend."</string>
    <string name="emergency_tone_title" msgid="254495218194925271">"Hädaabikõne signaal"</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_summary_state_on" msgid="6407084627816231202">"Sees"</string>
    <string name="backup_summary_state_off" msgid="7388321532624105594">"Väljas"</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="backup_data_management_title" msgid="4059093462647090064">"Varundamiskonto haldamine"</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 admin. 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 admin. rakendus?"</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_warning_simplified" msgid="8085544856342321981">"Seda seadet haldab ja jälgib rakendus <xliff:g id="APP_NAME">%1$s</xliff:g>."</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="profile_owner_add_title_simplified" msgid="6856400286736117006">"Kas lubada järelevalve?"</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="notification_log_title" msgid="3766148588239398464">"Märguannete logi"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Kõne helin ja vibreerimine"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Võrgu üksikasjad"</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="7157582467956920750">"Tööprofiil"</string>
    <string name="work_mode_on_summary" msgid="3628349169847990263">"Haldab teie organisatsioon"</string>
    <string name="work_mode_off_summary" msgid="2657138190560082508">"Rakendused ja märguanded on välja lülitatud"</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="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="really_remove_account_message" product="device" msgid="7507474724882080166">"Selle konto eemaldamisel kustutatakse kõik seal olevad sõnumid, kontaktid ja muud seadmes olevad andmed."</string>
    <string name="remove_account_failed" msgid="3901397272647112455">"Administraator on selle muudatuse keelanud"</string>
    <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="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">"Andmeside kasutus"</string>
    <string name="data_usage_app_summary_title" msgid="5571051159374290375">"Mobiilne andmeside, WiFi"</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_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">"Esiplaanil"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Taustal"</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_roaming_enable_mobile" msgid="1523331545457578362">"Rändlusteenus"</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 mobiilse andmeside kasutus taustal"</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_metered_auto" msgid="1262028400911918865">"Automaatne"</string>
    <string name="wifi_metered_title" msgid="5536703738895222444">"Võrgukasutus"</string>
    <string name="data_usage_metered_yes" msgid="9217539611385225894">"Mahupõhine"</string>
    <string name="data_usage_metered_no" msgid="4025232961929071789">"Pole mahupõhine"</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-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="7144543717673197102">"Kui see seade on sisse lülitatud, pole teil Interneti-ühendust, kuni VPN-iga ühenduse loomine õnnestub"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="798121133114824006">"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-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="spellcheckers_settings_for_work_title" msgid="4114555511355171248">"Õigekirjakontroll töö jaoks"</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="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="3493908927709169019">"Mitu kasutajat"</string>
    <string name="user_settings_footer_text" product="device" msgid="5947601460660791129">"Jagage oma seadet, lisades uusi kasutajaid. Igal kasutajal on teie seadmes isiklik ruum, kus on kohandatud avakuvad, kontod, rakendused, seaded ja palju muud."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="2153761434649733502">"Jagage oma tahvelarvutit, lisades uusi kasutajaid. Igal kasutajal on teie tahvelarvutis isiklik ruum, kus on kohandatud avakuvad, kontod, rakendused, seaded ja palju muud."</string>
    <string name="user_settings_footer_text" product="default" msgid="2844602828189838075">"Jagage oma telefoni, lisades uusi kasutajaid. Igal kasutajal on teie telefonis isiklik ruum, kus on kohandatud avakuvad, kontod, rakendused, seaded ja palju muud."</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="6768718238082929201">"Võite jagada seda 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 rakendusi kõigi kasutajate jaoks värskendada. Juurdepääsetavuse seadeid ja teenuseid ei pruugita uuele kasutajale üle kanda."</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 kasutaja kohe?"</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 kohe"</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="8068422695175097315">"Kas kustutada 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="3612979309028881318">"Kasutaja kustutamine"</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="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="2705726826263742491">"Abiartiklid, telefon ja vestlus, alustamine"</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="4124461751977706019">"Hädaolukorra teatised"</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="2544026384901010606">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="480304128966864221">"Täiustatud helistamine"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="6839553611093179243">"4G-helistamine"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="4156658595226379286">"Parema hääl- ja muu side kvaliteedi tagamiseks LTE-teenuste kasutamine (soovitatav)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="6145184730437907078">"Parema hääl- ja muu side kvaliteedi tagamiseks 4G-teenuste kasutamine (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="mms_message_title" msgid="6068098013612041440">"Multimeediumsõnumid"</string>
    <string name="mms_message_summary" msgid="8408985719331988420">"Saatmine ja vastuvõtmine, kui mobiilne andmeside on väljas"</string>
    <string name="data_during_calls_title" msgid="4476240693784306761">"Kõnede ajal andmeside lubamine"</string>
    <string name="data_during_calls_summary" msgid="497978580819604521">"Lubab kasutada seda SIM-i mobiilseks andmesideks ainult kõnede ajal"</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="4038201220173969126">"Pildista"</string>
    <string name="user_image_choose_photo" msgid="7643300431215339631">"Vali pilt"</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="select_sim_for_sms" msgid="6232060107120265044">"Valige SMS-i jaoks SIM-kaart"</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_status_title_sim_slot" msgid="5725659316463979194">"SIM-kaardi olek (SIM-kaardi pesa %1$d)"</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="sim_selection_channel_title" msgid="2760909074892782589">"SIM-kaardi valik"</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="3135144174846753758">"Võrk ja Internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="3851083934739500429">"mobiilivõrk"</string>
    <string name="network_dashboard_summary_data_usage" msgid="3843261364705042212">"andmeside kasutus"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"kuumkoht"</string>
    <string name="connected_devices_dashboard_title" msgid="2355264951438890709">"Ühendatud seadmed"</string>
    <string name="connected_devices_dashboard_summary" msgid="2665221896894251402">"Bluetooth, sõidurežiim, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="3840842725283655533">"Bluetooth, sõidurežiim"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="5018708106066758867">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="5250078362483148199">"Bluetooth"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Rakendused ja märguanded"</string>
    <string name="app_and_notification_dashboard_summary" msgid="3285151907659820564">"Hiljutised rakendused, vaikerakendused"</string>
    <string name="notification_settings_work_profile" msgid="3186757479243373003">"Tööprofiilil pole märguannete juurdepääs rakenduste puhul saadaval."</string>
    <string name="account_dashboard_title" msgid="5895948991491438911">"Kontod"</string>
    <string name="account_dashboard_default_summary" msgid="3998347400161811075">"Kontosid pole lisatud"</string>
    <string name="app_default_dashboard_title" msgid="7342549305933047317">"Vaikerakendused"</string>
    <string name="system_dashboard_summary" msgid="6839969589170062254">"Keeled, liigutused, kellaaeg, varundamine"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Seaded"</string>
    <string name="keywords_wifi" msgid="3646884600964177062">"wifi, wi-fi, võrguühendus, internet, juhtmeta, andmed, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="8745178424405564885">"WiFi märguanne, wifi märguanne"</string>
    <string name="keywords_vibrate_on_touch" msgid="1494239633254176598">"Vibreerimise peatamine, puudutus, klaviatuur"</string>
    <string name="keywords_time_format" msgid="5581515674151927461">"Kasuta 24-tunnist vormingut"</string>
    <string name="keywords_storage_files" msgid="7075933058850826819">"Allalaadimine"</string>
    <string name="keywords_app_default" msgid="5822717006354487071">"Ava rakendusega"</string>
    <string name="keywords_applications_settings" msgid="1268353611121497450">"Rakendused"</string>
    <string name="keywords_time_zone" msgid="998254736898753085">"ajavöönd"</string>
    <string name="keywords_draw_overlay" msgid="1001120206241401007">"Vestlusmull, süsteem, teatis, aken, dialoog, kuvamine, muude rakenduste peal, joonistamine"</string>
    <string name="keywords_flashlight" msgid="6161632177705233710">"Taskulamp, valgus, lamp"</string>
    <string name="keywords_change_wifi_state" msgid="627068244033681010">"wifi, WiFi, lüliti, juhtimine"</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_display" msgid="8910345814565493016">"ekraan, puuteekraan"</string>
    <string name="keywords_display_brightness_level" msgid="3138350812626210404">"ekraani hämardamine, puuteekraan, aku, ere"</string>
    <string name="keywords_display_night_display" msgid="2534032823231355074">"ekraani hämardamine, öö, toon, öörežiim, eredus, ekraanikuva värv, värv"</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="1209288893924324904">"projekt, ülekandmine, ekraani peegeldamine, ekraani jagamine, peegeldamine, kuva jagamine, ekraani ü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="2261491208836438871">"pühkimine, kustutamine, taastamine, tühjendamine, eemaldamine, tehaseseadetele lähtestamine"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"printer"</string>
    <string name="keywords_sounds" msgid="5633386070971736608">"kõlari piiks, kõlar, helitugevus, vaigistamine, vaikus, heli, muusika"</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="4132655528196729043">"läheduses, asukoht, ajalugu, aruandlus, GPS"</string>
    <string name="keywords_accounts" msgid="4479029747403203867">"konto, lisa konto, tööprofiil"</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_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="6239410718075715449">"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="3526905012224714078">"liigutused"</string>
    <string name="keywords_payment_settings" msgid="5220104934130446416">"maksa, puuduta, maksed"</string>
    <string name="keywords_backup" msgid="470070289135403022">"varukoopia, varundamine"</string>
    <string name="keywords_assist_gesture_launch" msgid="813968759791342591">"liigutus"</string>
    <string name="keywords_face_unlock" msgid="254144854349092754">"nägu, avamine, autentimine, sisselogimine"</string>
    <string name="keywords_imei_info" msgid="7230982940217544527">"imei, meid, min, prl-i versioon, imei sv"</string>
    <string name="keywords_sim_status" msgid="6682044233620329507">"võrk, mobiilsidevõrgu olek, teenuse olek, signaali tugevus, mobiilsidevõrgu tüüp, rändlus, iccid, eid"</string>
    <string name="keywords_model_and_hardware" msgid="1459248377212829642">"seerianumber, riistvaraversioon"</string>
    <string name="keywords_android_version" msgid="9069747153590902819">"androidi turvapaiga tase, põhiribaversioon, tuuma versioon"</string>
    <string name="keywords_dark_ui_mode" msgid="8999745898782012625">"teema, hele, tume, režiim"</string>
    <string name="keywords_systemui_theme" msgid="9112852512550404882">"tume teema"</string>
    <string name="keywords_device_feedback" msgid="564493721125966719">"viga"</string>
    <string name="keywords_ambient_display_screen" msgid="5874969496073249362">"Säästlik ekraan, lukustuskuva ekraan"</string>
    <string name="keywords_lock_screen_notif" msgid="6716392855813576197">"lukustuskuva märguanne, märguanded"</string>
    <string name="keywords_face_settings" msgid="7505388678116799329">"nägu"</string>
    <string name="keywords_fingerprint_settings" msgid="4425098764810291897">"sõrmejälg, sõrmejälje lisamine"</string>
    <string name="keywords_display_auto_brightness" msgid="4561771351118904241">"ekraani hämardamine, puuteekraan, aku, nutikas heledus, dünaamiline heledus, automaatne heledus"</string>
    <string name="keywords_display_adaptive_sleep" msgid="6865504720946121402">"ekraani hämardamine, unerežiim, aku, ajalõpp, tuvastus, ekraan, ekraanikuva, tegevusetus"</string>
    <string name="keywords_auto_rotate" msgid="5620879898668211494">"pöörama, vahetamine, pööramine, vertikaalpaigutus, horisontaalpaigutus, suund, vertikaalne, horisontaalne"</string>
    <string name="keywords_system_update_settings" msgid="7752189778843741773">"versiooniuuendus, android"</string>
    <string name="keywords_zen_mode_settings" msgid="6526742836231604995">"dnd, ajakava, märguanded, blokeerimine, vaikus, vibreerimine, unerežiim, töö, keskendumine, heli, vaigistamine, päev, tööpäev, nädalalõpp, öö nädala sees, sündmus"</string>
    <string name="keywords_screen_timeout" msgid="8161370660970309476">"kuva, lukustusaeg, ajalõpp, lukustuskuva"</string>
    <string name="keywords_storage_settings" msgid="297283751968446577">"mälu, vahemälu, andmed, kustutamine, tühjendamine, vaba, ruum"</string>
    <string name="keywords_bluetooth_settings" msgid="6804844062789439858">"ühendatud, seade, kõrvaklapid, peakomplekt, kõlar, juhtmeta, sidumine, nööpkõrvaklapid, muusika, meedia"</string>
    <string name="keywords_wallpaper" msgid="5058364390917429896">"taust, kuva, lukustuskuva, teema"</string>
    <string name="keywords_styles" msgid="5828725481814049422">"ikooni kuju, aktsentvärv, font"</string>
    <string name="keywords_assist_input" msgid="5017533309492679287">"vaikimisi, assistent"</string>
    <string name="keywords_default_payment_app" msgid="3838565809518896799">"makse, vaikeseade"</string>
    <string name="keywords_ambient_display" msgid="3103487805748659132">"sissetulev märguanne"</string>
    <string name="keywords_hotspot_tethering" msgid="1137511742967410918">"usb jagamine, bluetoothi jagamine, wifi-pääsupunkt"</string>
    <string name="keywords_touch_vibration" msgid="5983211715076385822">"puutepõhine, vibreerimine, kuva, tundlikkus"</string>
    <string name="keywords_ring_vibration" msgid="4652101158979064884">"puutepõhine, vibreerimine, telefon, kõne, tundlikkus, helin"</string>
    <string name="keywords_notification_vibration" msgid="31924624421190547">"puutepõhine, vibreerimine, tundlikkus"</string>
    <string name="keywords_battery_saver_sticky" msgid="5586215686021650278">"akusäästja, kinnitatav, pidev, aku säästmine, aku"</string>
    <string name="keywords_battery_saver_schedule" msgid="7358789228486231944">"rutiin, ajakava, akusäästja, toite säästmine, aku, automaatne, protsent"</string>
    <string name="keywords_enhance_4g_lte" msgid="2273810564244790859">"volte, täiustatud helistamine, 4g-kõned"</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="remote_media_volume_option_title" msgid="7602586327091007461">"Ülekantava sisu helitugevus"</string>
    <string name="call_volume_option_title" msgid="1265865226974255384">"Kõne helitugevus"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Äratuse 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="8658910997501323472">"Vibreerimine 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="3379885700913955599">"Laadimishelid ja vibreerimine"</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="1510405818894719079">"Puudutusel vibreerimine"</string>
    <string name="vibrate_on_touch_summary" msgid="8015901758501868229">"Värintagasiside puudutuse, klaviatuuri ja muu kohta"</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="3750231842974733677">"Vaikus"</string>
    <string name="emergency_tone_alert" msgid="8523447641290736852">"Toonid"</string>
    <string name="emergency_tone_vibrate" msgid="2278872257053690683">"Vibratsioonid"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Sisselülitamise helid"</string>
    <string name="live_caption_title" msgid="2241633148129286971">"Reaalajas subtiitrid"</string>
    <string name="live_caption_summary" msgid="3365960379606535783">"Meediasisu automaatsed subtiitrid"</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Mitte kunagi"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="2249085722517252521">
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> on lubatud</item>
      <item quantity="one">1 on lubatud</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="1066226840983908121">"Mitte segada"</string>
    <string name="zen_mode_slice_subtitle" msgid="1495506059205752083">"Katkestuste piiramine"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Valiku Mitte segada sisselülitamine"</string>
    <string name="zen_mode_behavior_settings_title" msgid="5453115212674008032">"Erandid"</string>
    <string name="zen_mode_duration_settings_title" msgid="8471983919324532829">"Vaikekestus"</string>
    <string name="zen_mode_behavior_allow_title" msgid="3845615648136218141">"Luba heli ja vibreerimine:"</string>
    <string name="zen_mode_behavior_no_sound" msgid="1219626004723208056">"Heli puudub"</string>
    <string name="zen_mode_behavior_total_silence" msgid="2229976744274214528">"Täielik vaikus"</string>
    <string name="zen_mode_behavior_no_sound_except" msgid="4968477585788243114">"Heli puudub, v.a <xliff:g id="CATEGORIES">%1$s</xliff:g>"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="6455884547877702466">"Helid on vaigistatud (v.a alarmid ja meedia)"</string>
    <string name="zen_mode_automation_settings_title" msgid="6155298704165984370">"Ajakavad"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5975522152123354381">"Ajakavade kustutamine"</string>
    <string name="zen_mode_schedule_delete" msgid="5717258786128155695">"Kustuta"</string>
    <string name="zen_mode_rule_name_edit" msgid="812185626159430507">"Muuda"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="8995524726286378583">"Ajakavad"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="4773111805919088437">"Ajakava"</string>
    <string name="zen_mode_schedule_category_title" msgid="5482757877262584975">"Ajastamine"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="4321254843908888574">"Telefoni vaigistamine teatud ajal"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="6223252025075862701">"Režiimi Mitte segada reeglite määramine"</string>
    <string name="zen_mode_schedule_title" msgid="8616187805239590649">"Ajastamine"</string>
    <string name="zen_mode_use_automatic_rule" msgid="489102635414919052">"Kasuta ajakava"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Ainult prioriteetsed"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Ainult äratused"</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="zen_mode_visual_signals_settings_subtitle" msgid="6308824824208120508">"Luba visuaalsed signaalid"</string>
    <string name="zen_mode_settings_category" msgid="8404473163624911791">"Kui funktsioon Mitte segada on sisse lülitatud"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="8138441771855063771">"Märguannete piiramine"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="3690261619682396872">"Hääletud märguanded"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="5810076116489877312">"Näete ekraanil märguandeid"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="3465600930732602159">"Teie telefon ei helise ega vibreeri märguannete saabumisel."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5305121630186687339">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="7555448406901864904">"Te ei kuule ega näe märguandeid"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="1069960859746788356">"Teie telefon ei vibreeri ega helise uute ega olemasolevate märguannete puhul ega kuva neid. Pidage meeles, et kriitilised märguanded telefoni tegevuste ja oleku kohta kuvatakse siiski.\n\nKui funktsiooni Mitte segada välja lülitate, leiate nägemata märguanded ekraani ülaosast alla pühkides."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="7498689167767941034">"Kohandatud"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4250962169561739747">"Kohandatud seade lubamine"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="6676997522330453597">"Kohandatud seade eemaldamine"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="5450158135853888485">"Hääletud märguanded"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="7416121534987213074">"Osaliselt peidetud"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="3618285192806732504">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_mode_what_to_block_title" msgid="5480903548365697159">"Kohandatud piirangud"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="4659484530849212827">"Kui ekraan on sees"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="4276414460889400625">"Kui ekraan on väljas"</string>
    <string name="zen_mode_block_effect_sound" msgid="7383953383758025895">"Vaigista heli ja vibreerimine"</string>
    <string name="zen_mode_block_effect_intent" msgid="350764335391428447">"Ära lülita ekraani sisse"</string>
    <string name="zen_mode_block_effect_light" msgid="8106976110224107316">"Ära vilguta tuld"</string>
    <string name="zen_mode_block_effect_peek" msgid="6836997464098657115">"Ära kuva märguandeid ekraanil"</string>
    <string name="zen_mode_block_effect_status" msgid="1651527249762752921">"Peida ülaosas olekuriba ikoonid"</string>
    <string name="zen_mode_block_effect_badge" msgid="214553506070597320">"Peida märguandetäpid ikoonidel"</string>
    <string name="zen_mode_block_effect_ambient" msgid="4704755879961212658">"Ära ärata märguannete puhul"</string>
    <string name="zen_mode_block_effect_list" msgid="4722887783222298295">"Peida allatõmmatavas menüüs"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="2617875282623486256">"Mitte kunagi"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="1230265589026355094">"Kui ekraan on väljas"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="6017536991063513394">"Kui ekraan on sees"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1065107568053759972">"Heli ja vibreerimine"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="3635646031575107456">"Märguannete heli, vibreerimine ja mõned visuaalsed märgid"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="1213328945418248026">"Märguannete heli, vibreerimine ja visuaalsed märgid"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="5710896246703497760">"Märguandeid, mis on vajalikud telefoni põhitoiminguteks ja oleku kuvamiseks, ei peideta kunagi"</string>
    <string name="zen_mode_no_exceptions" msgid="7653433997399582247">"Puudub"</string>
    <string name="zen_mode_other_options" msgid="520015080445012355">"muud valikud"</string>
    <string name="zen_mode_add" msgid="90014394953272517">"Lisa"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="8287824809739581837">"Lülita sisse"</string>
    <string name="zen_mode_button_turn_on" msgid="2824380626482175552">"Lülita kohe sisse"</string>
    <string name="zen_mode_button_turn_off" msgid="6181953727880503094">"Lülita kohe välja"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8860646554263965569">"Funktsioon Mitte segada on sees kuni <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="7186615007561990908">"Funktsioon Mitte segada on sees seni, kuni selle välja lülitate"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="6195725842906270996">"Ajakava (<xliff:g id="RULE_NAME">%s</xliff:g>) lülitas funktsiooni Mitte segada automaatselt sisse"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="1721179577382915270">"Rakendus (<xliff:g id="APP_NAME">%s</xliff:g>) lülitas funktsiooni Mitte segada automaatselt sisse"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="1965922539531521052">"Funktsioon Mitte segada on reeglite <xliff:g id="RULE_NAMES">%s</xliff:g> puhul sisse lülitatud koos kohandatud seadetega."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="7555742240858292255"><annotation id="link">" Kuva kohandatud seaded"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Ainult prioriteetsed"</string>
    <string name="zen_mode_and_condition" msgid="4927230238450354412">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="1202632669798211342">"Sees / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off_with_info" msgid="2348629457144123849">"Väljas / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off" msgid="4375814717589425561">"Väljas"</string>
    <string name="zen_mode_sound_summary_on" msgid="7718273231309882914">"Sees"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="3483258992533158479">"Küsi iga kord"</string>
    <string name="zen_mode_duration_summary_forever" msgid="8597777321810802309">"Kuni välja lülitate"</string>
    <plurals name="zen_mode_duration_summary_time_hours" formatted="false" msgid="3224363976852136871">
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> tundi</item>
      <item quantity="one">1 tund</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="6238305783533884764">"<xliff:g id="NUM_MINUTES">%d</xliff:g> minutit"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="6751226506661227581">
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> ajakava saab automaatselt sisse lülitada</item>
      <item quantity="one">1 ajakava saab automaatselt sisse lülitada</item>
    </plurals>
    <string name="zen_category_behavior" msgid="554277240833452070">"Vaigista seade, kuid luba erandid"</string>
    <string name="zen_category_exceptions" msgid="7601136604273265629">"Erandid"</string>
    <string name="zen_category_schedule" msgid="9000447592251450453">"Ajakava"</string>
    <string name="zen_sound_title" msgid="4461494611692749446">"Kuva kõik erandid"</string>
    <string name="zen_sound_footer" msgid="7621745273287208979">"Kui funktsioon Mitte segada on sisse lülitatud, vaigistatakse heli ja vibreerimine (v.a ülal lubatud üksuste puhul)."</string>
    <string name="zen_sound_category_title" msgid="4336596939661729188">"Vaigista kõik, v.a"</string>
    <string name="zen_sound_all_muted" msgid="4850363350480968114">"Vaigistatud"</string>
    <string name="zen_sound_none_muted" msgid="3938508512103612527">"Pole vaigistatud"</string>
    <string name="zen_sound_one_allowed" msgid="8447313454438932276">"Vaigistatud, kuid lubatakse <xliff:g id="SOUND_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_sound_two_allowed" msgid="980491120444358550">"Vaigistatud, kuid lubatakse <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g> ja <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_sound_three_allowed" msgid="3455767205934547985">"Vaigistatud, kuid lubatakse <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g>, <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g> ja <xliff:g id="SOUND_TYPE_2">%3$s</xliff:g>"</string>
    <string name="zen_custom_settings_dialog_title" msgid="3999383687283620283">"Kohandatud seaded"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="7056997717364939238">"Vaadake ajakava üle"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="5302885851078421866">"Selge"</string>
    <string name="zen_custom_settings_notifications_header" msgid="6931035609369698584">"Märguanded"</string>
    <string name="zen_custom_settings_duration_header" msgid="1190989278065507035">"Kestus"</string>
    <string name="zen_msg_event_reminder_title" msgid="5137894077488924820">"Sõnumid, sündmused ja meeldetuletused"</string>
    <string name="zen_msg_event_reminder_footer" msgid="4376930591019535192">"Kui funktsioon Mitte segada on sisse lülitatud, vaigistatakse sõnumid, meeldetuletused ja sündmused, välja arvatud teie ülal lubatud üksuste puhul. Võite sõnumite seadeid kohandada, et lubada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_onboarding_ok" msgid="6131211000824433013">"Valmis"</string>
    <string name="zen_onboarding_settings" msgid="9046451821239946868">"Seaded"</string>
    <string name="zen_onboarding_new_setting_title" msgid="1893095176110470711">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_onboarding_current_setting_title" msgid="776426065129609376">"Hääletud märguanded"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="6293026064871880706">"Te ei kuule ega näe märguandeid. Tärniga tähistatud kontaktidelt ja korduvatelt helistajatelt pärit kõned on lubatud."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="1280614488924843713">"(praegune seade)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="1352808651270918932">"Kas soovite režiimi Mitte segada märguandeseadeid muuta?"</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 värinad"</string>
    <string name="configure_notification_settings" msgid="7616737397127242615">"Märguanded"</string>
    <string name="recent_notifications" msgid="5660639387705060156">"Hiljuti saadetud"</string>
    <string name="recent_notifications_see_all_title" msgid="8572160812124540326">"Kuva kõik viimase 7 päeva kohta"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Täpsemad"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Töö märguanded"</string>
    <string name="smart_notifications_title" msgid="3702411478231865970">"Kohanduvad märguanded"</string>
    <string name="asst_capability_prioritizer_title" msgid="3854208223528908688">"Kohanduvate märguannete prioriteet"</string>
    <string name="asst_capability_prioritizer_summary" msgid="7553129095829077229">"Madalama prioriteediga märguanded määratakse automaatselt leebeteks märguanneteks"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="8621608733904251499">"Soovitatud toimingud ja vastused"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="2367828721274129806">"Kuva automaatselt soovitatud toimingud ja vastused"</string>
    <string name="snooze_options_title" msgid="7447722951050463793">"Märguannete edasilükkamise lubamine"</string>
    <string name="hide_silent_icons_title" msgid="3803036978493857276">"Leebete märguannete ikoonide peitmine"</string>
    <string name="hide_silent_icons_summary" msgid="8422819235336628802">"Leebete märguannete ikoone ei kuvata olekuribal"</string>
    <string name="notification_badging_title" msgid="5938709971403474078">"Luba märguandetäpid"</string>
    <string name="notification_bubbles_title" msgid="526545466417027926">"Mullid"</string>
    <string name="notification_bubbles_developer_setting_summary" msgid="5044678712656329427">"Teatud märguanded võidakse ekraanil kuvada mullidena"</string>
    <string name="bubbles_feature_education" msgid="69923617148394578">"Teatud märguanded ja muu sisu võidakse kuvada mullidena. Mulli avamiseks puudutage seda. Mulli eemaldamiseks lohistage seda ekraanil allapoole."</string>
    <string name="bubbles_app_toggle_title" msgid="9143702245165359360">"Mullid"</string>
    <string name="bubbles_app_toggle_summary" msgid="7714358008428342285">"Luba rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> kuvada teatud märguanded mullidena"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="8013961655723563787">"Mullide sisselülitamine"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="3616822820657195387">"Selles rakenduses mullide sisselülitamiseks peate need esmalt sisse lülitama oma seadmes. See mõjutab teisi rakendusi, milles olete mullid eelnevalt sisse lülitanud."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="5317196831268846883">"Lülita seadme puhul sisse"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8176870537170586852">"Tühista"</string>
    <string name="swipe_direction_title" msgid="6877543492435053137">"Pühkimistoimingud"</string>
    <string name="swipe_direction_ltr" msgid="3623394320915041215">"Loobumiseks pühkige paremale, menüü kuvamiseks vasakule"</string>
    <string name="swipe_direction_rtl" msgid="4972099509548044938">"Loobumiseks pühkige vasakule, menüü kuvamiseks paremale"</string>
    <string name="gentle_notifications_title" msgid="3976374971153475110">"Leebed märguanded"</string>
    <string name="gentle_notifications_also_display" msgid="6455360420411828133">"Kuva ka järgmises kohas:"</string>
    <string name="gentle_notifications_display_status" msgid="2904115658980383410">"Olekuriba"</string>
    <string name="gentle_notifications_display_lock" msgid="1395567209329239992">"Lukustuskuva"</string>
    <string name="gentle_notifications_education" msgid="8713358646047345762">"Leebed märguanded on alati vaiksed ja kuvatakse alati allatõmmatavas menüüs"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="6583107817329430916">"Kuva ainult allatõmmatavas menüüs"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="1434426811760016414">"Kuva allatõmmatavas menüüs ja lukustuskuval"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="6113566548809874319">"Kuva allatõmmatavas menüüs ja olekuribal"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="4222628772925544654">"Kuva allatõmmatavas menüüs, olekuribal ja lukustuskuval"</string>
    <string name="notification_pulse_title" msgid="1905382958860387030">"Vilkuv tuli"</string>
    <string name="lock_screen_notifications_title" msgid="7604704224172951090">"Lukustuskuva"</string>
    <string name="lockscreen_bypass_title" msgid="3077831331856929085">"Lukustuskuva vahelejätmine"</string>
    <string name="lockscreen_bypass_summary" msgid="2767475923650816867">"Pärast Face Unlocki kasutamist avaneb viimati vaadatud kuva"</string>
    <string name="keywords_lockscreen_bypass" msgid="250300001805572693">"Lukustuskuva, lukustuskuva, vahelejätmine, mittekasutamine"</string>
    <string name="locked_work_profile_notification_title" msgid="8327882003361551992">"Kui tööprofiil on lukustatud"</string>
    <string name="lock_screen_notifs_title" msgid="3812061224136552712">"Märguanded lukustuskuval"</string>
    <string name="lock_screen_notifs_show_all" msgid="5848645268278883539">"Kuva hoiatused ja hääletud märguanded"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="3085615237751195449">"Kuva ainult hoiatusmärguanded"</string>
    <string name="lock_screen_notifs_show_none" msgid="3357167536259901686">"Ära kuva märguandeid"</string>
    <string name="lock_screen_notifs_redact" msgid="3942294440983226225">"Tundlikud märguanded"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="3095153536179931941">"Kuva lukustatuna tundlik sisu"</string>
    <string name="lock_screen_notifs_redact_work" msgid="6777821963954035608">"Tööprofiili tundlikud märguanded"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="2179290697692276201">"Kuva lukustatuna tööprofiili tundlik sisu"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Kuva kogu märguande sisu"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="1133085507139112569">"Kuva tundlik sisu ainult avatuna"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Ära kuva märguandeid üldse"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="3143593517597479937">"Kuidas soovite lukustuskuva kuvada?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="709573564312902481">"Lukustuskuva"</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="2005907007779384635">"Peida tundlik töösisu"</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="notifications_title" msgid="8086372779371204971">"Märguanded"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Rakenduste märguanded"</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Märguannete kategooria"</string>
    <string name="notification_group_title" msgid="7180506440133859601">"Märguande kategooria grupp"</string>
    <string name="notification_importance_title" msgid="4368578960344731828">"Käitumine"</string>
    <string name="notification_importance_unspecified" msgid="6622173510486113958">"Heli lubamine"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Ära kunagi kuva märguandeid"</string>
    <string name="notification_importance_min" msgid="9054819132085066824">"Kuva vaikselt ja minimeeri"</string>
    <string name="notification_importance_low" msgid="2445139943005315690">"Kuva hääletult"</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_high_silent" msgid="2667033773703765252">"Tõsta märguanne esile"</string>
    <string name="notification_importance_min_title" msgid="5024538864029341539">"Minimeeri"</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="8792310396497954857">"Tõsta märguanne esile"</string>
    <string name="notification_block_title" msgid="1366361048463539674">"Blokeeri"</string>
    <string name="notification_silence_title" msgid="6986752165900591125">"Hääletu"</string>
    <string name="notification_alert_title" msgid="2267584776990348784">"Teavitamine"</string>
    <string name="allow_interruption" msgid="7136150018111848721">"Katkestuste lubamine"</string>
    <string name="allow_interruption_summary" msgid="7870159391333957050">"Rakendusel lubatakse heli esitada, vibreerida ja/või ekraanil hüpikmärguandeid kuvada"</string>
    <string name="notification_channel_summary_min" msgid="2965790706738495761">"Allatõmmatavas loendis ahendatakse märguanded ühele reale"</string>
    <string name="notification_channel_summary_low" msgid="7050068866167282765">"Aitab teil keskenduda (heli või vibreerimine puudub)"</string>
    <string name="notification_channel_summary_default" msgid="5753454293847059695">"Haarab heli või vibreerimisega teie tähelepanu"</string>
    <string name="notification_channel_summary_high" msgid="7737315941884569891">"Kui seade on avatud, kuvatakse märguanded bännerina ekraanikuva ülaosas"</string>
    <string name="notification_switch_label" msgid="6843075654538931025">"Kuva märguanded"</string>
    <string name="default_notification_assistant" msgid="8441022088918117445">"Kohanduvad märguanded"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="6049014219388148161">
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> märguannet päevas</item>
      <item quantity="one">~<xliff:g id="NUMBER_0">%d</xliff:g> märguanne päevas</item>
    </plurals>
    <plurals name="notifications_sent_weekly" formatted="false" msgid="5096638662520720959">
      <item quantity="other">~<xliff:g id="NUMBER_1">%d</xliff:g> märguannet nädalas</item>
      <item quantity="one">~<xliff:g id="NUMBER_0">%d</xliff:g> märguanne nädalas</item>
    </plurals>
    <string name="notifications_sent_never" msgid="1001964786456700536">"Mitte kunagi"</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="notification_assistant_title" msgid="7531256823396529700">"Kohanduvad märguanded"</string>
    <string name="no_notification_assistant" msgid="2818970196806227480">"Puudub"</string>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Ükski installitud rakendus pole taotlenud juurdepääsu märguannetele."</string>
    <string name="notification_assistant_security_warning_title" msgid="300600401595343861">"Kas lubada teenusel <xliff:g id="SERVICE">%1$s</xliff:g> märguannetele juurde pääseda?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="5829972610310154776">"<xliff:g id="NOTIFICATION_ASSISTANT_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 märguandeid muuta või nendest loobuda või aktiveerida märguannetes olevaid toimingunuppe. \n\nSee võimaldab rakendusel ka lülitada sisse või välja funktsiooni Mitte segada ja muuta sellega seotud seadeid."</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="1264019085827708920">"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_detail_switch" msgid="1188754646317450926">"Luba funktsioon Mitte segada"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Ükski installitud rakendus pole palunud juurdepääsu funktsioonile Mitte segada"</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Rakenduste laadimine ..."</string>
    <string name="app_notifications_off_desc" msgid="8289223211387083447">"Teie taotluse kohaselt blokeerib Android selle rakenduse märguannete kuvamise selles seadmes"</string>
    <string name="channel_notifications_off_desc" msgid="9013011134681491778">"Teie taotluse kohaselt blokeerib Android selle märguandekategooria kuvamise selles seadmes"</string>
    <string name="channel_group_notifications_off_desc" msgid="2315252834146837470">"Teie taotluse kohaselt blokeerib Android selle märguandegrupi kuvamise selles seadmes"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Kategooriad"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Muu"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="3420621520561455358">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategooriat</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategooria</item>
    </plurals>
    <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="8046168435207424440">"Sisse lülitatud kõigi rakenduste jaoks"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="6709582776823665660">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> rakenduse jaoks välja lülitatud</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> rakenduse jaoks välja lülitatud</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>
    <string name="notification_badge_title" msgid="6370122441168519809">"Luba märguandetäpp"</string>
    <string name="notification_channel_badge_title" msgid="2240827899882847087">"Kuva märguandetäpp"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Funktsiooni Mitte segada alistamine"</string>
    <string name="app_notification_override_dnd_summary" msgid="2612502099373472686">"Nendel märguannetel lubatakse teid jätkuvalt katkestada, kui funktsioon Mitte segada on sisse lülitatud"</string>
    <string name="app_notification_visibility_override_title" msgid="3618860781666494595">"Lukustuskuva"</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="5607736317244760638">"Ajakava nimi"</string>
    <string name="zen_mode_rule_name_hint" msgid="278109122579468433">"Sisestage ajakava nimi"</string>
    <string name="zen_mode_rule_name_warning" msgid="3856485373110366912">"Ajakava nimi on juba kasutuses"</string>
    <string name="zen_mode_add_rule" msgid="7459154136384467057">"Lisa veel"</string>
    <string name="zen_mode_add_event_rule" msgid="4454759739839069898">"Sündmuse ajakava lisamine"</string>
    <string name="zen_mode_add_time_rule" msgid="7890557350868257760">"Ajakava lisamine"</string>
    <string name="zen_mode_delete_rule" msgid="8055032645990309096">"Kustuta ajakava"</string>
    <string name="zen_mode_choose_rule_type" msgid="40993242338494595">"Valige ajakava tüüp"</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_unknown" msgid="3049377282766700600">"Teadmata"</string>
    <string name="zen_mode_app_set_behavior" msgid="1534429320064381355">"Neid seadeid ei saa praegu muuta. Rakendus (<xliff:g id="APP_NAME">%1$s</xliff:g>) on funktsiooni Mitte segada koos kohandatud käitumisega automaatselt sisse lülitanud."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="2558968232814237874">"Neid seadeid ei saa praegu muuta. Rakendus on funktsiooni Mitte segada koos kohandatud käitumisega automaatselt sisse lülitanud."</string>
    <string name="zen_mode_qs_set_behavior" msgid="6200424436456086312">"Neid seadeid ei saa praegu muuta. Funktsioon Mitte segada koos kohandatud käitumisega lülitati käsitsi sisse."</string>
    <string name="zen_schedule_rule_type_name" msgid="6163149826036287324">"Aeg"</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="6503468472212606158">"Sündmus"</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 alistab lõppaja"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="1673667979187593693">"Ajakava lülitub alarmi kõlamisel välja"</string>
    <string name="zen_mode_custom_behavior_title" msgid="1148856394866360783">"Funktsiooni Mitte segada käitumine"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="7750128187766412708">"Kasuta vaikeseadeid"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="7458258833216726120">"Sellele ajakavale kohandatud seadete määramine"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="4070854282812755247">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” jaoks"</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="4769117032399813012">"Luba kõned"</string>
    <string name="zen_mode_calls_title" msgid="2905770092665685857">"Kõned"</string>
    <string name="zen_mode_calls_footer" msgid="2002070641802102110">"Selleks et lubatud kõnede puhul telefon heliseks, kontrollige, kas seadmes on aktiveeritud helisemis-, vibreerimis- või vaikne režiim."</string>
    <string name="zen_mode_custom_calls_footer" msgid="4764756801941329281">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” puhul on sissetulevad kõned blokeeritud. Võite seadeid kohandada, et võimaldada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_mode_starred_contacts_title" msgid="1848464279786960190">"Tärniga tähistatud kontaktid"</string>
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts" formatted="false" msgid="500105380255018671">
      <item quantity="other">Veel <xliff:g id="NUM_PEOPLE">%d</xliff:g> inimest</item>
      <item quantity="one">Veel 1 inimene</item>
    </plurals>
    <string name="zen_mode_messages" msgid="6406892731721926170">"Luba sõnumid"</string>
    <string name="zen_mode_messages_footer" msgid="2616568463646674149">"Selleks et lubatud sõnumite puhul telefon heliseks, kontrollige, kas seadmes on aktiveeritud helisemis-, vibreerimis- või vaikne režiim."</string>
    <string name="zen_mode_custom_messages_footer" msgid="800067279796770040">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” puhul on sissetulevad sõnumid blokeeritud Võite seadeid kohandada, et võimaldada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_mode_messages_title" msgid="7325983674655986445">"SMS-, MMS- ja sõnumsiderakendused"</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_calls_summary_starred_repeat" msgid="4046151920710059778">"Tärniga tähistatud kontaktidelt ja korduvatelt helistajatelt"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="1528716671301999084">"Kontaktidelt ja korduvatelt helistajatelt"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7105261473107715445">"Ainult korduvatelt helistajatelt"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Mitte kelleltki"</string>
    <string name="zen_mode_from_none_calls" msgid="7705112158761351044">"Ära luba kõnesid"</string>
    <string name="zen_mode_from_none_messages" msgid="3300937656725582608">"Ära luba ühtki sõnumit"</string>
    <string name="zen_mode_alarms" msgid="6510378757005935647">"Luba märguanded"</string>
    <string name="zen_mode_alarms_list" msgid="1090332840207025714">"äratused"</string>
    <string name="zen_mode_media" msgid="4529187475698084320">"Esita meedia helisid"</string>
    <string name="zen_mode_media_list" msgid="5483540766397328038">"meedia"</string>
    <string name="zen_mode_system" msgid="236278770843463810">"Luba puutehelid"</string>
    <string name="zen_mode_system_list" msgid="6996104733185177115">"puutehelid"</string>
    <string name="zen_mode_reminders" msgid="5445657061499098675">"Luba meeldetuletused"</string>
    <string name="zen_mode_reminders_list" msgid="2853975802240340190">"meeldetuletused"</string>
    <string name="zen_mode_events" msgid="6154853744271591007">"Luba sündmused"</string>
    <string name="zen_mode_bypassing_apps" msgid="5493729796981237881">"Luba rakendustel alistada"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="2072590348079644482">"Rakenduse erandid"</string>
    <plurals name="zen_mode_bypassing_apps_subtext" formatted="false" msgid="3726913165356014788">
      <item quantity="other"><xliff:g id="NUMBER">%1$d</xliff:g> rakendust saab alistada režiimi Mitte segada</item>
      <item quantity="one">1 rakendus saab alistada režiimi Mitte segada</item>
    </plurals>
    <string name="zen_mode_events_list" msgid="5571368229052715098">"sündmused"</string>
    <string name="zen_mode_all_callers" msgid="2378065871253871057">"igaüks"</string>
    <string name="zen_mode_contacts_callers" msgid="5569804103920394175">"kontaktid"</string>
    <string name="zen_mode_starred_callers" msgid="1023167821338514140">"tärniga tähistatud kontaktidelt"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Korduvad helistajad"</string>
    <string name="zen_mode_repeat_callers_list" msgid="2529895519653237330">"korduvatelt helistajatelt"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8553876328249671783">"Luba korduvad helistajad"</string>
    <string name="zen_mode_calls_summary_one" msgid="1711737896388108388">"Luba <xliff:g id="CALLER_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_mode_calls_summary_two" msgid="8476861928783654064">"Luba <xliff:g id="CALLER_TYPE">%1$s</xliff:g> ja <xliff:g id="CALLERT_TPYE">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="239685342222975733">"Kui sama inimene helistab teile <xliff:g id="MINUTES">%d</xliff:g> minuti jooksul teist korda"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="168127313238020146">"Kohandatud"</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="8774571998575673502">"Kui ekraan on sees"</string>
    <string name="zen_mode_screen_on_summary" msgid="2208664848367443505">"Lubatakse märguannetel, mille funktsioon Mitte segada on vaigistanud, ekraanil hüpikaknaid näidata ja olekuriba ikoon kuvada"</string>
    <string name="zen_mode_screen_off" msgid="3144446765110327937">"Kui ekraan on väljas"</string>
    <string name="zen_mode_screen_off_summary" msgid="7430034620565812258">"Luba märguannetel, mille funktsioon Mitte segada on vaigistanud, ekraan sisse lülitada ja valgust vilgutada"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="2826121465026642017">"Luba märguannetel, mille funktsioon Mitte segada on vaigistanud, ekraan sisse lülitada"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Märguandeseaded"</string>
    <string name="suggestion_button_text" msgid="3275010948381252006">"OK"</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="1110847562111827766">"Kui seade on sees, saab ekraanikuva kinnitada. Nii jääb kuva avatuks, kuni selle vabastate.\n\nEkraanikuva kinnitamiseks tehke järgmist.\n\n1. Veenduge, et ekraanikuva kinnitamine oleks sisse lülitatud.\n\n2. Avage kuva Ülevaade.\n\n3. Puudutage ekraanikuva ülaosas rakenduse ikooni ja siis käsku Kinnita."</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_message_pin_for_face" msgid="2017438765366716760">"Lisaks sellele, et võite seadme avamiseks kasutada oma nägu, saate oma seadet veelgi paremini kaitsta, nõudes käivitamisel PIN-koodi. 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 PIN-koodi?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="3551827507967661552">"Lisaks sellele, et võite seadme avamiseks kasutada oma nägu, saate oma seadet veelgi paremini kaitsta, nõudes käivitamisel mustrit. 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 mustrit?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3452793542112093614">"Lisaks sellele, et võite seadme avamiseks kasutada oma nägu, 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="restricted_true_label" msgid="4761453839409220473">"Piiratud"</string>
    <string name="restricted_false_label" msgid="3279282180297058755">"Rakendus saab taustal akut kasutada"</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="2433632805847985867">"Märkus. Kui telefoni taaskäivitate ja määratud on ekraanilukk, 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">"<xliff:g id="SIZE">%1$s</xliff:g> kasutusel (<xliff:g id="STORAGE_TYPE">%2$s</xliff:g>)"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Sisemine salvestusruum"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Väline salvestusruum"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"<xliff:g id="SIZE">%1$s</xliff:g> kasut. alates <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Kasutatud salvestusruum"</string>
    <string name="change" msgid="6657848623929839991">"Muuda"</string>
    <string name="change_storage" msgid="600475265207060436">"Salvestusruumi muutmine"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Märguanded"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Sees"</string>
    <string name="notifications_enabled_with_info" msgid="5669544704839269901">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="1262114548434938079">"Väljas"</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="notifications_categories_off" formatted="false" msgid="5583365573683409754">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategooriat on välja lülitatud</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kategooria on välja lülitatud</item>
    </plurals>
    <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="3383043508771300704">"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="5584182129908141622">"Lubade haldur"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Rakendused, mis kasutavad: <xliff:g id="APPS">%1$s</xliff:g>"</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="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="time_spent_in_app_pref_title" msgid="9124796405314626532">"Ekraaniaeg"</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 rakenduste kasutusteave"</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>
    <plurals name="power_high_usage_title" formatted="false" msgid="3826660033363082922">
      <item quantity="other">Rakendused kulutavad akut</item>
      <item quantity="one"><xliff:g id="APP">%1$s</xliff:g> kulutab akut</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="4800495064747543954">"Andmeedastus puudub"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Selle seadme laadimine"</string>
    <string name="usb_use_power_only" msgid="3236391691786786070">"Ühendatud seadme laadimine"</string>
    <string name="usb_use_file_transfers" msgid="1223134119354320726">"Failiedastus"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Failide edastamine teise seadmesse"</string>
    <string name="usb_use_photo_transfers" msgid="8192719651229326283">"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_tethering" msgid="3944506882789422118">"USB kaudu jagamine"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Kasutage seda seadet MIDI-na"</string>
    <string name="usb_use" msgid="3372728031108932425">"USB kasutusviis"</string>
    <string name="usb_default_label" msgid="2211094045594574774">"USB-vaikeseadistus"</string>
    <string name="usb_default_info" msgid="8864535445796200695">"Kui teine seade on ühendatud ja teie telefon avatakse, rakendatakse need seaded. Looge ühendus ainult usaldusväärsete seadmetega."</string>
    <string name="usb_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_preference" msgid="7394265019817945275">"USB eelistused"</string>
    <string name="usb_control_title" msgid="4404322722995917160">"USB-liidest juhib"</string>
    <string name="usb_control_host" msgid="2276710819046647200">"Ühendatud seade"</string>
    <string name="usb_control_device" msgid="5821511964163469463">"See seade"</string>
    <string name="usb_switching" msgid="8995313698715545619">"Vahetamine …"</string>
    <string name="usb_switching_failed" msgid="4156073015692409651">"Ei õnnestunud vahetada"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Selle seadme laadimine"</string>
    <string name="usb_summary_power_only" msgid="1996391096369798526">"Ühendatud seadme laadimine"</string>
    <string name="usb_summary_file_transfers" msgid="6925168380589489645">"Failiedastus"</string>
    <string name="usb_summary_tether" msgid="951190049557074535">"USB kaudu jagamine"</string>
    <string name="usb_summary_photo_transfers" msgid="665584667685030007">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2399066753961085360">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="7700800611455849806">"Failiedastus ja toide"</string>
    <string name="usb_summary_tether_power" msgid="5825335393952752238">"USB kaudu jagamine ja toide"</string>
    <string name="usb_summary_photo_transfers_power" msgid="6826058111908423069">"PTP ja toide"</string>
    <string name="usb_summary_MIDI_power" msgid="3308250484012677596">"MIDI ja toide"</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">"Andmesidet pole kasutatud"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"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="3549930955839111652">"Aku võib kiiremini tühjeneda. Rakendusel on nüüd lubatud taustal akut kasutada."</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="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="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="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="permit_write_settings" msgid="658555006453212691">"Luba süsteemiseadete muutmine"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"Luba võimaldab rakendusel muuta süsteemiseadeid."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Jah"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Ei"</string>
    <string name="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="keyboard_disconnected" msgid="1495037256967224035">"Ühendus puudub"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"Kasutatud andmemaht on <xliff:g id="AMOUNT">%1$s</xliff:g>"</string>
    <string name="data_usage_wifi_format" msgid="5417296451392612860">"WiFi kaudu on kasutatud <xliff:g id="AMOUNT">^1</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_dashboard_summary_with_style" msgid="870920274423314524">"Stiilid, taustapildid, ekraani ajalõpp, fondi suurus"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="7840559323355210111">"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_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="backup_disabled" msgid="485189128759595412">"Varundamine on keelatud"</string>
    <string name="android_version_summary" msgid="2935995161657697278">"Android värskendati versioonile <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="487831391976523090">"Värskendus on saadaval"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Keelatud toiming"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="3208724801293696486">"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="disabled_by_policy_title_suspend_packages" msgid="7872038990805477554">"Seda rakendust ei saa avada"</string>
    <string name="default_admin_support_msg" msgid="4489678214035485367">"Küsimuste korral võtke ühendust IT-administraatoriga"</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="5959815393203320845">"Kuumkoht on aktiivne"</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Lennurežiim on sees"</string>
    <string name="condition_airplane_summary" msgid="2500054042183138980">"Võrgud pole saadaval"</string>
    <string name="condition_zen_title" msgid="2897779738211625">"Režiim Mitte segada on sees"</string>
    <string name="condition_zen_summary_phone_muted" msgid="3644614024467141806">"Telefon on vaigistatud"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="4047564276599301064">"Eranditega"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Akusäästja on sisse lülitatud"</string>
    <string name="condition_battery_summary" msgid="5847532902924566572">"Funktsioonid on piiratud"</string>
    <string name="condition_cellular_title" msgid="1327317003797575735">"Mobiilne andmeside on väljas"</string>
    <string name="condition_cellular_summary" msgid="816822977403022625">"Internet on saadaval ainult WiFi kaudu"</string>
    <string name="condition_bg_data_title" msgid="5475793236997935138">"Andmemahu säästja"</string>
    <string name="condition_bg_data_summary" msgid="1852811387315557164">"Funktsioonid on piiratud"</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Tööprofiil on välja lülitatud"</string>
    <string name="condition_work_summary" msgid="9167580982244020746">"Rakenduste ja märguannete puhul"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4930240942726349213">"Lülita heli sisse"</string>
    <string name="condition_device_muted_title" msgid="3476439379918599716">"Telefonihelin on vaigistatud"</string>
    <string name="condition_device_muted_summary" msgid="6313274406443663781">"Kõnede ja märguannete puhul"</string>
    <string name="condition_device_vibrate_title" msgid="8070177546359590131">"Ainult vibreerimine"</string>
    <string name="condition_device_vibrate_summary" msgid="5743200564646910423">"Kõnede ja märguannete puhul"</string>
    <string name="night_display_suggestion_title" msgid="6602129097059325291">"Öövalguse ajakava määramine"</string>
    <string name="night_display_suggestion_summary" msgid="228346372178218442">"Ekraani toon muutub igal õhtul automaatselt"</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"Öövalgus on sees"</string>
    <string name="condition_night_display_summary" msgid="7150932917610919907">"Kollase tooniga ekraanikuva"</string>
    <string name="condition_grayscale_title" msgid="3426050703427823519">"Halltoonid"</string>
    <string name="condition_grayscale_summary" msgid="7652835784223724625">"Ainult halli värviga kuvamine"</string>
    <string name="homepage_condition_footer_content_description" msgid="2335918927419018030">"Ahenda"</string>
    <string name="suggestions_title_v2" msgid="5601181602924147569">"Teile soovitatud"</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="suggestions_more_title" msgid="8223690393059519879">"Ja veel <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="1857433444865249823">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> soovitust</item>
      <item quantity="one">1 soovitus</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="7680263825371165461">
      <item quantity="other">Ja veel <xliff:g id="COUNT">%1$d</xliff:g> soovitust</item>
      <item quantity="one">Ja veel 1 soovitus</item>
    </plurals>
    <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="camera_laser_sensor_switch" msgid="8913588990743234440">"Kaamera laserandur"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Automaatsed süsteemivärskendused"</string>
    <string name="ota_disable_automatic_update_summary" msgid="940729694354373087">"Rakenda värskendused seadme taaskäivitamisel"</string>
    <string name="usage" msgid="2977875522080448986">"Kasutus"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Mobiilse andmeside kasutus"</string>
    <string name="app_cellular_data_usage" msgid="5468472735806533448">"Rakenduste andmekasutus"</string>
    <string name="wifi_data_usage" msgid="771603760674507659">"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="billing_cycle" msgid="6614597736285325497">"Andmekasutuse hoiatus ja piirang"</string>
    <string name="app_usage_cycle" msgid="8877223251648092131">"Rakenduse andmekasutuse tsükkel"</string>
    <string name="cell_data_warning" msgid="1985956818884847057">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu hoiatus"</string>
    <string name="cell_data_limit" msgid="1578367585799358854">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu piirang"</string>
    <string name="cell_data_warning_and_limit" msgid="6888825370687743208">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu hoiatus / <xliff:g id="ID_2">^2</xliff:g> – andmemahu piirang"</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="data_warning_footnote" msgid="776341964125603711">"Andmemahu hoiatuse ja piirangu mõõdikut jälgib teie seade. See võib erineda teie operaatori andmetest."</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="2923744765873163859">"Vahemikus <xliff:g id="ID_2">%2$s</xliff:g> on kasutatud <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="configure" msgid="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 andmemahu säästja on sisse lülitatud</item>
      <item quantity="one">1 rakendusel on lubatud kasutada piiranguteta andmemahtu, kui andmemahu säästja on sisse lülitatud</item>
    </plurals>
    <string name="data_usage_title" msgid="3659356290392241789">"Peamine andmeside"</string>
    <string name="data_usage_wifi_title" msgid="7063659423081820720">"WiFi-andmeside"</string>
    <string name="data_used" msgid="5116389957228457203">"<xliff:g id="ID_1">^1</xliff:g> on kasutatud"</string>
    <string name="data_used_formatted" msgid="2989129931961311051">"Kasutatud on <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="1134445012475270295">"<xliff:g id="ID_1">^1</xliff:g> üle"</string>
    <string name="data_remaining" msgid="8998091725895502181">"Jäänud on <xliff:g id="ID_1">^1</xliff:g>"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="456503215317213651">
      <item quantity="other">%d päeva jäänud</item>
      <item quantity="one">%d päev jäänud</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="5892754995098583472">"Rohkem aega pole jäänud"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="825838050296069404">"Jäänud on vähem kui üks päev"</string>
    <string name="carrier_and_update_text" msgid="7963409972475063897">"Operaator <xliff:g id="ID_1">^1</xliff:g> värskendas <xliff:g id="ID_2">^2</xliff:g> tagasi"</string>
    <string name="no_carrier_update_text" msgid="3277403390316201982">"Värskendati <xliff:g id="ID_1">^2</xliff:g> tagasi"</string>
    <string name="carrier_and_update_now_text" msgid="4057997726060106722">"Operaator <xliff:g id="ID_1">^1</xliff:g> värskendas äsja"</string>
    <string name="no_carrier_update_now_text" msgid="1766859656868932996">"Värskendati äsja"</string>
    <string name="launch_mdp_app_text" msgid="6751296320061773169">"Kuva pakett"</string>
    <string name="launch_wifi_text" msgid="2311424914664372687">"Kuva üksikasjad"</string>
    <string name="data_saver_title" msgid="8034286939200289826">"Andmemahu säästja"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Piiramata andmeside"</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="data_saver_switch_title" msgid="836312690356005669">"Andmemahu säästja kasutamine"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Piiranguteta andmekasutus"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Luba piiranguteta juurdepääs andmesidele, kui andmemahu säästja on sisse lülitatud"</string>
    <string name="home_app" msgid="4066188520886810030">"Avakuva rakendus"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Vaike-avakuva 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="7722791295871319534">"Sees"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="3953785517002197881">"Lülitub sisse <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> juures"</string>
    <string name="battery_saver_off_summary" msgid="784360321235698247">"Väljas"</string>
    <string name="battery_saver_button_turn_on" msgid="3699954061337848832">"Lülita kohe sisse"</string>
    <string name="battery_saver_button_turn_off" msgid="5916996792004611890">"Lülita kohe välja"</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_master_switch_title" msgid="8763132750954344372">"Kasuta õigekirjakontrolli"</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_alerted" msgid="6622944771989529320">"märguandest teavitati"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"heli"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"vibreerimine"</string>
    <string name="notification_log_details_vibrate_pattern" msgid="6076984056201975221">"muster"</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="theme_customization_device_default" msgid="5058147707906551368">"Seadme vaikeseade"</string>
    <string name="display_cutout_emulation" msgid="7466869822418376317">"Ekraani väljalõige"</string>
    <string name="display_cutout_emulation_keywords" msgid="4495418317471622562">"ekraani väljalõige, lõige"</string>
    <string name="overlay_option_device_default" msgid="294510212512203638">"Seadme vaikeseade"</string>
    <string name="overlay_toast_failed_to_apply" msgid="3506731619973103346">"Ülekatet ei õnnestunud rakendada"</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="special_access_more" msgid="6927066457969301921">"Kuva rohkem"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Kas soovite tõesti kasutaja andmed kustutada ja teisendada failide krüpteerimisele?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Kustuta ja teisenda"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Teenuse ShortcutManager sageduse piiramise lähtestamine"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Teenuse ShortcutManager sageduse piiramine lähtestati"</string>
    <string name="notification_suggestion_title" msgid="387052719462473500">"Kontrollige lukustuskuva teavet"</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="4407600495101788249">"Nõuanded ja 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="6244000672828617410">"Väljas"</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="dark_ui_mode" msgid="6795784845192720944">"Tume teema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="5141126532745008289">"Sees / akusäästja tõttu ajutiselt keelatud"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4619248181769223081">"Akusäästja tõttu ajutiselt sisse lülitatud"</string>
    <string name="dark_ui_settings_dark_summary" msgid="8205234847639399279">"Toetatud rakendused aktiveerivad samuti tumeda teema"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="8683868642329596059">"Selge"</string>
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Arendaja kiirseadete paanid"</string>
    <string name="winscope_trace_quick_settings_title" msgid="1294290008255732032">"Winscope Trace"</string>
    <string name="sensors_off_quick_settings_title" msgid="1487323753632515801">"Andurid on väljas"</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>
    <string name="cross_profile_calendar_title" msgid="4414835261437899531">"Profiilideülene kalender"</string>
    <string name="cross_profile_calendar_summary" msgid="8139424817135929870">"Kuvab tööga seotud sündmused isiklikus kalendris"</string>
    <string name="cross_profile_calendar_restricted_summary" msgid="295371538704418613">"Teie organisatsioon ei luba isiklikel rakendustel töökalendrile juurde pääseda"</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="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="automatic_storage_manager_master_switch_title" msgid="6792996736190821417">"Kasuta salvestusruumi haldurit"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automaatne"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Käsitsi"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Vabastage ruumi"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Liigutused"</string>
    <string name="gesture_preference_summary" 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 igast kuvast."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="6500405261202883589">"Kaamera kiiresti avamine"</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="double_twist_for_camera_suggestion_title" msgid="4689410222517954869">"Selfide kiiremini jäädvustamine"</string>
    <string name="system_navigation_title" msgid="6797710220442338366">"Süsteemis navigeerimine"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="7381617686249459562">"Kahe nupuga navigeerimine"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="2158312695920408870">"Rakenduste vahetamiseks pühkige avakuva nupul üles. Kõigi rakenduste nägemiseks pühkige uuesti üles. Tagasiliikumiseks puudutage nuppu Tagasi."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="1465200107913259595">"Proovige uut avakuva nuppu"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="4825314186907812743">"Rakenduste vahetamiseks lülitage sisse uus liigutus"</string>
    <string name="edge_to_edge_navigation_title" msgid="4889073348091667667">"Liigutustega navigeerimine"</string>
    <string name="edge_to_edge_navigation_summary" msgid="511639046551586471">"Avakuvale liikumiseks pühkige ekraani allosast üles. Rakenduste vahetamiseks pühkige allosast üles, hoidke ja seejärel tõstke sõrm üles. Tagasiliikumiseks pühkige ekraani vasakust või paremast servast."</string>
    <string name="legacy_navigation_title" msgid="2635061924638361565">"Kolme nupuga navigeerimine"</string>
    <string name="legacy_navigation_summary" msgid="5631274479304544610">"Liikuge tagasi või avakuvale ja vahetage rakendusi oma ekraani allosas olevate nuppude abil."</string>
    <string name="keywords_system_navigation" msgid="5825645072714635357">"süsteemis navigeerimine, kahe nupuga navigeerimine, kolme nupuga navigeerimine, liigutustega navigeerimine"</string>
    <string name="gesture_not_supported_dialog_message" msgid="4315436164949864999">"Teie avakuva vaikerakendus <xliff:g id="DEFAULT_HOME_APP">%s</xliff:g> ei toeta"</string>
    <string name="gesture_not_supported_positive_button" msgid="8233003373902032396">"Lülitu avakuva vaikerakendusele"</string>
    <string name="information_label" msgid="8133109685432913360">"Teave"</string>
    <string name="low_label" msgid="1679136861385616813">"Väike"</string>
    <string name="high_label" msgid="7278863493316447831">"Suur"</string>
    <string name="back_sensitivity_dialog_message" msgid="1742132397253621623">\n"Suurem tundlikkus võib ekraani servades mõne rakenduse liigutusega vastuolus olla."</string>
    <string name="back_sensitivity_dialog_title" msgid="5403946345652118253">"Tagasiliigutuse tundlikkus"</string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Telefoni kontrollimiseks topeltpuudutamine"</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="8534654210539169707">"Kellaaja, märguannete ja muu teabe vaatamiseks topeltpuudutage oma 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_wake_screen_title" msgid="4091523525326925790">"Ekraani äratamine"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="3436302177038243869">"Kellaaja, märguannete ja muu teabe vaatamiseks võtke telefon kätte."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="4938504160398665156">"Kellaaja, märguannete ja muu teabe vaatamiseks võtke tahvelarvuti kätte."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="4264958533375250254">"Kellaaja, märguannete ja muu teabe vaatamiseks võtke seade kätte."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="5458679563086979424">"Puudutamine telefoni kontrollimiseks"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="9108878716863882877">"Puudutamine tahvelarvuti kontrollimiseks"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="7071150656699666085">"Puudutamine seadme kontrollimiseks"</string>
    <string name="ambient_display_tap_screen_summary" msgid="8862155601920379979">"Kellaaja, märguannete ja muu teabe vaatamiseks puudutage oma ekraani."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Sõrmejälje pühkimine märguannete vaatamiseks"</string>
    <string name="fingerprint_gesture_screen_title" msgid="8562169633234041196">"Sõrmejälje pühkimine"</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="fingerprint_swipe_for_notifications_suggestion_title" msgid="1677291167470357802">"Kiiresti märguannete vaatamine"</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="3361344735430813695">"Looge esmalt Interneti-ühendus"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="2479038689567925511">"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="oem_lock_info_message" msgid="9218313722236417510">"Seadme kaitsefunktsiooni lubamiseks taaskäivitage seade."</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_settings" msgid="8827777916518348213">"Installimata avatavate rakenduste eelistused"</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="account_sync_summary_some_on" msgid="3375930757891381175">"Sünkroonimine on sisse lülitatud <xliff:g id="ID_1">%1$d</xliff:g> üksuse jaoks <xliff:g id="ID_2">%2$d</xliff:g>-st"</string>
    <string name="account_sync_summary_all_on" msgid="570431636622254156">"Sünkroonimine on kõigi üksuste jaoks sisse lülitatud"</string>
    <string name="account_sync_summary_all_off" msgid="8782409931761182734">"Sünkroonimine on kõigi üksuste jaoks välja lülitatud"</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_device" msgid="2019652712782510262">"Usaldusväärsed mandaadid"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="2279084820904076599">"Usaldusväärsed mandaadid teie isiklikul profiilil"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="6187377647815301809">"Usaldusväärsed mandaadid teie tööprofiilil"</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="learn_more" msgid="2623878455042103404">"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="3395208658399637645">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></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="launch_instant_app" msgid="391581144859010499">"Ava"</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="debug_autofill_category" msgid="8050326960545979035">"Automaattäide"</string>
    <string name="autofill_logging_level_title" msgid="899483289251346778">"Logimistase"</string>
    <string name="autofill_max_partitions" msgid="7590272120101271461">"Max taotluste arv seansi kohta"</string>
    <string name="autofill_max_visible_datasets" msgid="4531033613378881109">"Max nähtavate andmekomplektide arv"</string>
    <string name="autofill_reset_developer_options" msgid="5819016237049525099">"Vaikeväärtustele lähtestamine"</string>
    <string name="autofill_reset_developer_options_complete" msgid="7548288932341619412">"Arendaja automaattäite valikud on lähtestatud"</string>
    <string name="device_theme" msgid="4571803018917608588">"Seadme teema"</string>
    <string name="default_theme" msgid="7085644992078579076">"Vaikeseade"</string>
    <string name="show_operator_name_title" msgid="805135053530442951">"Võrgu nimi"</string>
    <string name="show_operator_name_summary" msgid="5962567590205757550">"Võrgu nimi kuvatakse olekuribal"</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>
    <string name="zen_suggestion_title" msgid="798067603460192693">"Värskendage režiimi Mitte segada"</string>
    <string name="zen_suggestion_summary" msgid="5928686804697233014">"Keskendumiseks peatage märguanded"</string>
    <string name="disabled_low_ram_device" msgid="3751578499721173344">"Sellel seadmel pole see funktsioon saadaval"</string>
    <string name="disabled_feature" msgid="3232554901854971743">"Funktsioon pole saadaval"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="3557117039415422481">"See funktsioon on välja lülitatud, kuna see muudab teie telefoni aeglaseks"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1294470289520660584">"Jõusta GNSS-i täielikud mõõtmistulemused"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="496344699046454200">"Jälgi kõiki GNSS-i radu ja sagedusi ilma töötsüklita"</string>
    <string name="show_first_crash_dialog" msgid="8889957119867262599">"Kuva alati kokkujooksmise dialoog"</string>
    <string name="show_first_crash_dialog_summary" msgid="703224456285060428">"Dialoog kuvatakse alati, kui rakendus kokku jookseb"</string>
    <string name="angle_enabled_app" msgid="1841862539745838255">"Valige rakendus, milles ANGLE on lubatud"</string>
    <string name="angle_enabled_app_not_set" msgid="864740024581634768">"Seadistatud pole ühtegi rakendust, milles ANGLE on lubatud"</string>
    <string name="angle_enabled_app_set" msgid="226015765615525056">"Rakendus, milles ANGLE on lubatud: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="game_driver_dashboard_title" msgid="8804074441354504919">"Mängudraiveri eelistused"</string>
    <string name="game_driver_dashboard_summary" msgid="2392113100578771289">"Mängudraiveri seadete muutmine"</string>
    <string name="game_driver_footer_text" msgid="3202576403048267763">"Kui mängudraiver on sisse lülitatud, saate seadmesse installitud rakenduste puhul soovi korral kasutada värskendatud graafikadraiverit"</string>
    <string name="game_driver_all_apps_preference_title" msgid="6067527642706295180">"Luba kõigi rakenduste puhul"</string>
    <string name="game_driver_app_preference_title" msgid="5072626013346650374">"Graafikadraiveri valimine"</string>
    <string name="game_driver_app_preference_default" msgid="7686384740483216333">"Vaikeseade"</string>
    <string name="game_driver_app_preference_game_driver" msgid="6426312331295324606">"Mängudraiver"</string>
    <string name="game_driver_app_preference_prerelease_driver" msgid="1295460693830677733">"Draiveri eelväljalase"</string>
    <string name="game_driver_app_preference_system" msgid="8272672982113332753">"Süsteemi graafikadraiver"</string>
    <!-- no translation found for game_driver_all_apps_preference_values:0 (7193648562434970105) -->
    <!-- no translation found for game_driver_all_apps_preference_values:1 (7189663725490629463) -->
    <!-- no translation found for game_driver_app_preference_values:0 (4271044622117073985) -->
    <!-- no translation found for game_driver_app_preference_values:1 (6628516810440406199) -->
    <!-- no translation found for game_driver_app_preference_values:2 (1760397725970916076) -->
    <string name="unsupported_setting_summary" product="default" msgid="11246953620654225">"Seadet selles telefonis ei toetata"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="6328431665635673717">"Seadet selles tahvelarvutis ei toetata"</string>
    <string name="unsupported_setting_summary" product="device" msgid="2348970994972110886">"Seadet selles seadmes ei toetata"</string>
    <string name="disabled_for_user_setting_summary" msgid="3388525317680711262">"Praegune kasutaja ei saa seadet muuta"</string>
    <string name="disabled_dependent_setting_summary" msgid="8291322239940946902">"Oleneb teisest seadest"</string>
    <string name="unknown_unavailability_setting_summary" msgid="4589584678033059435">"Seade pole saadaval"</string>
    <string name="my_device_info_account_preference_title" msgid="342933638925781861">"Konto"</string>
    <string name="my_device_info_device_name_preference_title" msgid="7104085224684165324">"Seadme nimi"</string>
    <string name="change_wifi_state_title" msgid="3261945855372885427">"WiFi-seadete juhtimine"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="7942268646980694224">"Lubage rakendusel WiFi-seadeid juhtida"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8434262633905502679">"Lubage sellel rakendusel WiFi sisse või välja lülitada, otsida WiFi-võrke ja nendega ühendus luua, võrke lisada või eemaldada või luua kohalik kuumkoht"</string>
    <string name="media_output_title" msgid="115223550977351699">"Esita meedia seadmes"</string>
    <string name="media_output_default_summary" msgid="8115153381240348279">"See seade"</string>
    <string name="media_output_summary" product="default" msgid="6839458453831567167">"Telefon"</string>
    <string name="media_output_summary" product="tablet" msgid="7217221078578554515">"Tahvelarvuti"</string>
    <string name="media_output_summary" product="device" msgid="5677420090811068649">"Seade"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="3533731701018680693">"Pole kõnede ajal saadaval"</string>
    <string name="media_output_summary_unavailable" msgid="7970304720507697019">"Pole saadaval"</string>
    <string name="take_call_on_title" msgid="6066362463436122655">"Vasta kõnele seadmes"</string>
    <string name="cannot_change_apn_toast" msgid="4652498125702594916">"Seda APN-i ei saa muuta."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="752439050748267917">"Parandage tahvelarvuti aku tööiga"</string>
    <string name="battery_suggestion_title" product="device" msgid="1507272328369733005">"Parandage seadme aku tööiga"</string>
    <string name="battery_suggestion_title" product="default" msgid="4038053023336285165">"Parandage telefoni aku tööiga"</string>
    <string name="battery_suggestion_summary" msgid="4585677159811722359"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="7840226017975251549">"Helisemise vältimine"</string>
    <string name="gesture_prevent_ringing_title" msgid="5961391929839748111">"Korraga toitenupu ja helitugevuse suurendamise nupu vajutamine:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="5724512060316688779">"Otsetee helisemise vältimiseks"</string>
    <string name="prevent_ringing_option_vibrate" msgid="7286821846542822661">"Vibreeri"</string>
    <string name="prevent_ringing_option_mute" msgid="7551545579059879853">"Vaigista"</string>
    <string name="prevent_ringing_option_none" msgid="4656046650769569175">"Ära tee midagi"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="1157524435626890116">"Sees (vibreeri)"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="4472465110708640980">"Sees (vaigistatud)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="5013718946609276137">"Väljas"</string>
    <string name="pref_title_network_details" msgid="7186418845727358964">"Võrgu üksikasjad"</string>
    <string name="about_phone_device_name_warning" msgid="8885670415541365348">"Teie seadme nimi on telefonis rakendustele nähtav. Bluetoothi seadmetega ühendamisel või WiFi-pääsupunkti loomisel võivad seda näha ka teised inimesed."</string>
    <string name="devices_title" msgid="7701726109334110391">"Seadmed"</string>
    <string name="homepage_all_settings" msgid="1245540304900512919">"Kõik seaded"</string>
    <string name="homepage_personal_settings" msgid="1570415428680432319">"Soovitused"</string>
    <string name="choose_network_title" msgid="5702586742615861037">"Võrgu valimine"</string>
    <string name="network_disconnected" msgid="2933191767567503504">"Ühendus on katkestatud"</string>
    <string name="network_connected" msgid="4943925032253989621">"Ühendatud"</string>
    <string name="network_connecting" msgid="76404590784733557">"Ühendamine …"</string>
    <string name="network_could_not_connect" msgid="1113813392274155369">"Ühendust ei saanud luua"</string>
    <string name="empty_networks_list" msgid="2578752112731781190">"Võrke ei leitud."</string>
    <string name="network_query_error" msgid="7487714485362598410">"Võrke ei õnnestunud leida. Proovige uuesti."</string>
    <string name="forbidden_network" msgid="4626592887509826545">"(keelatud)"</string>
    <string name="no_sim_card" msgid="1360669528113557381">"SIM-kaarti pole"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="3956515670308744433">"Eelistatud võrgurežiim: eelistatud WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="5225727680228194864">"Eelistatud võrgurežiim: ainult GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="8956197584659205699">"Eelistatud võrgurežiim: ainult WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="4290654515569144276">"Eelistatud võrgurežiim: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="854981096234906594">"Eelistatud võrgurežiim: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="2578065433446506616">"Eelistatud võrgurežiim: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6604102246309629962">"Eelistatud võrgurežiim: ainult CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="7558385602277592784">"Eelistatud võrgurežiim: ainult EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="1742638677806401815">"Eelistatud võrgurežiim: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="8528755811985330696">"Eelistatud võrgurežiim: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="6632007438739933645">"Eelistatud võrgurežiim: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="5464960267483576515">"Eelistatud võrgurežiim: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_global_summary" msgid="8552400100470153638">"Eelistatud võrgurežiim: üldine"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="8037915274486919940">"Eelistatud võrgurežiim: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="104110625441127919">"Eelistatud võrgurežiim: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2561159741461407053">"Eelistatud võrgurežiim: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="1111689194136766011">"Eelistatud võrgurežiim: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="4272515966019344433">"Eelistatud võrgurežiim: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3138210224248737600">"Eelistatud võrgurežiim: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="7575595856957063853">"Eelistatud võrgurežiim: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="1512046749970721629">"Eelistatud võrgurežiim: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="1038314909945393905">"Eelistatud võrgurežiim: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="3277980364222159279">"Eelistatud võrgurežiim: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1572937828071126891">"Eelistatud võrgurežiim: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8393145171649288912">"Eelistatud võrgurežiim: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="5544016990994809932">"Eelistatud võrgurežiim: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_lte" msgid="1287709529829131860">"LTE (soovitatav)"</string>
    <string name="network_4G" msgid="8611758013994499559">"4G (soovitatav)"</string>
    <string name="network_global" msgid="959947774831178632">"Üldine"</string>
    <string name="label_available" msgid="1731547832803057893">"Saadaolevad võrgud"</string>
    <string name="load_networks_progress" msgid="7709402068413190831">"Otsimine …"</string>
    <string name="register_on_network" msgid="766516026652295941">"Registreerimine võrgus <xliff:g id="NETWORK">%s</xliff:g> …"</string>
    <string name="not_allowed" msgid="1667079919821581706">"Teie SIM-kaart ei võimalda ühendust selle võrguga."</string>
    <string name="connect_later" msgid="978991102125216741">"Võrguga ei saa praegu ühendust. Proovige hiljem uuesti."</string>
    <string name="registration_done" msgid="4573820010512184521">"Võrgus registreeritud."</string>
    <string name="select_automatically" msgid="7318032984017853975">"Vali võrk automaatselt"</string>
    <string name="carrier_settings_title" msgid="3503012527671299886">"Operaatori seaded"</string>
    <string name="cdma_lte_data_service" msgid="8507044148856536098">"Andmesideteenuse seadistamine"</string>
    <string name="mobile_data_settings_title" msgid="7674604042461065482">"Mobiilne andmeside"</string>
    <string name="mobile_data_settings_summary" msgid="2708261377199805404">"Andmesideühendus mobiilsidevõrgu abil"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="2914985502279794000">"Telefon aktiveerib levialasse jõudmisel selle operaatori automaatselt"</string>
    <string name="calls_preference" msgid="4628557570999372758">"Kõnede eelistus"</string>
    <string name="sms_preference" msgid="3479810211828513772">"SMS-i eelistus"</string>
    <string name="calls_and_sms_ask_every_time" msgid="2127802836576375306">"Küsi iga kord"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9148476748420654283">"Võrgu lisamine"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="4505694491027023039">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM-i</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> SIM</item>
    </plurals>
    <string name="default_for_calls" msgid="6732520879241581841">"Kõnede puhul vaikeseade"</string>
    <string name="default_for_sms" msgid="294276190503132313">"SMS-ide puhul vaikeseade"</string>
    <string name="default_for_calls_and_sms" msgid="3862322027700754792">"Kõnede ja SMS-ide puhul vaikeseade"</string>
    <string name="default_for_mobile_data" msgid="955987144209828344">"Mobiilse andmeside puhul vaikeseade"</string>
    <string name="mobile_data_active" msgid="5108294051762397700">"Mobiilne andmeside on aktiivne"</string>
    <string name="mobile_data_off" msgid="5831854766113105657">"Mobiilne andmeside on väljas"</string>
    <string name="subscription_available" msgid="6502502298446954785">"Saadaval"</string>
    <string name="mobile_network_in_range" msgid="8212440637838603215">"Levialas"</string>
    <string name="mobile_network_not_in_range" msgid="5287596455212313284">"Pole levialas"</string>
    <string name="mobile_network_list_add_more" msgid="4000806369124701679">"Lisa veel"</string>
    <string name="mobile_network_active_sim" msgid="2375956837678169169">"Aktiivne / SIM-kaart"</string>
    <string name="mobile_network_inactive_sim" msgid="291768076436646044">"Inaktiivne / SIM-kaart"</string>
    <string name="mobile_network_active_esim" msgid="4914509039134228659">"Aktiivne / allalaaditud SIM-kaart"</string>
    <string name="mobile_network_inactive_esim" msgid="7653631389686307842">"Inaktiivne / allalaaditud SIM-kaart"</string>
    <string name="mobile_network_sim_name" msgid="6026120971523242277">"SIMi nimi ja värv"</string>
    <string name="mobile_network_sim_name_label" msgid="281403463781467324">"Nimi"</string>
    <string name="mobile_network_sim_color_label" msgid="3662112943353180621">"Värv (kasutavad ühilduvad rakendused)"</string>
    <string name="mobile_network_sim_name_rename" msgid="3082357234342116252">"Salvesta"</string>
    <string name="mobile_network_use_sim_on" msgid="8035448244261570189">"Kasuta SIM-kaarti"</string>
    <string name="mobile_network_use_sim_off" msgid="889073420068380943">"Väljas"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="1515981880164339357">"Selle SIM-i keelamiseks eemaldage SIM-kaart"</string>
    <string name="mobile_network_tap_to_activate" msgid="4573431375941175566">"Puudutage operaatori <xliff:g id="CARRIER">%1$s</xliff:g> aktiveerimiseks"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="6546784593612512953">"Kas soovite aktiveerida operaatori <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="1621021150667547211">"Korraga saab aktiivne olla vaid üks allalaaditud SIM-kaart.\n\nOperaatori <xliff:g id="CARRIER1">%1$s</xliff:g> aktiveerimisel ei tühistata operaatori <xliff:g id="CARRIER2">%2$s</xliff:g> teenust."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8025086398614992834">"Aktiveeri <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="896275511321635947">"Kustuta SIM-kaart"</string>
    <string name="mobile_network_erase_sim_dialog_title" msgid="8211945787729023193">"Kas soovite allalaaditud SIM-kaardi kustutada?"</string>
    <string name="mobile_network_erase_sim_dialog_body" msgid="3363079846287650684">"SIM-kaardi kustutamisel eemaldatakse seadmest operaatori <xliff:g id="CARRIER_0">%1$s</xliff:g> teenus.\n\nOperaatori <xliff:g id="CARRIER_1">%2$s</xliff:g> teenust ei tühistata."</string>
    <string name="mobile_network_erase_sim_dialog_ok" msgid="5130805470041783437">"Kustuta"</string>
    <string name="mobile_network_erase_sim_dialog_progress" msgid="6541813899575453878">"SIM-kaardi kustutamine …"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="730767308428197756">"SIM-kaarti ei saa kustutada"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6835262809290075813">"Seda SIM-kaarti ei saa vea tõttu kustutada.\n\nTaaskäivitage seade ja proovige uuesti."</string>
    <string name="preferred_network_mode_title" msgid="6505630109389684100">"Eelistatud võrgutüüp"</string>
    <string name="preferred_network_mode_summary" msgid="1216219115667163264">"Võrgu töörežiimi muutmine"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="849254040214447984">"Eelistatud võrgutüüp"</string>
    <string name="carrier_settings_euicc" msgid="8658562169133242581">"Operaator"</string>
    <string name="carrier_settings_version" msgid="3469507893844448432">"Seadete versioon"</string>
    <string name="call_category" msgid="8108654745239563833">"Helistamine"</string>
    <string name="video_calling_settings_title" msgid="8153216918491498505">"Operaatori videokõne"</string>
    <string name="cdma_system_select_title" msgid="7210256688912895790">"Süsteemi valimine"</string>
    <string name="cdma_system_select_summary" msgid="3413863051181111941">"CDMA-rändlusrežiimi muutmine"</string>
    <string name="cdma_system_select_dialogtitle" msgid="1198883288864916563">"Süsteemi valimine"</string>
    <string name="network_operator_category" msgid="8451238364605724918">"Võrk"</string>
    <string name="network_select_title" msgid="8394621216255081026">"Võrk"</string>
    <string name="cdma_subscription_title" msgid="1473189596933979467">"CDMA-tellimus"</string>
    <string name="cdma_subscription_summary" msgid="7191590908367194209">"RUIM/SIM-i ja NV vahetamine"</string>
    <string name="cdma_subscription_dialogtitle" msgid="9153005469617575361">"tellimus"</string>
    <string name="register_automatically" msgid="518185886971595020">"Automaatne registreerimine …"</string>
    <string name="roaming_alert_title" msgid="7458177294163751484">"Kas lubada andmesiderändlus?"</string>
    <string name="roaming_check_price_warning" msgid="4979418631753681300">"Hinnakirja küsige oma võrguteenuse pakkujalt."</string>
    <string name="mobile_data_usage_title" msgid="7862429216994894656">"Rakenduse andmekasutus"</string>
    <string name="mobile_network_mode_error" msgid="4784347953600013818">"Võrgu režiim <xliff:g id="NETWORKMODEID">%1$d</xliff:g> on sobimatu. Eirake seda."</string>
    <string name="mobile_network_apn_title" msgid="7610812642954395440">"Pääsupunktide nimed"</string>
    <string name="manual_mode_disallowed_summary" msgid="2085670341790561153">"Pole saadaval, kui on ühendus on loodud operaatoriga <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="emergency_info_contextual_card_summary" msgid="7993926837251874514">"Meditsiiniline teave, hädaolukorra kontaktid"</string>
    <string name="see_more" msgid="5953815986207345223">"Kuva rohkem"</string>
    <string name="see_less" msgid="1250265310929558370">"Kuva vähem"</string>
    <string name="network_connection_request_dialog_title" msgid="3502355504717957803">"Seade, mida rakendusega <xliff:g id="APPNAME">%1$s</xliff:g> kasutada"</string>
    <string name="network_connection_timeout_dialog_message" msgid="3711556077945728716">"Seadmeid ei leitud. Veenduge, et seadmed oleksid sisse lülitatud ja ühendamiseks saadaval."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="8924405960181020156">"Proovi uuesti"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="6953778550775646710">"Midagi tuli vahele. Rakendus tühistas seadme valimise taotluse."</string>
    <string name="network_connection_connect_successful" msgid="5935510954474494928">"Ühendamine õnnestus"</string>
    <string name="network_connection_request_dialog_showall" msgid="6938922880244567521">"Kuva kõik"</string>
    <string name="network_connection_searching_message" msgid="4638576789450817530">"Seadme otsimine …"</string>
    <string name="network_connection_connecting_message" msgid="3740982406609245654">"Seadmega ühendamine …"</string>
    <plurals name="show_bluetooth_devices" formatted="false" msgid="1715020480026568408">
      <item quantity="other">Ühendatud on <xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> seadet</item>
      <item quantity="one">Ühendatud on <xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> seade</item>
    </plurals>
    <string name="no_bluetooth_devices" msgid="861861879657732058">"Bluetoothi seadmed puuduvad"</string>
    <string name="bluetooth_left_name" msgid="2133431890020995442">"Vasak"</string>
    <string name="bluetooth_right_name" msgid="525578831502355410">"Parem"</string>
    <string name="bluetooth_middle_name" msgid="3272836932362043957">"Ümbris"</string>
    <string name="settings_panel_title" msgid="4688575606213055744">"Seadete paneel"</string>
    <string name="internet_connectivity_panel_title" msgid="721392242301676444">"Interneti ühenduvus"</string>
    <string name="volume_connectivity_panel_title" msgid="9192664643867101356">"Helitugevus"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="1127588179830051811">"Ei ole lennukirežiimis saadaval"</string>
    <string name="force_desktop_mode" msgid="4303240595324847998">"Töölauarežiimi jõustamine"</string>
    <string name="force_desktop_mode_summary" msgid="6259798246015387202">"Katselise töölauarežiimi jõustamine teisestel ekraanidel"</string>
    <string name="hwui_force_dark_title" msgid="2466919877609396257">"Funktsiooni Sunnitud tume alistamine"</string>
    <string name="hwui_force_dark_summary" msgid="8705328793382981780">"Alistab funktsiooni Sunnitud tume ja lülitab selle alaliselt sisse"</string>
    <string name="privacy_dashboard_title" msgid="2458407399263943923">"Privaatsus"</string>
    <string name="privacy_dashboard_summary" msgid="4570241983077984329">"Load, kontotegevused, isiklikud andmed"</string>
    <string name="contextual_card_dismiss_remove" msgid="2813670241047194713">"Eemalda"</string>
    <string name="contextual_card_dismiss_keep" msgid="2230740610451447340">"Säilita"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="5507487987591500742">"Kas eemaldada see soovitus?"</string>
    <string name="contextual_card_removed_message" msgid="6744732110721136227">"Soovitus on eemaldatud"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="3564089284222177020">"Võta tagasi"</string>
    <string name="low_storage_summary" msgid="2077564126033530">"Salvestusruumi on vähe. <xliff:g id="PERCENTAGE">%1$s</xliff:g> on kasutusel ja <xliff:g id="FREE_SPACE">%2$s</xliff:g> vaba"</string>
    <string name="contextual_card_feedback_send" msgid="2996691837358030021">"Saada tagasisidet"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="8115454795160804779">"Kas soovite selle soovituse kohta tagasisidet anda?"</string>
    <string name="copyable_slice_toast" msgid="2924110841440836023">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> on lõikelauale kopeeritud."</string>
    <string name="search_bar_account_avatar_content_description" msgid="4718261366290530792"></string>
    <string name="permission_bar_chart_empty_text" msgid="4380731551728553852">"0 rakendust kasutasid lube"</string>
    <string name="permission_bar_chart_title" msgid="2745425703472199837">"Lubade kasutus viimase 24 tunni jooksul"</string>
    <string name="permission_bar_chart_details" msgid="2977943114535855210">"Kuva kõik juhtpaneelil"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="5346938677887948252">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> rakendust</item>
      <item quantity="one">1 rakendus</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="5136753034714150614">"Juurdepääsetavuse kasutus"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="5790789101231115740">
      <item quantity="other"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> rakendusel on täielik juurdepääs teie seadmele</item>
      <item quantity="one">1 rakendusel on täielik juurdepääs teie seadmele</item>
    </plurals>
    <string name="manage_app_notification" msgid="4575452737886198216">"Halda rakenduse <xliff:g id="APP_NAME">%1$s</xliff:g> märguandeid"</string>
    <string name="no_suggested_app" msgid="5722034393216359231">"Soovitatud rakendust pole"</string>
    <plurals name="notification_few_channel_count_summary" formatted="false" msgid="1090888820158822106">
      <item quantity="other"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> märguandekanalit.</item>
      <item quantity="one"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_0">%1$d</xliff:g> märguandekanal.</item>
    </plurals>
    <string name="notification_many_channel_count_summary" msgid="8647409434789898073">"<xliff:g id="NOTIFICATION_CHANNEL_COUNT">%1$d</xliff:g> märguandekanalit. Puudutage kõigi haldamiseks."</string>
    <string name="recently_installed_app" msgid="2877671740090335492">"Installisite selle rakenduse hiljuti."</string>
    <string name="media_output_panel_title" msgid="6197092814295528184">"Väljundi vahetamine"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="629529380940058789">"Praegu seadmes <xliff:g id="DEVICE_NAME">%1$s</xliff:g> esitamisel"</string>
    <string name="wfc_disclaimer_title_text" msgid="6164569741719679613">"Oluline teave"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="1405773141236165542">"JÄTKA"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="2700358281438736674">"EI, TÄNAN"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="6658735446562619865">"Asukoht"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="3096546236221656018">"Teenusepakkuja võib selle teenuse pakkumiseks koguda teie asukohateavet.\n\nVaadake oma teenusepakkuja privaatsuseeskirju."</string>
    <string name="forget_passpoint_dialog_message" msgid="7331876195857622224">"Järelejäänud aeg või andmemaht võib kaotsi minna. Enne eemaldamist pidage nõu operaatoriga."</string>
    <string name="keywords_content_capture" msgid="8252675452668954083">"sisu jäädvustamine, rakenduse sisu"</string>
    <string name="content_capture" msgid="3210232615756364639">"Rakenduse sisu"</string>
    <string name="content_capture_summary" msgid="659506647507221852">"Luba rakendustel Android-süsteemile sisu saata"</string>
    <string name="capture_system_heap_dump_title" msgid="8043655498113164693">"Jäädvusta süsteemi mälutõmmis"</string>
    <string name="capturing_system_heap_dump_message" msgid="8680086369500395131">"Süsteemi mälutõmmise jäädvustamine"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="6346229989760615103">"Süsteemi mälutõmmist ei saanud jäädvustada"</string>
    <string name="automatic_system_heap_dump_title" msgid="442496436397957988">"Jäädvusta süsteemi mälutõmmised automaatselt"</string>
    <string name="automatic_system_heap_dump_summary" msgid="8253838659009241350">"Jäädvusta mälutõmmis automaatselt, kui Androidi süsteem kasutab liiga palju mälu"</string>
    <string name="wifi_disconnect_button_text" msgid="2032651902928903819">"Katkesta ühendus"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="3354031536141983602">"Hädaabikõned"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="6068582272230311464">"Teie operaator ei toeta hädaabikõnesid WiFi-kõnede kaudu.\nSeade lülitub hädaabikõne tegemiseks automaatselt mobiilsidevõrgule.\nHädaabikõned on võimalikud ainult mobiilsidevõrgu levialas."</string>
    <string name="wifi_calling_summary" msgid="513599567573172420">"Kvaliteedi parandamiseks kasutage kõnede puhul WiFi-t"</string>
    <string name="enable_receiving_mms_notification_title" msgid="8809328429865242752">"Sissetulev MMS-sõnum"</string>
    <string name="enable_sending_mms_notification_title" msgid="3852773093703966351">"MMS-i ei saa saata"</string>
    <string name="enable_mms_notification_summary" msgid="7643379825980866408">"Puudutage, et lubada MMS-sõnumside operaatori <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> võrgus, kui mobiilne andmeside on välja lülitatud"</string>
    <string name="enable_mms_notification_channel_title" msgid="4402474709766126987">"MMS-sõnum"</string>
    <string name="sim_combination_warning_notification_title" msgid="3717178238465948430">"Probleem SIM-kombinatsiooniga"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2602011424635850202">"Operaatorite <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> kasutamine võib piirata funktsionaalsust. Puudutage lisateabe saamiseks."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="4144088600737896010">"SIM-kombinatsioon"</string>
    <string name="work_policy_privacy_settings" msgid="2348992644755730215">"Teie tööeeskirjade teave"</string>
    <string name="work_policy_privacy_settings_summary" msgid="2236899807429121767">"Seadeid haldab teie IT-administraator"</string>
</resources>
