<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Jah"</string>
    <string name="no" msgid="5541738710521607130">"Ei"</string>
    <string name="create" msgid="986997212165228751">"Loo"</string>
    <string name="allow" msgid="3763244945363657722">"Luba"</string>
    <string name="deny" msgid="7326117222944479942">"Keela"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Lülita sisse"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Tundmatu"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="1646187747875476269">
      <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="2840850085134853754">"Olete nüüd arendaja!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Ei ole vaja, olete juba arendaja."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Lubage esmalt arendaja valikud."</string>
    <string name="header_category_wireless_networks" msgid="303445626075235229">"Traadita ühendus ja võrgud"</string>
    <string name="header_category_system" msgid="1665516346845259058">"Süsteem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Teenus toimib"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Teenus ei toimi"</string>
    <string name="radioInfo_service_emergency" msgid="6838935881091760942">"Ainult hädaabikõned"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Raadio on väljas"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Rändlus"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Rändlus puudub"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Ühendus katkestatud"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Ühendamine"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Ühendatud"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Peatatud"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Teadmata"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="1816306320988638382">"Lahuta USB-mäluseade"</string>
    <string name="sdcard_unmount" product="default" msgid="8078570285871053815">"SD-kaardi lahutamine"</string>
    <string name="sdcard_format" product="nosdcard" msgid="3248760426252305366">"Kustuta USB-mäluseade"</string>
    <string name="sdcard_format" product="default" msgid="3676635435136326182">"Kustuta SD-kaart"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Eelvaade"</string>
    <string name="preview_page_indicator_content_description" msgid="2790254666634885865">"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="1296835853522566260">"Muutke ekraanil kuvatavat teksti suuremaks või väiksemaks."</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Vähendamine"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Suurendamine"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3151963020165952847">"Kasuta automaatset pööramist"</string>
    <string name="smart_rotate_text_headline" msgid="8947678366129076364">"Näotuvastus kasutab esikaamerat, et parandada automaatse pööramise täpsust. Pilte ei salvestata ega saadeta mitte kunagi Google\'ile.&lt;br&gt;&lt;br&gt; &lt;a href=<xliff:g id="URL">http://support.google.com/mobile?p=telephony_rtt</xliff:g>&gt;Lisateave ekraanikuva automaatse pööramise kohta&lt;/a&gt;"</string>
    <string name="font_size_preview_text_headline" msgid="1173103737980511652">"Näidistekst"</string>
    <string name="font_size_preview_text_title" msgid="6363561029914452382">"Võlur Oz"</string>
    <string name="font_size_preview_text_subtitle" msgid="5806349524325544614">"11. peatükk: Ozi imeline smaragdlinn"</string>
    <string name="font_size_preview_text_body" msgid="3323732544011097199">"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="206892409190870726">"OK"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="6071836464978826249">"USB-mäluseade"</string>
    <string name="sdcard_setting" product="default" msgid="3713462184783824923">"SD-kaart"</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Nähtav kõigile lähedalasuvatele Bluetooth-seadmetele (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Nähtav kõigile lähedalasuvatele Bluetooth-seadmetele"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Ei ole nähtav teistele Bluetooth-seadmetele"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Nähtav ainult seotud seadmetele"</string>
    <string name="bluetooth_visibility_timeout" msgid="7611781967900196353">"Nähtavuse ajalõpp"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="7405038248936935186">"Lukusta häälvalimine"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4959591522483403402">"Vältige Bluetoothi valija kasutamist, kui ekraan on lukustatud"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth-seadmed"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Seadme nimi"</string>
    <string name="bluetooth_device_details" msgid="630702184344217832">"Seadme seaded"</string>
    <string name="bluetooth_profile_details" msgid="1269419918127093325">"Profiili seaded"</string>
    <string name="bluetooth_name_not_set" msgid="4654357917928126208">"Nimi on määramata, konto nime kasutamine"</string>
    <string name="bluetooth_scan_for_devices" msgid="8143654526358934069">"Otsi seadmeid"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Seadme ümbernimetamine"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Nimeta ümber"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Kas katkestada seadme ühendus?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="1934297101665686854">"Teie telefon katkestab ühenduse seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="336622948210457991">"Teie tahvelarvuti katkestab ühenduse seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="6944790936166852428">"Teie seade katkestab ühenduse seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="4173740094381092185">"Katk. üh."</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="909734990821975673">"Teil ei ole luba Bluetoothi seadete muutmiseks."</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Uue seadme sidumine"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_is_visible_message" msgid="3811631869768157387">"<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="4782330594323261630">"Telefoni Bluetoothi aadress: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="1257226691967432025">"Tahvelarvuti Bluetoothi aadress: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="2863536947810007600">"Seadme Bluetoothi aadress: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="777406775955421784">"Kas katkestada ühendus seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="6379176741690311973">"Edastamine"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Nimetu Bluetooth-seade"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Otsimine"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Läheduses ei leitud Bluetooth-seadmeid."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Bluetoothi sidumisettepanek"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Sidumistaotlus"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Puudutage seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> sidumiseks."</string>
    <string name="bluetooth_show_received_files" msgid="685424727760622632">"Vastuvõetud failid"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="7097860463458492953">"Bluetoothi kaudu saadud failid"</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth on väljas"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Puudutage sisselülitamiseks"</string>
    <string name="device_picker" msgid="2427027896389445414">"Bluetooth-seadme valimine"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi sisse lülitada"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> soovib Bluetoothi välja lülitada"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Rakendus soovib Bluetoothi sisse lülitada"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Rakendus soovib Bluetoothi välja lülitada"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="1273405567801929487">"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="7013223328571883275">"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="3266007454914144057">"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="7989444746980501116">"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="6482084870735107773">"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="2352494279465502950">"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="2732992604509910896">"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="356982103612920264">"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="6103655179509599427">"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="934276632311449337">"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="1284048348024444485">"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="2661614145022629454">"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="8588317955400593623">"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="4047444317445386579">"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="4922952478824372605">"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="1381582950049639439">"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="3842613808709024730">"Bluetoothi sisselülitamine ..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Bluetoothi väljalülitamine ..."</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Bluetooth-ühenduse taotlus"</string>
    <string name="bluetooth_connection_notif_message" msgid="6087344980352898209">"Puudutage seadmega „<xliff:g id="DEVICE_NAME">%1$s</xliff:g>” ühenduse loomiseks."</string>
    <string name="bluetooth_connection_dialog_text" msgid="2537152772549874391">"Kas soovite ühendada seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Taotlus telefoniraamatule juurdepääsuks"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="7153531868579789993">"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="173821849670438110">"Ära enam küsi"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2080511174185036562">"Ära enam küsi"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Taotlus sõnumile juurdepääsuks"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="2647611490952377156">"%1$s soovib saada juurdepääsu sõnumitele. Kas anda seadmele %2$s juurdepääs?"</string>
    <string name="bluetooth_sap_request" msgid="473439406287008397">"Juurdepääsutaotlus SIM-kaardile"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="2849083276356078655">"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="8678342689845439583">"Teistele seadmetele nähtav seadmena „<xliff:g id="DEVICE_NAME">^1</xliff:g>”"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Teiste seadmetega ühendamiseks lülitage Bluetooth sisse."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Teie seadmed"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Uue seadme sidumine"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3506962706611366830">"Lubage oma tahvelarvutil lähedalasuvate Bluetoothi seadmetega suhelda"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2192027516577675587">"Lubage oma seadmel lähedalasuvate Bluetoothi seadmetega suhelda"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="768958961865499804">"Lubage telefonil suhelda lähedalasuvate Bluetoothi seadmetega"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Keela Bluetoothi A2DP riistvara mahalaadimine"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="8610420176339657720">"Kas taaskäivitada seade?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8333029144800835996">"Selle seade muutmiseks peate seadme taaskäivitama."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="3488695418187553566">"Taaskäivita"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="4930826928585464191">"Loobu"</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Meediaseadmed"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Helistamisseadmed"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Muud seadmed"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Salvestatud seadmed"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth lülitatakse sidumiseks sisse"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Ühenduse eelistused"</string>
    <string name="connected_device_previously_connected_title" msgid="605808252622814415">"Varem ühendatud seadmed"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Eelnevalt ühendatud"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth on sisse lülitatud"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Kuva kõik"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Kuupäev ja kellaaeg"</string>
    <string name="choose_timezone" msgid="1450780665958642147">"Ajavööndi valimine"</string>
    <!-- no translation found for intent_sender_data_label (1733806423295725392) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="3202857258557610646">"Saada <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="257853357827275530">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="519934560779343541">"Käivita <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="5087385727740280207">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="36614006839665458">"Konto:"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Puhverserver"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Kustuta"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Puhverserveri port"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Puhverserverist mööduvad"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Taasta vaikeväärtused"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Valmis"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Puhverserveri hosti nimi"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Tähelepanu"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Sisestatud hosti nimi on kehtetu."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Sisestatud välistusloend ei ole õigesti vormindatud. Sisestage välistatud domeenide komadega eraldatud loend."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Peate täitma pordi välja."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Pordi väli peab olema tühi, kui hosti väli on tühi."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Sisestatud port on kehtetu."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Brauser kasutab HTTP-puhverserverit, kuid muud rakendused ei pruugi seda kasutada."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Pingi hosti nimi (www.google.com) IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="8327436534663560713">"Pingi hosti nimi (www.google.com) IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP-kliendi test:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Pingimistesti käitamine"</string>
    <string name="sdcard_changes_instructions" msgid="2331969501845866957">"Muudatused jõustuvad siis, kui USB-kaabel on uuesti ühendatud."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="129059989000252994">"USB massmälu lubamine"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="5298511430610207103">"Baite kokku:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="6189761476582690998">"USB-mäluseade on paigaldamata."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="6601962586941623203">"Puudub SD-kaart."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="7721283102767669004">"Saadaolevad baidid:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="4878190674458263222">"USB on kasutusel massmäluna."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="8850227049504860012">"SD-kaart on kasutusel massmäluseadmena."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="1053258530368541571">"USB eemaldamine on nüüd ohutu."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="5813940671700138561">"SD-kaardi eemaldamine on nüüd ohutu."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="209564009449909311">"USB eemaldati kasutamise ajal"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="6817342973919819392">"SD-kaart eemaldati kasutamise ajal."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="5646588579332741943">"Kasutatud baite:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="8037280964384235345">"USB-st meediumi skaneering ..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="3297316465982471437">"SD-kaardi skannimine meediumi jaoks ..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3444648373391629840">"USB-mälu on kirjutuskaitsega."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4338796260718910164">"SD-kaart on paigaldatud kirjutuskaitstuna."</string>
    <string name="skip_label" msgid="6380034601349015895">"Jäta vahele"</string>
    <string name="next_label" msgid="1248293387735652187">"Järgmine"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Keeled"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Eemalda"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Lisa keel"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="2845515796732609837">
      <item quantity="other">Kas eemaldada valitud keeled?</item>
      <item quantity="one">Kas eemaldada valitud keel?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Tekst kuvatakse teises keeles."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Kõiki keeli ei saa eemaldada"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Jätke alles vähemalt üks eelistatud keel"</string>
    <string name="locale_not_translated" msgid="5079729745235316146">"Ei pruugi mõnes rakenduses saadaval olla"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Teisalda üles"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Teisalda alla"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Teisalda kõige üles"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Teisalda kõige alla"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Eemalda keel"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Tegevuse valimine"</string>
    <string name="display_label" msgid="3056320781191343221">"Ekraan"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="1850505156136467106">"USB-mäluseade"</string>
    <string name="sd_card_settings_label" product="default" msgid="8715502912796241588">"SD-kaart"</string>
    <string name="proxy_settings_label" msgid="6300573815025557843">"Puhverserveri seaded"</string>
    <string name="cancel" msgid="5780102414089664898">"Tühista"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Unusta"</string>
    <string name="save" msgid="3125033126936493822">"Salvesta"</string>
    <string name="done" msgid="7497982645646431310">"Valmis"</string>
    <string name="apply" msgid="7834684883190163536">"Rakenda"</string>
    <string name="share" msgid="8502235338607613795">"Jaga"</string>
    <string name="add" msgid="8335206931421683426">"Lisa"</string>
    <string name="settings_label" msgid="943294133671632976">"Seaded"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Seaded"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Seadete otsetee"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Lennukirežiim"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Traadita ühendus ja võrgud"</string>
    <string name="radio_controls_summary" msgid="9028430178697624501">"WiFi, Bluetoothi, lennurežiimi ja mobiilsidevõrkude ning VPN-ide haldamine"</string>
    <string name="cellular_data_summary" msgid="6551434804367912367">"Luba andmekasutus mobiilsidevõrgu kaudu"</string>
    <string name="allow_data_usage_title" msgid="2645963379925196671">"Luba andmekas. rändluse ajal"</string>
    <string name="roaming" msgid="3055365654530847985">"Rändlus"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Ühenda rändluse ajal andmesideteenustega"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Ühenda rändluse ajal andmesideteenustega"</string>
    <string name="roaming_reenable_message" msgid="5150423860521673540">"Kaotasite andmesideühenduse, kuna jätsite oma koduvõrgu andmerändluse väljalülitatuks."</string>
    <string name="roaming_turn_it_on_button" msgid="6999283810847157816">"Lülita sisse"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Rakenduda võivad rändlustasud."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="5629953315019604726">"Kui lubate andmeside rändluse, võivad rakenduda rändlustasud.\n\nSee seade mõjutab kõiki selle tahvelarvuti kasutajaid."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="3693719745119874126">"Kui lubate andmeside rändluse, võivad rakenduda rändlustasud.\n\nSee seade mõjutab kõiki selle telefoni kasutajaid."</string>
    <string name="roaming_reenable_title" msgid="770824950144026180">"Kas lubada andmesiderändlus?"</string>
    <string name="networks" msgid="5184501333492775095">"Operaatori valik"</string>
    <string name="sum_carrier_select" msgid="1669911795517995916">"Võrguoperaatori valimine"</string>
    <string name="date_and_time_settings_title" msgid="2305454529709812364">"Kuupäev ja kellaaeg"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="1841717199409629742">"Kuupäeva ja kellaaja määramine"</string>
    <string name="date_and_time_settings_summary" msgid="334967758944498010">"Määra kuupäev, kellaaeg, ajavöönd ja vormingud"</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Kellaaja automaatne määramine"</string>
    <string name="zone_auto_title" msgid="3993580453604839924">"Ajavööndi automaatne määramine"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Kasuta lokaadi vaikeseadet"</string>
    <string name="date_time_24hour_title" msgid="1445056824481243600">"24-tunnine vorming"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"24-tunnise vormingu kasutamine"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Kellaaeg"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Kellaaja vorming"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Ajavöönd"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Ajavööndi valimine"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Kuupäev"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Otsingupiirkond"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Piirkond"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"UTC-nihke valimine"</string>
    <string name="zone_change_to_from_dst" msgid="686451769985774294">"<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="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="7004693956837388129">"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="8399585343328811158">"Kasutab ajavööndit <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Suveaega pole."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Suveaeg"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Aeg"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Vali piirkonna alusel"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"UTC nihke alusel valimine"</string>
    <string name="date_picker_title" msgid="646573308567782578">"Kuupäev"</string>
    <string name="time_picker_title" msgid="1784236407401743393">"Kellaaeg"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Lukustamine pärast ekraani ajalõppu"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast ajalõppu"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Kohe pärast ajalõppu, välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> hoiab seadme avatuna"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pärast ajalõppu, välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> hoiab seadme avatuna"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="197365342192696406">"Kuva lukustusekraanil teave omaniku kohta"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Teksti lisamine lukustuskuvale"</string>
    <string name="security_enable_widgets_title" msgid="676199714313423099">"Luba vidinad"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="5191637768484254146">"Administraatori keelatud"</string>
    <string name="lockdown_settings_title" msgid="8988970335658365075">"Kuva lukustamise valik"</string>
    <string name="lockdown_settings_summary" msgid="5857509790740495057">"Kuvatakse toitenupu valik, mis lülitab funktsiooni Smart Lock, näoga avamise, sõrmejäljega avamise ja lukustuskuval kuvatavad märguanded välja"</string>
    <string name="trust_lost_locks_screen_title" msgid="4231232144565291276">"Lukusta ekraan usalduse kadumisel"</string>
    <string name="trust_lost_locks_screen_summary" msgid="718374221849537361">"Kui see on lubatud, lukustub seade, kui viimane usaldusväärne agent kaotab usalduse"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Puudub"</string>
    <string name="owner_info_settings_status" msgid="7488764871758677862">"<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="841926875876050274">"Nt Martini Android."</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="5734739022887933365">"Kuva lukustusekraanil profiili teave"</string>
    <string name="Accounts_settings_title" msgid="8434263183710375412">"Kontod"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Asukoht"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Kasuta asukohta"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Väljas"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="1019959038518185676">
      <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="6054103701535557342">"Laadimine …"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Rakendused, millel on luba läheduses olevatele seadmetele juurde pääseda, saavad määrata ühendatud seadmete suhtelise asukoha."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Juurdepääs asukohale on rakenduste ja teenuste jaoks välja lülitatud. Teie seadme asukoht võidakse siiski päästeteenistusele saata, kui helistate või saadate sõnumi hädaabinumbrile."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Vaadake lisateavet asukohaseadete kohta."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Kontod"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Turvalisus"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Krüpteerimine ja mandaadid"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="5298195959570992363">"Telefon on krüpteeritud"</string>
    <string name="decryption_settings_summary" product="default" msgid="1742645256103613503">"Telefon ei ole krüpteeritud"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="3776741531205406800">"Seade on krüpteeritud"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="1864963068216544631">"Seade ei ole krüpteeritud"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Lukustuskuva"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Mida kuvada?"</string>
    <string name="security_settings_summary" msgid="1627059516127354233">"Määrake Minu asukoht, ekraani avamine, SIM-kaardi lukk, mandaadi talletuslukk"</string>
    <string name="cdma_security_settings_summary" msgid="2455517905101186330">"Määrake oma asukoht, ekraani avamine, mandaadi talletuslukk"</string>
    <string name="security_passwords_title" msgid="4154420930973818581">"Privaatsus"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Pole saadaval"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Turvalisuse olek"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Ekraanilukk, Leia mu seade, rakenduse turvalisus"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Nägu on lisatud"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5952752252122581846">"Puudutage näo seadistamiseks"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Näoga avamine"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Näoga avamine töö jaoks"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Näoga avamise seadistamine"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Näoga avamise seadistamine"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Kasutage autentimiseks oma nägu"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_message_accessibility" msgid="1986648712195281391"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Alustamine"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Kui hõlbustatud näoga avamine välja lülitatakse, ei pruugi mõned seadistustoimingud TalkBackiga õigesti töötada."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Mine tagasi"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Jätka seadistamist"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Kasuta juurdepääset. seadistust"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="6763509014732769185"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Tühista"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Tänan, ei"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Nõustun"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Rohkem"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Avage oma näoga"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Lubage näoga avamine"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Kasutage autentimiseks oma nägu"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="3015751486939484934">"Kasutage oma nägu telefoni avamiseks, ostude volitamiseks või rakendustesse sisselogimiseks."</string>
    <string name="security_settings_face_enroll_introduction_consent_message" msgid="866117500419055444">"Lubage lapsel näo abil telefoni avada või oma isikut kinnitada. See toimub siis, kui ta üritab rakendustesse sisse logida, ostu kinnitada või teha muud."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Kasutage telefoni avamiseks või ostude kinnitamiseks oma nägu.\n\nMärkus: te ei saa kasutada oma nägu selle seadme avamiseks. Lisateabe saamiseks võtke ühendust oma organisatsiooni administraatoriga."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Kasutage oma nägu telefoni avamiseks, ostude volitamiseks või rakendustesse sisselogimiseks"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_info_looking" msgid="6502109133251718131"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_looking" msgid="1911530177804950718"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_how_message" msgid="4192656589626667797"></string>
    <string name="security_settings_face_enroll_introduction_how_consent_message" msgid="9028182363896853946"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_introduction_control_message" msgid="4818463420573540379"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_message" msgid="4658082872829249850"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Hoidke oma nägu ringi keskel"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Jäta vahele"</string>
    <string name="face_add_max" msgid="4578405795494514876">"Lisada saab kuni <xliff:g id="COUNT">%d</xliff:g> nägu"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Olete lisanud maksimaalse arvu nägusid"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Rohkem nägusid ei saa lisada"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registreerimist ei lõpetatud"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Näo registreerimisaeg lõppes. Proovige uuesti."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Näo registreerimine ei toiminud."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Kõik on valmis. Kõik on korras."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Valmis"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Täiustage näoga avamise toimivust"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Seadistage näoga avamine uuesti"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Seadistage näoga avamine uuesti"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Täiustage turvalisust ja toimivust"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Näoga avamise seadistamine"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Näoga avamise uuesti seadistamiseks kustutage oma praegune näomudel.\n\nTeie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist tuleb teil telefoni avamiseks või rakendustes autentimiseks sisestada PIN-kood, muster või parool."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Näoga avamise uuesti seadistamiseks kustutage oma praegune näomudel.\n\nTeie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist tuleb teil telefoni avamiseks või rakendustes autentimiseks kasutada sõrmejälge või sisestada PIN-kood, muster või parool."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Kasuta näoga avamist"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Näoga avamise kasutamisel"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Nõua avatud silmi"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Telefoni avamiseks peavad teie silmad avatud olema"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Nõua alati kinnitust"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Näoga avamise kasutamisel rakendustes nõutakse alati kinnitustoimingut"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Kustuta näomudel"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Näoga avamise seadistamine"</string>
    <string name="security_settings_face_settings_footer" msgid="625696606490947189">"Kasutage oma telefoni avamiseks või enda autentimiseks (nt rakendustes sisselogimisel või ostude kinnitamisel) oma nägu.\n\nPidage meeles:\nkorraga saab olla seadistatud ainult üks nägu. Uue näo lisamiseks kustutage praegune nägu.\n\nTelefoni vaatamisel võib see soovimatult avaneda.\n\nKeegi teine võib teie telefoni avada, kui seda hoitakse teie näo ees.\n\nVõib juhtuda, et teiega sarnane inimene, näiteks identne vend/õde, saab teie telefoni avada."</string>
    <string name="security_settings_face_settings_footer_attention_not_supported" msgid="2071065435536235622">"Kasutage oma telefoni avamiseks või enda autentimiseks (nt rakendustes sisselogimisel või ostude kinnitamisel) oma nägu.\n\nPidage meeles:\nkorraga saab olla seadistatud ainult üks nägu. Uue näo lisamiseks kustutage praegune nägu.\n\nTelefoni vaatamisel võib see soovimatult avaneda.\n\nKeegi teine võib teie telefoni avada, kui seda hoitakse teie näo ees, isegi kui teie silmad on suletud.\n\nVõib juhtuda, et teiega sarnane inimene, näiteks identne vend/õde, saab teie telefoni avada."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Kas kustutada näomudel?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="3268144215619385299">"Teie näomudel kustutatakse jäädavalt ja turvaliselt. Pärast kustutamist vajate telefoni avamiseks või rakendustes autentimiseks PIN-koodi, mustrit või parooli."</string>
    <string name="security_settings_face_settings_remove_model_dialog_title" msgid="7175068449513875691">"Kas kustutada näomudel?"</string>
    <string name="security_settings_face_settings_remove_model_dialog_details" msgid="7148069244593587389">"Teie näomudel kustutatakse jäädavalt ja turvaliselt.\n\nPärast kustutamist vajate telefoni avamiseks või rakendustes autentimiseks sõrmejälge, PIN-koodi, mustrit või parooli."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Kasutage oma telefoni avamiseks näoga avamise funktsiooni"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Sõrmejälg"</string>
    <string name="fingerprint_manage_category_title" msgid="1249349505688268850">"Sõrmejälgede haldamine"</string>
    <string name="fingerprint_usage_category_title" msgid="8757959085075024856">"Sõrmej. kasutatakse:"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Sõrmejälje lisamine"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5451094461919440992">"ekraanilukk"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="6897454766137108776">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> sõrmejälge on lisatud</item>
      <item quantity="one">Sõrmejälg on lisatud</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1044059475710838504"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Sõrmejälje seadistamine"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Lubage sõrmejäljega avamine"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Sõrmejälje kasutamine"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="6100563481214337377">"Kasutage oma telefoni avamiseks või oma isiku kinnitamiseks (nt rakendustesse sisselogimisel või ostude kinnitamisel) oma sõrmejälge."</string>
    <string name="security_settings_fingerprint_enroll_introduction_consent_message" msgid="1833139688278350628">"Lubage lapsel sõrmejälje abil telefoni avada või oma isikut kinnitada. See toimub siis, kui ta üritab rakendustesse sisse logida, ostu kinnitada või teha muud."</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Teie juhite toimuvat"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Kontroll on teie ja teie lapse käes"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Pidage meeles"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_message_1" msgid="7817635368506064516">"Sõrmejäljefunktsiooni salvestatud andmed talletatakse turvaliselt ja neid ei edastata telefonist väljapoole. Seadetes võite oma andmed alati kustutada."</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_message_2" msgid="3507618608004123384">"Teie sõrmejälg võib olla ebaturvalisem kui tugev muster või PIN-kood."</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_message_3" product="default" msgid="4757472591076060066">"Telefon kasutab aeg-ajalt teie sõrmejälje hiljutisi pilte, et luua paremaid sõrmejälje mudeleid."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Kasutage telefoni avamiseks või ostude kinnitamiseks oma sõrmejälge.\n\nMärkus: te ei saa kasutada oma sõrmejälge selle seadme avamiseks. Lisateabe saamiseks võtke ühendust oma organisatsiooni administraatoriga."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Tühista"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Tänan, ei"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Nõustun"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Kas jätta sõrmejälg vahele?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Sõrmejälje seadistamiseks kulub vaid paar minutit. Kui selle vahele jätate, saab sõrmejälje hiljem lisada menüüs Seaded."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Kui näete seda ikooni, kasutage autentimiseks (nt rakendustesse sisselogimisel või ostude kinnitamisel) oma sõrmejälge"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Pidage meeles"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_1" msgid="5824014348182478279">"Telefoni avamiseks sõrmejälje kasutamine võib olla vähem turvaline kui tugev muster või PIN-kood"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Kuidas see toimib?"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Sõrmejäljega avamise funktsioon loob teie sõrmejäljest kordumatu mudeli, mille abil teie isik kinnitada. Sõrmejäljemudeli loomiseks jäädvustate seadistamise ajal kujutised oma sõrmejäljest eri asendites."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Sõrmejäljega avamise funktsioon loob teie lapse sõrmejäljest kordumatu mudeli, mille abil tema isik kinnitada. Sõrmejäljemudeli loomiseks jäädvustatakse seadistamise ajal kujutised tema sõrmejäljest eri asendites."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_3" msgid="4729142136478078228">"Kui kasutate Pixel Imprinti, kasutatakse kujutisi teie sõrmejäljemudeli värskendamiseks. Sõrmejäljemudeli loomiseks kasutatavaid kujutisi ei salvestata mitte kunagi, kuid sõrmejäljemudel salvestatakse turvaliselt teie telefoni, kust seda välja ei saadeta. Kogu töötlus toimub turvaliselt teie telefonis."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_3" msgid="5908959250804145997">"Kui ta kasutab Pixel Imprinti, kasutatakse kujutisi tema sõrmejäljemudeli värskendamiseks. Lapse sõrmejäljemudeli loomiseks kasutatavaid kujutisi ei salvestata mitte kunagi, kuid sõrmejäljemudel salvestatakse turvaliselt tema telefoni, kust seda välja ei saadeta. Kogu töötlus toimub turvaliselt telefonis."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_4" msgid="3948305045484131665">"Seadetes saate oma sõrmejäljekujutised ja -mudeli alati kustutada või sõrmejäljega avamise funktsiooni välja lülitada. Sõrmejäljekujutised ja -mudelid salvestatakse telefoni, kuni need kustutate."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_4" msgid="4983770600405797515">"Seadetes saate (või saab laps) sõrmejäljekujutised ja -mudeli alati kustutada või sõrmejäljega avamise funktsiooni välja lülitada. Sõrmejäljekujutised ja -mudelid salvestatakse telefoni, kuni need kustutatakse."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_5" msgid="2018885671994058605">"Teie telefoni saab avada, kui te seda teha ei kavatse (nt kui keegi hoiab seda teie sõrme vastas)."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_5" msgid="8356551505082794682">"Teie lapse telefoni saab avada, kui ta seda teha ei kavatse (nt kui keegi hoiab seda tema sõrme vastas)."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_try_adjusting" msgid="3855444121278320304">"Muutke iga kord pisut oma sõrme asendit"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_partially_detected" msgid="8330287007361798356">"Katke ikoon oma sõrmejälje keskosaga"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_already_enrolled" msgid="8616678833080422946">"See sõrmejälg on juba lisatud"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_clean_sensor" msgid="3501453094314993113">"Puhastage ekraani anduri ümbruses ja proovige uuesti"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_too_fast" msgid="5891227328100822018">"Tõstke sõrm ekraanilt, kui tunnete vibratsiooni"</string>
    <string name="security_settings_fingerprint_v2_enroll_acquire_too_bright" msgid="769646735950329315">"Minge kohta, kus on mahedam valgus, ja proovige uuesti"</string>
    <string name="security_settings_fingerprint_v2_enroll_error_max_attempts" msgid="1464972470750764128">"Olete teinud maksimaalse arvu katseid"</string>
    <string name="security_settings_fingerprint_v2_home_screen" msgid="1709655966777714761">"Kasutage oma sõrmejälge telefoni avamiseks või oma isiku kinnitamiseks (nt rakendustesse sisselogimisel)\n\n"<annotation id="url">"Lisateave"</annotation></string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Näo ja sõrmejäljega avamine"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="6941188982863819389">"Puudutage seadistamiseks"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Nägu ja sõrmejäljed on lisatud"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Nägu ja sõrmejälg on lisatud"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Kui seadistate näoga ja sõrmejäljega avamise, küsib telefon teie sõrmejälge, kui kannate maski või olete hämaras."</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Võimalused avamiseks"</string>
    <string name="biometric_settings_category_ways_to_use" msgid="2730401752914580200">"Kasuta nägu ja sõrmejälge:"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="2002278066540969480">"Telefoni avamine"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="5251210618011579314">"Autentimine rakendustes"</string>
    <string name="biometric_settings_hand_back_to_guardian" msgid="3747619291972376153">"Anna telefon vanema kätte tagasi"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Kas jätta ekraanilukk vahele?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1570832293693405757">"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="4618501606519351904">"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="2412426429887900241">"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="7119039592587429936">"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="3365990364131398523">"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="4908278819257287536">"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="3442274117023270068">"Jäta ikka vahele"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Mine tagasi"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Jäta vahele"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Tühista"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Puudutage andurit"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Kuidas sõrmejälg seadistada?"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"See asub telefoni tagaküljel. Kasutage oma nimetissõrme."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Sõrmejäljeandur on ekraani sees. Sõrmejälje jäädvustate järgmisel ekraanikuval."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Alusta"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Anduri leidmiseks liigutage sõrme ekraanil. Puudutage pikalt sõrmejäljeandurit."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Seadme joonis ja sõrmejäljeanduri asukoht"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nimi"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Kustuta"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Puudutage andurit"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Asetage oma sõrm andurile ja kui tunnete värinat, siis tõstke see üles."</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="7534383192863798967">"Hoidke sõrme anduril, kuni tunnete vibratsiooni."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Puudutage pikalt sõrmejäljeandurit"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Tõstke, seejärel puudutage uuesti"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Veel üks kord"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Järgige sõrmejälje ikooni"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Tõstke sõrme, et lisada sõrmejälje eri osad."</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="8982595794258965437">"Puudutage pikalt iga kord, kui sõrmejäljeikoon liigub. See aitab jäädvustada teie täieliku sõrmejälje."</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="7869449488918552551">"See aitab jäädvustada teie täieliku sõrmejälje."</string>
    <!-- String.format failed for translation -->
    <!-- no translation found for security_settings_udfps_enroll_progress_a11y_message (6183535114682369699) -->
    <skip />
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Sõrmejälg on lisatud"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="3469254005423998143">"Nüüd saate telefoni avamiseks või oma isiku kinnitamiseks (nt rakendustesse sisselogimisel) oma sõrmejälge kasutada"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Teen seda hiljem"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Kas jätta sõrmejälje seadistus vahele?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Valisite telefoni avamise üheks viisiks sõrmejälje kasutamise. Kui seadistamise praegu vahele jätate, peate seda tegema hiljem. See võtab ainult umbes minuti."</string>
    <string name="lock_screen_pin_skip_message" product="tablet" msgid="4938798234214623521">"PIN-kood kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_pattern_skip_message" product="tablet" msgid="4359575348578515037">"Muster kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_password_skip_message" product="tablet" msgid="5420451292764062637">"Parool kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_pin_skip_message" product="device" msgid="8841426051550671169">"PIN-kood kaitseb seadet juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_pattern_skip_message" product="device" msgid="6296702954920045923">"Muster kaitseb seadet juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_password_skip_message" product="device" msgid="9186075211441188900">"Parool kaitseb seadet juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_pin_skip_message" product="default" msgid="4301690296689572747">"PIN-kood kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_pattern_skip_message" product="default" msgid="7387967847446084260">"Muster kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_password_skip_message" product="default" msgid="6415788841227543063">"Parool kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse"</string>
    <string name="lock_screen_pin_skip_fingerprint_message" product="tablet" msgid="2350062798056164403">"Sõrmejäljega avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_fingerprint_message" product="tablet" msgid="222574071926747300">"Sõrmejäljega avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_fingerprint_message" product="tablet" msgid="7780323831330724644">"Sõrmejäljega avamise seadistamiseks on vaja parooli.\n\nParool kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_fingerprint_message" product="device" msgid="7421096089691939451">"Sõrmejäljega avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_fingerprint_message" product="device" msgid="6458468083711413617">"Sõrmejäljega avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_fingerprint_message" product="device" msgid="1632249532665518954">"Sõrmejäljega avamise seadistamiseks on vaja parooli.\n\nParool kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_fingerprint_message" product="default" msgid="3101384462491132314">"Sõrmejäljega avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_fingerprint_message" product="default" msgid="382422778886929469">"Sõrmejäljega avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_fingerprint_message" product="default" msgid="5515199168425229243">"Sõrmejäljega avamise seadistamiseks on vaja parooli.\n\nParool kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_face_message" product="tablet" msgid="2454239555320628731">"Näoga avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_face_message" product="tablet" msgid="4354138725903415816">"Näoga avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_face_message" product="tablet" msgid="719339718267952196">"Näoga avamise seadistamiseks on vaja parooli.\n\nParool kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_face_message" product="device" msgid="3729243407606881750">"Näoga avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_face_message" product="device" msgid="6966329744346503807">"Näoga avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_face_message" product="device" msgid="3020827854443297996">"Näoga avamise seadistamiseks on vaja parooli.\n\nParool kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_face_message" product="default" msgid="2155678903559865476">"Näoga avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_face_message" product="default" msgid="473271568005748452">"Näoga avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_face_message" product="default" msgid="4319934862372116788">"Näoga avamise seadistamiseks on vaja parooli.\n\nParool kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_biometrics_message" product="tablet" msgid="647987565338402155">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_biometrics_message" product="tablet" msgid="5293609077890072841">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_biometrics_message" product="tablet" msgid="2660359318928684172">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja parooli.\n\nParool kaitseb tahvelarvutit juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_biometrics_message" product="device" msgid="1278795063897397815">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_biometrics_message" product="device" msgid="8766169819759371801">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_biometrics_message" product="device" msgid="8611216039321306045">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja parooli.\n\nParool kaitseb seadet juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_biometrics_message" product="default" msgid="8796878521409329051">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja PIN-koodi.\n\nPIN-kood kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pattern_skip_biometrics_message" product="default" msgid="8423700958936341596">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja mustrit.\n\nMuster kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_password_skip_biometrics_message" product="default" msgid="5411689248299854172">"Näoga avamise ja sõrmejäljega avamise seadistamiseks on vaja parooli.\n\nParool kaitseb telefoni juhul, kui see läheb kaotsi või varastatakse."</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Kas jätta PIN-koodi määramine vahele?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Kas soovite PIN-koodi ja näo seadistuse vahele jätta?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Kas soovite PIN-koodi ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Kas soovite PIN-koodi, näo ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Kas jätta parooli määramine vahele?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Kas soovite parooli ja näo seadistuse vahele jätta?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Kas soovite parooli ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Kas soovite parooli, näo ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Kas jätta mustri määramine vahele?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Kas soovite mustri ja näo vahele jätta?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Kas soovite mustri ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Kas soovite mustri, näo ja sõrmejälje seadistuse vahele jätta?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Seadista ekraanilukk"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Valmis"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Vabandust, see pole andur"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Puud. telefoni tagaküljel asuvat andurit. Kasut. oma nimetissõrme."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="132085362209418770">"Registreerimist ei lõpetatud"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="5479647886550695766">"Sõrmejälje registreerimisaeg lõppes. Proovige uuesti."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"Sõrmejälje registreerimine ei toiminud. Proovige uuesti või kasutage teist sõrme."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Lisa veel üks"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Järgmine"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="7875826823637114097">"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="4260983700868889294">" 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="2590665137265458789">"Tõstke sõrme, seejärel puudutage sõrmejäljeandurit uuesti"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="598502302101068608">"Sõrmejäljeandurit ei saa kasutada. Külastage remonditeenuse pakkujat"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Saate lisada kuni <xliff:g id="COUNT">%d</xliff:g> sõrmejälge"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Olete lisanud maksimaalse arvu sõrmejälgi"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Rohkem sõrmejälgi ei saa lisada"</string>
    <string name="fingerprint_last_delete_title" msgid="4081475675646514726">"Kas eemaldada kõik sõrmejäljed?"</string>
    <string name="fingerprint_delete_title" msgid="1469865327307917858">"Sõrmejälje „<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>” eemaldamine"</string>
    <string name="fingerprint_delete_message" msgid="1454995433333496541">"Kas soovite selle sõrmejälje kustutada?"</string>
    <string name="fingerprint_v2_delete_message" msgid="4136720729608391131">"See kustutab sõrmejäljega „<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>“ seotud sõrmejäljekujutised ja -mudeli, mis on teie seadmesse salvestatud"</string>
    <string name="fingerprint_last_delete_message" msgid="7860374760549404410">"Te ei saa oma sõrmejälge kasutades telefoni avada ega rakendustes oma isikut kinnitada."</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Te ei saa oma sõrmejälge kasutades tööprofiili avada, oste volitada ega töörakendustesse sisse logida."</string>
    <string name="fingerprint_last_delete_confirm" msgid="3294910995598819259">"Jah, eemalda"</string>
    <string name="security_settings_biometrics_title" msgid="9156091890323967944">"Näo ja sõrmejäljega avamine"</string>
    <string name="security_settings_biometrics_summary_none" msgid="7832260410376805323">"Puudutage seadistamiseks"</string>
    <string name="security_settings_biometrics_summary_face" msgid="531544670908824943">"Ainult nägu"</string>
    <string name="security_settings_biometrics_summary_fingerprint" msgid="6815851804705508275">"Ainult sõrmejälg"</string>
    <string name="security_settings_biometrics_summary_both" msgid="7328638955127876021">"Nägu ja sõrmejälg"</string>
    <string name="security_settings_biometrics_description" msgid="1669340998063178097">"Kui seadistate näo ja sõrmejäljega avamise, küsib telefon teie sõrmejälge, kui kannate maski või olete hämaras"</string>
    <string name="security_settings_biometrics_types_category" msgid="4875227478250058267">"Võimalused avamiseks"</string>
    <string name="security_settings_biometrics_preferences_category" msgid="8289089775173952237">"Kasuta nägu või sõrmejälge järgmiseks:"</string>
    <string name="security_settings_biometrics_preference_use_with_apps" msgid="4068551659594090167">"Autentimine rakendustes"</string>
    <string name="crypt_keeper_settings_title" msgid="4938812137822100044">"Krüpteerimine"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="7484150746479958376">"Tahvelarvuti krüpteerimine"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="8302873664348463041">"Telefoni krüpteerimine"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="3866488451639592071">"Krüpteeritud"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="4103951371711323192">"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="6180866043921135548">"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="5551608011810921471">"Krüpteeri tahvelarvuti"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="6370330929679426136">"Krüpteeri telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="4920087247177024521">"Laadige akut ja proovige uuesti."</string>
    <string name="crypt_keeper_unplugged_text" msgid="2709721134148651329">"Ühendage laadija ja proovige uuesti."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="1847280235529858357">"Ekraaniluku PIN-koodi või parooli ei ole"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="7210616262954236042">"Enne krüpteerimist peate määrama lukustusekraani PIN-koodi või parooli."</string>
    <string name="crypt_keeper_confirm_title" msgid="8600000209722452230">"Kas krüpteerida?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="3270587498436152259">"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="3040428543349852419">"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="3339725741305796680">"Krüpteerimine"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="4417016995091289019">"Oodake, kuni teie tahvelarvutit krüpteeritakse. <xliff:g id="PERCENT">^1</xliff:g>% valmis."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="7902355422499500352">"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="8348188415839917821">"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="8556105766597855198">"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="3832496715430327682">"Tahvelarvuti avamiseks lülitage see välja ja uuesti sisse."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="5070346039522135361">"Telefoni avamiseks lülitage see välja ja uuesti sisse."</string>
    <string name="crypt_keeper_warn_wipe" msgid="8104921337301750394">"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="1274917431075529732">"Sisestage parool"</string>
    <string name="crypt_keeper_failed_title" msgid="8173654570682244149">"Krüptimine ebaõnnestus"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="5977961188966570342">"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="1028716993071131029">"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="5920153462176846037">"Dekrüpteerimine ebaõnnestus"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="4420666705959562753">"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="3200498792238652367">"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="7712732134989470573">"Sisestusmeetodi vahetamine"</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Tagage oma telefoni turvalisus"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="3213718550422761562">"Määrake tahvelarvuti kaitsmiseks ekraanilukk"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="8479766049078378225">"Määrake seadme kaitsmiseks ekraanilukk"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="2443273582716671033">"Määrake telefoni kaitsmiseks ekraanilukk"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Avamiseks lisage sõrmejälg"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="1040265358906410746"></string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Ekraaniluku valimine"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Valige ekraanilukk"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Valige uus ekraanilukk"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Valige töörakendustele lukk"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Valige uus tööprofiili lukk"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="1276283007274778191">"Tahvelarvuti kaitsmine"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="3585905639045649905">"Seadme kaitsmine"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="2758197863515864300">"Telefoni kaitsmine"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Lisaturvalisuse huvides seadistage varuekraanilukk"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="4870877800737248926">"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="8961855222808442301">"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="8867435145945818970">"Aktiveerige seadme kaitsefunktsioonid, et teised ei saaks ilma teie loata telefoni kasutada. Valige kasutatav ekraanilukk."</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Valige oma ekraaniluku varumeetod"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="7769526424722627301">"Teie IT-administraator ei saa seda lukku lähtestada. <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Seadistage selle asemel eraldi tööprofiili lukk<xliff:g id="LINK_END_1">LINK_END</xliff:g>"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Kui unustate selle luku, paluge IT-administraatoril see lähtestada"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Ekraaniluku valikud"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Ekraaniluku valikud"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Ekraanilukk"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5799070517574360310">"<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="4572132216801894216">"<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="7631371082326055429">"Tööprofiili lukk"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="4746783679112447948">"Ekraaniluku muutmine"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="6023813780512501969">"Muuda või keela mustri, PIN-koodi või parooli turve"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="1699993191343299179">"Valige ekraani lukustamise meetod"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Puudub"</string>
    <string name="unlock_set_unlock_off_summary" msgid="4578319976164001322"></string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Pühkimine"</string>
    <string name="unlock_set_unlock_none_summary" msgid="641298008390890152">"Turvamata"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Muster"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="4482018884090552709">"Keskmine turvalisus"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN-kood"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="1961863114590024945">"Keskmine kuni kõrge turvalisus"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Parool"</string>
    <string name="unlock_set_unlock_password_summary" msgid="7647435233968707432">"Kõrge turvalisus"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Mitte praegu"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Praegune ekraanilukk"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"Sõrmejälg + muster"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"Sõrmejälg + PIN-kood"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"Sõrmejälg + parool"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Jätkamine ilma sõrmejäljeta"</string>
    <string name="fingerprint_unlock_title" msgid="4978686534505944042">"Telefoni saate avada oma sõrmejäljega. Turvalisuse tagamiseks nõuab see valik varuekraanilukku."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="3117316407679805330">"Näoga avamine + muster"</string>
    <string name="face_unlock_set_unlock_pin" msgid="5300188327595503657">"Näoga avamine + PIN-kood"</string>
    <string name="face_unlock_set_unlock_password" msgid="8395722611524617956">"Näoga avamine + parool"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Jätka ilma näoga avamiseta"</string>
    <string name="face_unlock_title" msgid="7344830351598247267">"Telefoni võite avada oma näoga. Turvalisuse tagamiseks nõuab see valik varuekraanilukku."</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Muster • Nägu • Sõrmejälg"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"PIN-kood • Nägu • Sõrmejälg"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Parool • Nägu • Sõrmejälg"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Jätka ilma näo või sõrmejäljeta"</string>
    <string name="biometrics_unlock_title" msgid="616524056055233041">"Saate oma telefoni avada näo või sõrmejäljega. Turvalisuse tagamiseks nõuab see valik varuekraanilukku."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="4022867760387966129">"Administraator, krüpteerimiseeskirjad või mandaatide salvestusruum on selle keelanud"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Puudub"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Pühkimine"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Muster"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN-kood"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Parool"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="5974580769186206478">"Kui olete ekraaniluku seadistanud, saate menüüs Seaded &gt; Turvalisus seadistada ka oma sõrmejälje."</string>
    <string name="unlock_disable_lock_title" msgid="2564279819907932759">"Lülita ekraanilukk välja"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Kas kustutada ekraanilukk?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Kas eemaldada profiili kaitsefunktsioonid?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Muster kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Muster kaitseb teie telefoni olukorras, kus see läheb kaotsi või varastatakse.<xliff:g id="EMPTY_LINE">

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

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

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

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

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

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

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

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

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

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

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

</xliff:g>See kustutab teie seadmesse salvestatud sõrmejäljemudeli. Samuti kustutatakse jäädavalt ja turvaliselt teie näomudel. Te ei saa oma nägu ega sõrmejälge rakendustes autentimiseks kasutada."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Kustuta"</string>
    <string name="unlock_change_lock_pattern_title" msgid="8234523589333929193">"Avamismustri muutmine"</string>
    <string name="unlock_change_lock_pin_title" msgid="2324077520816477479">"Muuda avamise PIN-koodi"</string>
    <string name="unlock_change_lock_password_title" msgid="873517913969091074">"Avamisparooli muutmine"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab keerukat PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut mustrit, PIN-koodi või parooli ega pruugi ilma selleta oodatud viisil töötada"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> soovitab uut ekraanilukku"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Proovige uuesti. Katse <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>/<xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>-st."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Teie andmed kustutatakse"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Kui sisestate järgmisel katsel vale mustri, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Kui sisestate järgmisel katsel vale parooli, kustutatakse selle seadme andmed"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Kui sisestate järgmisel katsel vale mustri, kustutatakse see kasutaja"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse see kasutaja"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Kui sisestate järgmisel katsel vale parooli, kustutatakse see kasutaja"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Kui sisestate järgmisel katsel vale mustri, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Kui sisestate järgmisel katsel vale PIN-koodi, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Kui sisestate järgmisel katsel vale parooli, kustutatakse teie tööprofiil ja selle andmed"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="2813744895409014471">"Liiga palju valesid katseid. Selle seadme andmed kustutatakse."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="3958755474620948727">"Liiga palju valesid katseid. See kasutaja kustutatakse."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="3171880997211568208">"Liiga palju valesid katseid. See tööprofiil ja selle andmed kustutatakse."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="170155081899679669">"Sule"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="2192234965414232157">
      <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="6817086810898414162">
      <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="2507983991979547816">"Jätka"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="8118091957172967677">
      <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="8706992338720310765">
      <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_recently_used" msgid="6650277060998923465">"Seadme administraator ei luba kasutada viimast PIN-koodi"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"See ei tohi sisaldada sobimatut tähemärki"</string>
    <string name="lockpassword_password_requires_alpha" msgid="721084100957669018">"Peab sisaldama vähemalt ühte tähte"</string>
    <string name="lockpassword_password_requires_digit" msgid="312518567592683795">"Peab sisaldama vähemalt ühte numbrit"</string>
    <string name="lockpassword_password_requires_symbol" msgid="6178512486154701321">"Peab sisaldama vähemalt ühte sümbolit"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="2385916409676839024">
      <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="2057467885488612701">
      <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="4541266279643052025">
      <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="70617964591376248">
      <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="7981236881269921943">
      <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="1567877061888948467">
      <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>
    <plurals name="lockpassword_password_requires_nonnumerical" formatted="false" msgid="5056743974888384475">
      <item quantity="other">Peab sisaldama vähemalt <xliff:g id="COUNT">%d</xliff:g> tähemärki, mis ei ole number</item>
      <item quantity="one">Peab sisaldama vähemalt 1 tähemärki, mis ei ole number</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Seadme administraator ei luba kasutada hiljutist parooli"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Kasvavad, kahanevad või korduvad numbrijadad on keelatud"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Kinnita"</string>
    <string name="lockpassword_cancel_label" msgid="6711112212489992112">"Tühista"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Kustuta"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Ekraanilukk on juba muudetud. Proovige uue ekraanilukuga veel kord."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Tühista"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Järgmine"</string>
    <string name="lock_setup" msgid="4622999020926280737">"Seadistamine on lõpetatud."</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Seadme admin. rakendused"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Aktiivseid rakendusi ei ole"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="2528735319390151989">
      <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="6410149930029992356">"Usaldusväärsed agendid"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Kasutamiseks määrake kõigepealt ekraanilukk"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Mitte ükski"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="5438047398376802735">
      <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="5955341060378240781">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5257744297562880017">"Lülitage Bluetooth sisse"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="6805458703566046784">"Halda ühendusi, määra seadme nimi ja leitavus"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Kas siduda seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetoothi sidumiskood"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Sisestage sidumiskood ja vajutage seejärel sisestusklahvi"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN-kood sisaldab tähti või sümboleid"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Tavaliselt 0000 või 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Peab olema 16-kohaline"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Võib-olla peate selle PIN-koodi sisestama ka teise seadmesse."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Võib-olla peate selle parooli sisestama ka teise seadmesse."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="327192310468680072">"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="1068123527866596779">"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="8672803845151786521">"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="4329325125260724843">"Luba juurdepääs kontaktidele ja kõneajaloole"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ei saanud ühendust."</string>
    <string name="bluetooth_preference_scan_title" msgid="3460316252463771851">"Otsi seadmeid"</string>
    <string name="bluetooth_search_for_devices" msgid="6516902340975407648">"Värskenda"</string>
    <string name="bluetooth_searching_for_devices" msgid="6541984133657573124">"Otsimine ..."</string>
    <string name="bluetooth_preference_device_settings" msgid="1688662188157019998">"Seadme seaded"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="1090131276572055841">"Seotud seade"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="4337953030661626289">"Interneti-ühendus"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="8247634441638919886">"Klaviatuur"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="8194423860397844579">"Kontaktid ja kõneajalugu"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="6106058683134173178">"Kas siduda selle seadmega?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="5472835166206721325">"Kas jagada telefoniraamatut?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="7516277926581535299">"<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="1545098121090892788">"<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="830061195998352840">"Saadaval seadmed"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="1331122763066030155">"Ühtegi seadet pole saadaval"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Ühenda"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Katkesta ühendus"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Seo ja ühenda"</string>
    <string name="bluetooth_device_context_unpair" msgid="7525735305244087162">"Seo lahti"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="2001359431289794561">"Katkesta ühendus ja seo lahti"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="934657460643490773">"Valikud ..."</string>
    <string name="bluetooth_menu_advanced" msgid="7633682234855216066">"Täpsemad"</string>
    <string name="bluetooth_advanced_titlebar" msgid="5369701494951467257">"Täpsemad Bluetoothi seaded"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Kui Bluetooth on sisse lülitatud, saab seade suhelda teiste lähikonna Bluetooth-seadmetega."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="6667723887545056976">"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">"Bluetoothi skannimise seadetes"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1358879010396045164">"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="7892663424429584925">"Ühendust ei õnnestunud luua. Proovige uuesti."</string>
    <string name="device_details_title" msgid="1155622417516195481">"Seadme üksikasjad"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Seadme Bluetoothi aadress: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Kas unustada seade?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Eemalda seos"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Kas katkestada rakenduse ühendus?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="4730377171981539265">"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="3428463407231980054">"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="5117397433721336918">"Teie seade ei ole enam seotud seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> ei loo enam teie seadmega <xliff:g id="DEVICE_NAME">%2$s</xliff:g> ühendust"</string>
    <string name="bluetooth_untethered_unpair_dialog_body" msgid="1938465582242297905">"<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="9184489424930549015">"Unusta seade"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Katkesta rakenduse ühendus"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="1323072239637864488">"Ühendamine ..."</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="339103864166293612">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus meediumiheliga katkestatakse."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="7857706184371154920">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus vabakäeseadme heliga katkestatakse."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="4794752406024916925">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühendus sisendseadmega katkestatakse."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="283176886159444413">"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="733193449967330892">"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="7852265676243153982">"Telefoni internetiühenduse jagamine seadmega <xliff:g id="DEVICE_NAME">%1$s</xliff:g> katkestatakse."</string>
    <string name="bluetooth_device_advanced_title" msgid="1181664272013729515">"Seotud Bluetooth-seade"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="8302236592496988747">"Ühenda"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="271856759516576615">"Ühenda Bluetooth-seadmega"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="7892879890208207223">"Kasutus:"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="4798081898389041132">"Nimeta ümber"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="7604726126703453984">"Luba sissetul. failiedastused"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="7851033200857999275">"Interneti kasutamiseks seadmega ühend."</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="5563892893331988809">"Kohaliku Interneti-ühenduse jagamine seadmega"</string>
    <string name="bluetooth_dock_settings" msgid="1709536202189755022">"Doki seaded"</string>
    <string name="bluetooth_dock_settings_title" msgid="4872789068019972847">"Kasutage heli jaoks dokki"</string>
    <string name="bluetooth_dock_settings_headset" msgid="5756482379574272554">"Kõlartelefonina"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="434520221656010141">"Muusika ja meediumi jaoks"</string>
    <string name="bluetooth_dock_settings_remember" msgid="6993526033095292609">"Jäta seaded meelde"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maksimaalne arv ühendatud Bluetoothi heliseadmeid"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Maksimaalse arvu ühendatud Bluetoothi heliseadmete valimine"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Ülekandmine"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"peegeldamine"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Luba juhtmeta ekraaniühendus"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Läheduses olevaid seadmeid ei leitud."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Ühendamine"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Ühendatud"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Kasutusel"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Pole saadaval"</string>
    <string name="wifi_display_details" msgid="2351632307998142920">"Kuvaseaded"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Juhtmeta ekraaniühenduse valikud"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Unusta"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Valmis"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nimi"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Logi sisse"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Ava sait"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> on jäänud"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Aegub <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_tap_to_sign_in" msgid="8658506618807549483">"Puudutage siin, et võrku sisse logida"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"Rakendus <xliff:g id="REQUESTER">%s</xliff:g> soovib WiFi sisse lülitada"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"Rakendus <xliff:g id="REQUESTER">%s</xliff:g> soovib WiFi välja lülitada"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Silutavate rakenduste baidikoodi kinnitamine"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Luba ART silutavate rakenduste baidikoodi kinnitamiseks"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Kuva värskendussagedus"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Kuva ekraani praegune värskendussagedus"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="3622326550467939809">"Lubab andmevahetuse, kui tahvelarvuti puudutab NFC-seadet"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="1460871052409162980">"Lubab andmevahetuse, kui telefon puudutab NFC-seadet"</string>
    <string name="nfc_disclaimer_title" msgid="3696580694485048039">"NFC sisselülitamine"</string>
    <string name="nfc_disclaimer_content" msgid="8256675597551036207">"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="4906958426927741485">"Nõua NFC puhul seadme avamist"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="407654335737959071">"NFC kasutuse lubamine vaid siis, kui ekraan on avatud"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Valmis edastama rakenduse sisu NFC kaudu"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Väljas"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Pole saadaval, kuna NFC on välja lülitatud"</string>
    <string name="android_beam_label" msgid="7168565080321110094">"Android Beam"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Kui see funktsioon on sisse lülitatud, saate rakenduse sisu teise NFC-toega seadmesse saata, kui hoiate seadmeid üksteise lähedal. Nii saate edastada näiteks veebilehti, YouTube\'i videoid, kontakte ja muud.\n\nLihtsalt hoidke seadmeid lähestikku (tavaliselt tagakülgi koos) ja seejärel puudutage seadme ekraani. Rakendus määrab, mida edastatakse."</string>
    <string name="wifi_quick_toggle_title" msgid="2737097538432862807">"WiFi"</string>
    <string name="wifi_quick_toggle_summary" msgid="4957267477820468553">"Lülita WiFi sisse"</string>
    <string name="wifi_settings" msgid="8313301946393559700">"WiFi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"WiFi kasutus"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"WiFi-seaded"</string>
    <string name="wifi_settings_title" msgid="3879649725059512799">"WiFi"</string>
    <string name="wifi_settings_summary" msgid="784074686763572811">"Määra ja halda traadita pääsupunkte"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"WiFi valimine"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"WiFi sisselülitamine ..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"WiFi väljalülitamine ..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Viga"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz riba pole selles riigis saadaval"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Lennurežiimis"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Teavita avalike võrkude puhul"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Teavita, kui kvaliteetne avalik võrk on saadaval"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Lülita WiFi automaatselt sisse"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"WiFi lülitub uuesti sisse kvaliteetsete salvestatud võrkude, näiteks teie koduse võrgu läheduses"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Pole saadaval, sest asukoha otsimine on välja lülitatud. Lülitage valik "<annotation id="link">"Asukoht"</annotation>" sisse."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="1771489741850119751">"Pole saadaval, kuna WiFi-skannimine on välja lülitatud"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="3615120120960539780">"Funktsiooni kasutamiseks valige võrgukvaliteedi hinnangute pakkuja"</string>
    <string name="wifi_poor_network_detection" msgid="8210035875160288422">"Väldi halbu ühendusi"</string>
    <string name="wifi_poor_network_detection_summary" msgid="383834617032605347">"Ära kasuta WiFi-võrku, kui selle Interneti-ühendus on halb"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4993203473116721772">"Kasuta ainult võrke, millel on hea Interneti-ühendus"</string>
    <string name="use_open_wifi_automatically_title" msgid="7193846454986712009">"Ühenda avalike võrkudega"</string>
    <string name="use_open_wifi_automatically_summary" msgid="6663890845558591023">"Loo automaatselt ühendus kvaliteetsete avalike võrkudega"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="2299284032301667622">"Funktsiooni kasutamiseks valige võrgukvaliteedi hinnangute pakkuja"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="1780306481499369913">"Funktsiooni kasutamiseks valige sobiv võrgukvaliteedi hinnangute pakkuja"</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Installi sertifikaate"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Asukoha täpsuse parandamiseks võivad rakendused ja teenused siiski alati otsida WiFi-võrke isegi siis, kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks. Seda saab muuta <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>WiFi-skannimise seadetes<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Asukoha täpsuse parandamiseks lülitage <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>WiFi-skannimise seadetes<xliff:g id="LINK_END_1">LINK_END</xliff:g> WiFi-skannimine sisse."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="8436897497968907701">"Ära kuva uuesti"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="6285374200292675649">"Hoia WiFi unerežiimis sees"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8753852404141070878">"WiFi on unerež. sisselülitatud"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="4512566787805720422">"Seade muutmisel tekkis probleem"</string>
    <string name="wifi_suspend_efficiency_title" msgid="3589291227092825754">"Tõhusamaks muutmine"</string>
    <string name="wifi_suspend_optimizations" msgid="5840680940416640209">"WiFi optimeerimine"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="8204170804523356781">"Minimeeri aku kasutamine, kui WiFi on sees"</string>
    <string name="wifi_limit_optimizations_summary" msgid="8461087338100462302">"Piira WiFi akukasutust"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="681353878530696197">"Kui WiFi kaotab juurdepääsu Internetile, lülita mobiilsele andmesidele."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Lülita automaatselt mobiilsele andmesidele"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Kui WiFi-l puudub Internetile juurdepääs, kasutatakse mobiilset andmesidet. Rakenduda võivad andmekasutustasud."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Võrgu lisamine"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"WiFi-eelistused"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"WiFi lülitub automaatselt tagasi sisse"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"WiFi ei lülitu automaatselt uuesti sisse"</string>
    <string name="wifi_access_points" msgid="5846755709207101844">"WiFi-võrgud"</string>
    <string name="wifi_menu_more_options" msgid="1236651929987819716">"Rohkem valikuid"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"WiFi Direct"</string>
    <string name="wifi_menu_scan" msgid="3498653582115656526">"Skannimine"</string>
    <string name="wifi_menu_advanced" msgid="1940919392030994019">"Täpsemalt"</string>
    <string name="wifi_menu_configure" msgid="352423980467311427">"Seadistamine"</string>
    <string name="wifi_menu_connect" msgid="7824796427932811078">"Loo võrguühendus"</string>
    <string name="wifi_menu_remember" msgid="8639523871321603112">"Jäta võrk meelde"</string>
    <string name="wifi_menu_forget" msgid="6557142984528657361">"Unusta võrk"</string>
    <string name="wifi_menu_modify" msgid="7246143391161038875">"Võrgu muutmine"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Võrkude kuvamiseks lülitage WiFi sisse."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Võrkude otsimine …"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Teil pole WiFi-võrgu muutmiseks luba."</string>
    <string name="wifi_more" msgid="8742256421693351035">"Rohkem"</string>
    <string name="wifi_setup_wps" msgid="4303694722593999931">"Automaatseadistus (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Kas lülitada WiFi-skannimine sisse?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"WiFi automaatseks sisselülitamiseks peate esmalt lülitama WiFi-skannimise sisse."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"WiFi-skannimine lubab rakendustel ja teenustel alati otsida WiFi-võrke, isegi kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Lülita sisse"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"WiFi-skannimine on lülitatud sisse"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Täpsemad valikud"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rippmenüü loend Täpsemad valikud"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"laienda"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Võrgu nimi"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Sisestage SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Turvalisus"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Peidetud võrk"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Kui teie ruuter ei edasta võrgu-ID-d, kuid soovite võrguga tulevikus ühenduse luua, võite võrgu peita.\n\nSee võib tekitada turvariski, kuna teie telefon edastab võrgu leidmiseks pidevalt signaali.\n\nVõrgu peitmisel ruuteri seadeid ei muudeta."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Signaali tugevus"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Olek"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Saatmiskanali kiirus"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Vastuvõtukanali kiirus"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Lingi kiirus"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Sagedus"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP-aadress"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Salvestusviis:"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Üksuse <xliff:g id="NAME">%1$s</xliff:g> mandaat"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP meetod"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"2. etapi autentimine"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA-sertifikaat"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Sertifikaadi olek onlainis"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domeen"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Kasutaja sertifikaat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identiteet"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonüümne identiteet"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Parool"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Kuva parool"</string>
    <string name="wifi_ap_band_config" msgid="1589020070150933055">"AP-riba valimine"</string>
    <string name="wifi_ap_choose_auto" msgid="8944442003151215691">"Automaatne"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4 GHz riba"</string>
    <string name="wifi_ap_choose_5G" msgid="8413248472288180075">"5,0 GHz riba"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Eelistatud on 5,0 GHz riba"</string>
    <string name="wifi_ap_2G" msgid="4099628221864343015">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="3493942667238551207">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="5221193733812493435">"Valige WiFi-kuumkoha lubamiseks vähemalt üks sagedusriba:"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP-seaded"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privaatsus"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Tellimus"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Tellimuse vaatamine või muutmine"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Juhulikustatud MAC-aadress"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Seadme lisamine"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Seadme võrku „<xliff:g id="SSID">%1$s</xliff:g>” lisamiseks paigutage QR-kood allolevas aknas keskele"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"QR-koodi skannimine"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Võrguga „<xliff:g id="SSID">%1$s</xliff:g>” ühenduse oomiseks paigutage QR-kood allolevas aknas keskele"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Liituge WiFi-võrguga, skannides QR-koodi"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"WiFi jagamine"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Võrguga „<xliff:g id="SSID">%1$s</xliff:g>” liitumiseks skannige see QR-kood teise seadmega"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Võrguga „<xliff:g id="SSID">%1$s</xliff:g>” ühenduse loomiseks skannige see QR-kood"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Proovige uuesti. Kui see probleem jätkub, võtke ühendust seadme tootjaga"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Midagi läks valesti"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Veenduge, et seade oleks ühendatud, laetud ja sisse lülitatud"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Veenduge, et seade oleks ühendatud, laetud ja sisse lülitatud. Kui see probleem jätkub, võtke ühendust seadme tootjaga"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"See seade ei toeta SSID „<xliff:g id="SSID">%1$s</xliff:g>” lisamist"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Liigutage seade WiFi-pääsupunktile/-ruuterile lähemale"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Kontrollige parooli ja proovige uuesti"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Võtke ühendust seadme tootjaga"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Kontrollige ühendust ja proovige uuesti"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Võrgu valimine"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Oma seadme ühendamiseks valige võrk"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Kas lisada see seade võrku „<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"WiFi-t jagatakse seadmega"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Lisa teine seade"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Valige mõni teine võrk"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Seadet ei õnnestunud lisada"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Leiti seade"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"WiFi-võrgu jagamine selle seadmega …"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Ühendamine …"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Kuumkoha jagamine"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Kinnitage, et see olete teie"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"WiFi-võrgu parool: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Kuumkoha parool: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automaatne ühendamine"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Luba levialas selle võrguga ühendamine"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Seadme lisamine"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Kasutage sellesse võrku seadme lisamiseks QR-koodi"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR-kood ei ole sobilik vorming"</string>
    <string name="retry" msgid="7542103800274026915">"Proovi uuesti"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Jaga seadme teiste kasutajatega"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(muutmata)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Valige"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Lisati mitu sertifikaati)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Kasuta süsteemi sertifikaate"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Ära esita"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4673867078988209732">"Ära kinnita"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Võrgu nimi on liiga pikk."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Domeeni määramine on kohustuslik."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Sertifikaat on nõutav."</string>
    <string name="wifi_wps_available_first_item" msgid="5780501151792036589">"WPS on saadaval"</string>
    <string name="wifi_wps_available_second_item" msgid="1717024103303480804">" WPS on saadaval"</string>
    <string name="wifi_carrier_connect" msgid="4511538300946413213">"Operaatori WiFi-võrk"</string>
    <string name="wifi_carrier_content" msgid="2876499905644083615">"Ühendage operaatori <xliff:g id="NAME">%1$s</xliff:g> kaudu"</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Täpsema asukoha ja muude toimingute jaoks tahab rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> võrkude skannimise sisse lülitada, isegi kui WiFi on välja lülitatud.\n\nKas lubada see kõigi rakenduste jaoks, mis skannida tahavad?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Täpsema asukoha ja muude toimingute jaoks tahab tundmatu rakendus võrkude skannimise sisse lülitada, isegi kui WiFi on välja lülitatud.\n\nKas lubada see kõigi rakenduste jaoks, mis skannida tahavad?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="93691286302680448">"Väljalülitamiseks avage ületäitemenüüs valik Täpsemad."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Luba"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Keela"</string>
    <string name="wifi_hotspot_title" msgid="1918712370697971229">"Kas logida sisse, et ühendada?"</string>
    <string name="wifi_hotspot_message" msgid="5245614124614833169">"<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="1916314048788438331">"ÜHENDA"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Sellel võrgul puudub juurdepääs Internetile. Kas soovite ühenduse säilitada?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Mõned rakendused ja teenused ei pruugi piiratud ühenduse tõttu töötada. Kas soovite siiski kasutada?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ära selle võrgu puhul uuesti küsi"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"WiFi pole Internetiga ühendatud"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Kui WiFi-ühendus on halb, võite aktiveerida mobiilsidevõrgu. Andmekasutus võib olla tasuline."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Lülita mobiilsidevõrku"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Kasuta edasi WiFi-t"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Ära näita enam kunagi"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Ühenda"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"WiFi on sisse lülitatud"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Ühendatud võrguga <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Ühendamine võrguga <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Ühendamine …"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Võrguga ühenduse loomine ebaõnnestus"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Te ei ole võrgu levialas"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Unusta"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Muuda"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Võrgu unustamine ebaõnnestus"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Salvesta"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Võrgu säilitamine ebaõnnestus"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Tühista"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Kas unustada võrk?"</string>
    <string name="wifi_forget_dialog_message" msgid="8419499588321940243">"Kõik selle võrgu paroolid kustutatakse"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="2802436466732147888">
      <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="5802057518058840450">
      <item quantity="other">%d tellimust</item>
      <item quantity="one">Üks tellimus</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="5125849180309374451">
      <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="1234150304285575798">"Täpsemad WiFi-seaded"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Seadme MAC-aadress"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Juhulikustatud MAC-aadress"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Juhuslikustatud MAC-aadress (viimati kasutatud)"</string>
    <string name="wifi_advanced_ip_address_title" msgid="4265355419782184514">"IP-aadress"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Võrgu üksikasjad"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Alamvõrgu mask"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Tüüp"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6-aadressid"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Salvestatud võrgud"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Tellimused"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Muud võrgud"</string>
    <string name="wifi_advanced_settings_label" msgid="5880605751602184383">"IP-seaded"</string>
    <string name="wifi_advanced_not_available" msgid="8701003884367299092">"WiFi täpsemad seaded pole selle kasutaja jaoks saadaval"</string>
    <string name="wifi_ip_settings_menu_save" msgid="5190481040428567106">"Salvesta"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="1757817733064004598">"Tühista"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Sisestage kehtiv IP-aadress."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Sisestage kehtiv lüüsi aadress."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Sisestage kehtiv DNS-aadress."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Sisestage võrgu eesliide pikkusega 0 kuni 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (kui privaatne DNS pole seda alistanud)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (kui privaatne DNS pole seda alistanud)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Lüüs"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Võrgu prefiksi pikkus"</string>
    <string name="wifi_type_11AX" msgid="6594656203096598812">"6. põlvkonna WiFi"</string>
    <string name="wifi_type_11AC" msgid="5290409766357395104">"5. põlvkonna WiFi"</string>
    <string name="wifi_type_11N" msgid="4758480232958990793">"4. põlvkonna WiFi"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"WiFi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="4304362679971797283">"Seadme teave"</string>
    <string name="wifi_p2p_persist_network" msgid="7942929491568227945">"Pea see ühendus meeles"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Otsi seadmeid"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Otsing …"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Nimeta seade ümber"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Võrdõigusvõrgu seadmed"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Meeldejäetud rühmad"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Ühenduse loomine ebaõnnestus."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Seadme ümbernimetamine ebaõnnestus."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Kas katkestada ühendus?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Kui katkestate ühenduse, siis katkeb ühendus seadmega <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Kui katkestate ühenduse, siis lõpeb ühendus seadmega <xliff:g id="PEER_NAME">%1$s</xliff:g> ja veel <xliff:g id="PEER_COUNT">%2$s</xliff:g> seadmega."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Kas tühistada kutse?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Kas soovite tühistada kutse kasutajaga <xliff:g id="PEER_NAME">%1$s</xliff:g> ühenduse loomiseks?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Kas unustada see rühm?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"WiFi-kuumkoht"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Internetiühendust ega sisu ei jagata teiste seadmetega"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5832429443898690152">"Tahvelarvuti Interneti-ühendust jagatakse kuumkoha kaudu"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5451921191609178326">"Telefoni Interneti-ühendust jagatakse kuumkoha kaudu"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="965051079784031636">"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="3685689196772398783">"Parool on määramata"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Kuumkoha nimi"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="2094754115215428892">"Kuumkoha <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g> sisselülitamine …"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="6935457127884928249">"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="9096340919454296786">"Kuumkoha parool"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Pääsupunkti sagedusriba"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="6620216295510397461">"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="3813311942370920903">"Rakendused saavad luua kuumkoha, et jagada läheduses olevate seadmetega sisu."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Lülita kuumkoht automaatselt välja"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kui ükski seade pole ühendatud"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Ühilduvuse laiendamine"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Aitab muudel seadmetel selle kuumkoha leida. Vähendab kuumkoha ühenduse kiirust."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Aitab muudel seadmetel selle kuumkoha leida. Akukasutus suureneb."</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Kuumkoha sisselülitamine ..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Kuumkoha väljalülitamine ..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> on aktiivne"</string>
    <string name="wifi_tether_failed_subtext" msgid="437190628041885500">"Mobiilse WiFi-kuumkoha viga"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7072559431286459122">"WiFi-kuumkoha seadistamine"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="9027072969831022321">"WiFi-kuumkoha seadistamine"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="1445157424926935178">"AndroidAP WPA2 PSK-kuumkoht"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Kas soovite võrgu salvestada?"</string>
    <string name="wifi_add_app_single_network_summary" product="default" msgid="6881712878537666626">"<xliff:g id="APPNAME">%1$s</xliff:g> soovib võrgu teie telefoni salvestada"</string>
    <string name="wifi_add_app_single_network_summary" product="tablet" msgid="8455616967601552440">"<xliff:g id="APPNAME">%1$s</xliff:g> soovib võrgu teie tahvelarvutisse salvestada"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Salvestamine …"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Salvestatud"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Ei saa salvestada. Proovige uuesti."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Kas salvestada võrgud?"</string>
    <string name="wifi_add_app_networks_summary" product="default" msgid="2670215712788515167">"<xliff:g id="APPNAME">%1$s</xliff:g> soovib need võrgud teie telefoni salvestada"</string>
    <string name="wifi_add_app_networks_summary" product="tablet" msgid="2088967184512169910">"<xliff:g id="APPNAME">%1$s</xliff:g> soovib need võrgud teie tahvelarvutisse salvestada"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Salvestatakse <xliff:g id="NUMBER">%d</xliff:g> võrku …"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Võrgud salvestati"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"WiFi-kõned"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Suurendage WiFi abil helistamisulatust"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Lülitage WiFi-kõned sisse, et ulatust suurendada"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Kõne-eelistus"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Kõne-eelistus"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Rändluse eelistus"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Rändluse eelistus"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"WiFi"</item>
    <item msgid="8622872038388687383">"Mobiilne andmeside"</item>
    <item msgid="3027927219952052398">"Ainult WiFi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"WiFi"</item>
    <item msgid="7566603075659706590">"Mobiilne andmeside"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Kasuta mobiilsidevõrku, kui WiFi ei ole saadaval"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Kasuta WiFi-ühendust, kui mobiilsidevõrk ei ole saadaval"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Helistage WiFi-võrgu kaudu. WiFi-ühenduse katkemisel kõne lõpeb."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Kui WiFi-kõned on sisse lülitatud, saab telefon olenevalt eelistustest ja signaalitugevusest kõnesid marsruutida WiFi-võrkude või teie operaatori võrgu kaudu. Enne selle funktsiooni sisselülitamist uurige operaatorilt tasude ja muude üksikasjade kohta. <xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="3490633500025717573">"Hädaolukorra aadress"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Seda kasutatakse WiFi kaudu hädaabikõne tegemisel teie asukohana"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Lisateave"</annotation>" privaatse DNS-i funktsioonide kohta"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Sees"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="129524064888622179">"Seadet haldab operaator"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktiveerige WiFi-kõned"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Lülitage WiFi-kõned sisse"</string>
    <string name="wifi_calling_not_supported" msgid="3303917737849393175">"Operaator %1$s ei toeta WiFi-kõnesid"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Ühendus võrguga <xliff:g id="SSID">%1$s</xliff:g> katkestati"</string>
    <string name="carrier" msgid="1755020806290963951">"Operaator"</string>
    <string name="display_settings_title" msgid="626835071804834218">"Ekraan"</string>
    <string name="sound_settings" msgid="5514582720435174014">"Heli"</string>
    <string name="all_volume_title" msgid="6196367642878437513">"Helitugevused"</string>
    <string name="musicfx_title" msgid="5458574743312283473">"Muusikaefektid"</string>
    <string name="ring_volume_title" msgid="4869034595079914541">"Helina ja märguannete helitugevus"</string>
    <string name="vibrate_in_silent_title" msgid="5076579100685867363">"Vibreeri hääletus režiimis"</string>
    <string name="notification_sound_title" msgid="8747567935870133157">"Märguande vaikeheli"</string>
    <string name="incoming_call_volume_title" msgid="8445408274513654261">"Helin"</string>
    <string name="notification_volume_title" msgid="328053763590888609">"Teatis"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1798481722572489141">"Kasuta teatiste jaoks sissetuleva kõne helitugevust"</string>
    <string name="home_work_profile_not_supported" msgid="2605589489324241338">"Tööprofiile ei toetata"</string>
    <string name="notification_sound_dialog_title" msgid="7431891669251806266">"Märguande vaikeheli"</string>
    <string name="media_volume_title" msgid="5209147840160985178">"Meedium"</string>
    <string name="media_volume_summary" msgid="4671324482655564873">"Määra muusika ja videote helitugevus"</string>
    <string name="alarm_volume_title" msgid="706302621191735343">"Äratus"</string>
    <string name="dock_settings_summary" msgid="8548721822219932359">"Ühendatud doki heliseaded"</string>
    <string name="dtmf_tone_enable_title" msgid="2241337296249130217">"Valimisklahvistiku puutetoonid"</string>
    <string name="sound_effects_enable_title" msgid="328569690466233866">"Puudutuste helid"</string>
    <string name="lock_sounds_enable_title" msgid="804365014499259673">"Ekraaniluku heli"</string>
    <string name="audio_record_proc_title" msgid="486071779724181619">"Mürasummutus"</string>
    <string name="volume_media_description" msgid="2736061076584067204">"Muusika, video, mängud ja muu meedia"</string>
    <string name="volume_ring_description" msgid="5423168446359881864">"Helin ja teated"</string>
    <string name="volume_notification_description" msgid="3241009629930030492">"Märguanded"</string>
    <string name="volume_alarm_description" msgid="156563371961039376">"Äratused"</string>
    <string name="volume_ring_mute" msgid="1445718401945149622">"Helinate ja teatiste summutamine"</string>
    <string name="volume_media_mute" msgid="1881020121757820746">"Muusika ja muude meediumide summutamine"</string>
    <string name="volume_notification_mute" msgid="2612197659377126312">"Teatiste summutamine"</string>
    <string name="volume_alarm_mute" msgid="3730895630530980760">"Äratuste summutamine"</string>
    <string name="dock_settings" msgid="4654404127402812514">"Dokk"</string>
    <string name="dock_settings_title" msgid="1276956575555480214">"Doki seaded"</string>
    <string name="dock_audio_settings_title" msgid="8294821925086965934">"Heli"</string>
    <string name="dock_audio_summary_desk" msgid="4158593887711452737">"Ühendatud töölaua doki seaded"</string>
    <string name="dock_audio_summary_car" msgid="292911654994476080">"Ühendatud autodoki seaded"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="7758416095500202500">"Tahvelarvuti on dokkimata"</string>
    <string name="dock_audio_summary_none" product="default" msgid="9056359991181743485">"Telefon dokkimata"</string>
    <string name="dock_audio_summary_unknown" msgid="5486086330763810318">"Ühendatud doki seaded"</string>
    <string name="dock_not_found_title" msgid="4721157149003423417">"Dokki ei leitud"</string>
    <string name="dock_not_found_text" product="tablet" msgid="9192097687086523411">"Enne doki heli seadistamist peate tahvelarvuti dokkima."</string>
    <string name="dock_not_found_text" product="default" msgid="2247163115146852069">"Enne doki heli seadistamist peate telefoni dokkima."</string>
    <string name="dock_sounds_enable_title" msgid="2974614136344237932">"Dokki sisestamise heli"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="468592489565539336">"Esita heli tahvelarvuti sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8121670617316301768">"Esita heli telefoni sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="7833926726878567889">"Ära esita heli tahvelarvuti sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="5560601997128422001">"Ära esita heli telefoni sisestamisel dokki või sellest eemaldamisel"</string>
    <string name="account_settings" msgid="255404935489127404">"Kontod"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Tööprofiili kontod – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Isikliku profiili kontod"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Töökonto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Isiklik konto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Otsing"</string>
    <string name="display_settings" msgid="7197750639709493852">"Ekraan"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Kuva automaatne pööramine"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Väljas"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Sees"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Sees – näopõhine"</string>
    <string name="auto_rotate_switch_face_based" msgid="7824467067774120000">"Luba näotuvastus"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Värvid"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Loomulikud"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Võimendatud"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Küllastatud"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Kohanduv"</string>
    <string name="color_mode_summary_natural" msgid="8298840714001791628">"Kasuta ainult täpseid värve"</string>
    <string name="color_mode_summary_automatic" msgid="8157885594041700275">"Eredate ja täpsete värvide vahel kohandamine"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="6413384391658481700">"Tahvelarvuti pööramisel automaatselt paigutuse ümberlülitamine"</string>
    <string name="accelerometer_summary_on" product="default" msgid="7117139542131700779">"Muuda telefoni pööramisel automaatselt orientatsiooni"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="3747370091309939684">"Tahvelarvuti pööramisel automaatselt paigutuse ümberlülitamine"</string>
    <string name="accelerometer_summary_off" product="default" msgid="4451125241783158763">"Muuda telefoni pööramisel automaatselt orientatsiooni"</string>
    <string name="brightness" msgid="6216871641021779698">"Ereduse tase"</string>
    <string name="brightness_title" msgid="5457874893085305155">"Heledus"</string>
    <string name="brightness_summary" msgid="6309641759293018049">"Reguleeri ekraani heledust"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Kohanduv eredus"</string>
    <string name="auto_brightness_summary" msgid="1737148869232725883">"Ekraanikuva eredus kohandub vastavalt keskkonnale"</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Sees"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Väljas"</string>
    <string name="auto_brightness_summary_very_low" msgid="2705445901659224330">"Eelistatav heledus on väga tume"</string>
    <string name="auto_brightness_summary_low" msgid="1606100911112851291">"Eelistatav heledus on tume"</string>
    <string name="auto_brightness_summary_default" msgid="9038441148247815684">"Eelistatav heledus on vaikeseade"</string>
    <string name="auto_brightness_summary_high" msgid="2886260311484349010">"Eelistatav heledus on hele"</string>
    <string name="auto_brightness_summary_very_high" msgid="8294814315426024005">"Eelistatav heledus on väga hele"</string>
    <string name="auto_brightness_off_title" msgid="5156056957376839677">"Väljas"</string>
    <string name="auto_brightness_very_low_title" msgid="618973599332847430">"Väga tume"</string>
    <string name="auto_brightness_low_title" msgid="4243763334776382492">"Tume"</string>
    <string name="auto_brightness_default_title" msgid="1776584786251120907">"Vaikeseade"</string>
    <string name="auto_brightness_high_title" msgid="6472704542949390468">"Hele"</string>
    <string name="auto_brightness_very_high_title" msgid="4935132626750630713">"Väga hele"</string>
    <string name="auto_brightness_subtitle" msgid="6839449395639517870">"Teie eelistatud heleduse tase"</string>
    <string name="auto_brightness_off_summary" msgid="4993150980274474226">"Ära kohanda valgustingimuste järgi"</string>
    <string name="auto_brightness_very_high_summary" msgid="2784981315548144255">"Suurem akukasutus"</string>
    <string name="auto_brightness_disclaimer" msgid="1868395832774087351">"Heledust optimeeritakse valgustingimuste järgi. Kui funktsioon on sisse lülitatud, saate heledust siiski ajutiselt reguleerida."</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Teie ekraanikuva eredust kohandatakse automaatselt teie keskkonna ja tegevuste järgi. Võite liugurit käsitsi liigutada, et aidata kohanduval eredusel teie eelistusi õppida."</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Ekraani valge tasakaal"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="1527087897198455042">"Suurendab teatud sisu puhul värskendamissagedust 60 hertsilt 90 hertsini. Akukasutus suureneb."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Jõusta kõrgeim värskendamissagedus"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Kõrgeim värskendamissagedus täiustab puutetundlikkust ja pakub sujuvamaid animatsioone. Akukasutus suureneb."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Ekraanivaatamise tuvastus"</string>
    <string name="adaptive_sleep_summary_on" msgid="313187971631243800">"Sees / ekraan jääb sisselülitatuks, kui seda vaatate"</string>
    <string name="adaptive_sleep_summary_off" msgid="5272156339202897523">"Väljas"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Vajalik on kaamera juurdepääs"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Ekraanivaatamise tuvastuse kasutamiseks on vaja juurdepääsu kaamerale. Puudutage, et hallata seadme isikupärastamise teenuste lube"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Lubade haldamine"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Takistab ekraani väljalülitamist, kui seda vaatate"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Ekraanivaatamise tuvastuse funktsioon kontrollib esikaamera abil, kas keegi vaatab ekraani. See töötab ainult seadmes ja pilte ei salvestata kunagi ega saadeta Google\'ile."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Lülita ekraanivaatamise tuvastus sisse"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Ekraan jääb vaatamise ajal sisselülitatuks"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kaamera on lukus"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Näotuvastuse kasutamiseks peab kaamera olema avatud"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Kaamera peab ekraanivaatamise tuvastuse kasutamiseks olema avatud"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Näotuvastuse kasutamiseks on vaja juurdepääsu kaamerale. Puudutage, et hallata seadme isikupärastamise teenuste lube"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Lubade haldamine"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Öövalgus"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Funktsioon Öövalgus toonib ekraani oranžkollaseks. Nii on hämaras ekraani mugavam vaadata ja sellelt teksti lugeda. See võib aidata teil ka hõlpsamini magama jääda."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Ajastamine"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Mitte kunagi"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Lülitub sisse kohandatud ajal"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Lülitub sisse loojangust tõusuni"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Algusaeg"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Lõppaeg"</string>
    <string name="night_display_status_title" msgid="9006282950657941820">"Olek"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensiivsus"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Ei lülitu kunagi automaatselt sisse"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Lülitub automaatselt sisse kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Lülitub automaatselt sisse päikeseloojangul"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Ei lülitu kunagi automaatselt välja"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Lülitub automaatselt välja kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Lülitub automaatselt välja päikesetõusul"</string>
    <string name="night_display_activation_on_manual" msgid="7999294858026069365">"Lülita kohe sisse"</string>
    <string name="night_display_activation_off_manual" msgid="4842907786868153218">"Lülita kohe välja"</string>
    <string name="night_display_activation_on_twilight" msgid="3440889451767582067">"Lülita sisse päikesetõusuni"</string>
    <string name="night_display_activation_off_twilight" msgid="2853594955401726956">"Lülita välja päikeseloojanguni"</string>
    <string name="night_display_activation_on_custom" msgid="4951143503599226846">"Lülita sisse kuni <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="79965738861100371">"Lülita välja kuni <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Öövalgus pole praegu sees"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Päikeseloojangu ja -tõusu aja määramiseks on vaja teada seadme asukohta."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Asukohaseaded"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Lülita kohe sisse"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Lülita kohe välja"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Lülita sisse päikesetõusuni"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Lülita välja päikeseloojanguni"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Tume režiim"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Ajakava"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Puudub"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Sees loojangust päikesetõusuni"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Lülitub sisse kohandatud ajal"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Olek"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Ei lülitu kunagi automaatselt sisse"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Lülitub automaatselt sisse päikeseloojangul"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Lülitub automaatselt sisse kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Ei lülitu kunagi automaatselt välja"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Lülitub automaatselt välja päikesetõusul"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Lülitub automaatselt välja kell <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_on_custom" msgid="1889379402860316125">"Lülita sisse kuni <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_off_custom" msgid="2192932161592759607">"Lülita välja kuni <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tume teema kasutab musta tausta, et teie aku kestaks mõne ekraani puhul kauem. Tumeda teema ajakava lülitatakse sisse siis, kui ekraan on väljas."</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Ekraani ajalõpp"</string>
    <string name="screen_timeout_title" msgid="785134393520893049">"Ekraan lülitub välja"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Pärast <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> tegevusetust"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Taustapilt"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Taustapilt ja stiil"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Avakuva, lukustuskuva"</string>
    <string name="wallpaper_settings_summary_default" msgid="7569803705735001813">"Vaikeseade"</string>
    <string name="wallpaper_settings_summary_custom" msgid="3174561317688848729">"Kohandatud"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Muutke taustapilti"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Isikupärastage ekraani"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Taustapildi valimine:"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Telefoni kohandamine"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Proovige eri stiile, taustapilte ja muud"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Ekraanisäästja"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Laadimise ajal või dokis"</string>
    <string name="screensaver_settings_summary_either_short" msgid="2126139984738506920">"Kui on dokitud või laeb"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Laadimise ajal"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Kui on dokitud"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Mitte kunagi"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Välja"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1166343194760238835">"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="8145025742428940520">"Alustamise aeg"</string>
    <string name="screensaver_settings_current" msgid="390472865895976891">"Praegune ekraanisäästja"</string>
    <string name="screensaver_settings_button" msgid="6159236558934930238">"Seaded"</string>
    <string name="automatic_brightness" msgid="4599827881929079513">"Automaatne eredus"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Tõstke äratamiseks"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Säästlik ekraan"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Millal kuvada?"</string>
    <string name="doze_title" msgid="1523090408230862316">"Ekraani äratamine märguanneteks"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Kui ekraan on välja lülitatud, lülitatakse see uute märguannete puhul sisse"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Alati aja ja teabe kuvamine"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Suurem akukasutus"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Paks tekst"</string>
    <string name="title_font_size" msgid="570613010306330622">"Fondi suurus"</string>
    <string name="short_summary_font_size" msgid="184712645848458143">"Teksti suuremaks või väiksemaks muutmine"</string>
    <string name="sim_lock_settings" msgid="4493069398250139205">"SIM-kaardi luku seaded"</string>
    <string name="sim_lock_settings_category" msgid="4280307997492851625">"SIM-kaardi lukk"</string>
    <string name="sim_lock_settings_summary_off" msgid="4570941250786847095">"Väljas"</string>
    <string name="sim_lock_settings_summary_on" msgid="1562184566830887925">"Lukus"</string>
    <string name="sim_lock_settings_title" msgid="1401619059761012696">"SIM-kaardi lukk"</string>
    <string name="sim_pin_toggle" msgid="98754920202404425">"SIM-kaardi lukustamine"</string>
    <string name="sim_lock_on" product="tablet" msgid="5857965768682972363">"Nõua tahvelarvuti kasutamiseks PIN-i"</string>
    <string name="sim_lock_on" product="default" msgid="3303147192981388923">"Nõua telefoni kasutamiseks PIN-i"</string>
    <string name="sim_lock_off" product="tablet" msgid="7188936582548721225">"Nõua tahvelarvuti kasutamiseks PIN-i"</string>
    <string name="sim_lock_off" product="default" msgid="4634118006847137785">"Nõua telefoni kasutamiseks PIN-i"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Muuda SIM-kaardi PIN-koodi"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"SIM-kaardi PIN-kood"</string>
    <string name="sim_enable_sim_lock" msgid="8993991669975548653">"SIM-kaardi lukustamine"</string>
    <string name="sim_disable_sim_lock" msgid="7656447857474746157">"Ava SIM-kaart"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"SIM-kaardi vana PIN-kood"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"SIM-kaardi uus PIN-kood"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Sisestage uus PIN-kood uuesti"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"SIM-kaardi PIN-kood"</string>
    <string name="sim_bad_pin" msgid="5416328363761048221">"Vale PIN-kood"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN-koodid ei kattu"</string>
    <string name="sim_change_failed" msgid="316723087029061740">"PIN-koodi ei saa muuta.\nPIN-kood võib vale olla."</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"SIM-i PIN-koodi muutmine õnnestus"</string>
    <string name="sim_lock_failed" msgid="16360418201678317">"SIM-kaardi lukustusolekut ei saa muuta.\nVõimalik, et PIN-kood on vale."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"PIN-koodi ei saa keelata."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"PIN-koodi ei saa lubada."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Tühista"</string>
    <string name="sim_multi_sims_title" msgid="4875083890014013296">"Leiti mitu SIM-kaarti"</string>
    <string name="sim_multi_sims_summary" msgid="1711012455679332238">"Valige SIM-kaart, mida eelistate kasutada mobiilse andmeside puhul."</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Kas kasutada <xliff:g id="CARRIER">%1$s</xliff:g> andmesidet?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Kasutate operaatori <xliff:g id="CARRIER2_0">%2$s</xliff:g> mobiilset andmesidet. Kui aktiveerite operaatori <xliff:g id="CARRIER1">%1$s</xliff:g>, ei kasutata enam operaatori <xliff:g id="CARRIER2_1">%2$s</xliff:g> mobiilset andmesidet."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Kasuta operaatorit <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="7182406911552216373">"Kas värskendada SIM-kaarti?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> on ainuke seadmes olev SIM-kaart. Kas soovite mobiilse andmeside, kõnede ja SMS-sõnumite puhul kasutada seda SIM-kaarti?"</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Vale SIM-i PIN-kood, seadme avamiseks peate nüüd ühendust võtma oma operaatoriga."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="4054088588731305475">
      <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="wrong_pin_code_one" msgid="6924852214263071441">"Vale SIM-i PIN-kood, teil on jäänud veel 1 katse, enne kui peate seadme avamiseks operaatoriga ühendust võtma."</string>
    <string name="pin_failed" msgid="3726505565797352255">"SIM-i PIN-koodi toiming ebaõnnestus."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Süsteemivärskendused"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Androidi versioon"</string>
    <string name="security_patch" msgid="4071756145347865382">"Androidi turvavärskendus"</string>
    <string name="model_info" msgid="8997566254717810904">"Mudel"</string>
    <string name="hardware_info" msgid="7035211991066637019">"Mudel ja riistvara"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Riistvara versioon"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Seadme ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Põhiribaversioon"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Tuuma versioon"</string>
    <string name="build_number" msgid="9009733242117579826">"Järgunumber"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play süsteemivärskendus"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Pole saadaval"</string>
    <string name="device_status_activity_title" msgid="1812666241137263882">"Olek"</string>
    <string name="device_status" msgid="7988547478034984649">"Olek"</string>
    <string name="device_status_summary" product="tablet" msgid="8826216824111648900">"Aku laetuse, võrgu ja muu teave"</string>
    <string name="device_status_summary" product="default" msgid="8132661857066128832">"Telefoninumber, signaal jne"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Mäluruum"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Salvestusruum ja vahemälu"</string>
    <string name="storage_usb_settings" msgid="7058142934214211583">"Salvestusruum"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Mäluruumi seaded"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3858049818577638926">"USB-mäluseadme lahutamine, saadaoleva mäluruumi kuvamine"</string>
    <string name="storage_settings_summary" product="default" msgid="267557695753980969">"Eemalda SD-kaart, kuva saadaolev mäluruum"</string>
    <string name="imei_multi_sim" msgid="71477088017585479">"IMEI (SIM-kaardi pesa %1$d)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Vaatamiseks valige salvestatud võrk"</string>
    <string name="status_number" product="tablet" msgid="3597945414666253183">"MDN"</string>
    <string name="status_number" product="default" msgid="8407999629121682207">"Telefoninumber"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="6582203988975619529">"MDN (SIM-kaardi pesa %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="5724823197745786398">"Telefonin. (SIM-i pesa %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="4239876366511743428">"MDN SIM-kaardil"</string>
    <string name="status_number_sim_status" product="default" msgid="2772745542921910086">"Telefoninumber SIMil"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"PRL-versioon"</string>
    <string name="meid_multi_sim" msgid="7645394486193991388">"MEID (SIM-kaadri pesa %1$d)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Sees"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Väljas"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="7644609329607744714">"Nii WiFi kui ka Bluetoothi skannimine on sisse lülitatud"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="7215007787287418186">"WiFi-skannimine on sees, Bluetoothi skannimine on väljas"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="1396882599556304165">"Bluetoothi skannimine on sees, WiFi-skannimine on väljas"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="7670694707427030537">"Nii WiFi kui ka Bluetoothi skannimine on välja lülitatud"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Mobiilse andmesidevõrgu tüüp"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Mobiilse häälvõrgu tüüp"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Operaatori teave"</string>
    <string name="status_data_state" msgid="525196229491743487">"Mobiilsidevõrgu olek"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Teenuse olek"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signaali tugevus"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Rändlus"</string>
    <string name="status_operator" msgid="4335640583552058491">"Võrk"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"WiFi MAC-aadress"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Seadme WiFi MAC-aadress"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetoothi aadress"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Seerianumber"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Talitlusaeg"</string>
    <string name="status_awake_time" msgid="2573925324168081586">"Sisselülitusaeg"</string>
    <string name="internal_memory" msgid="1869518160077033848">"Sisemälu"</string>
    <string name="sd_memory" product="nosdcard" msgid="5456718463397723781">"USB-mäluseade"</string>
    <string name="sd_memory" product="default" msgid="3098344183202722455">"SD-kaart"</string>
    <string name="memory_available" msgid="712528795743654737">"Saadaval"</string>
    <string name="memory_available_read_only" msgid="3201969221573511590">"Saadaval (kirjutuskaitstud)"</string>
    <string name="memory_size" msgid="2710897518522931469">"Kogu ruum"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Arvutamine ..."</string>
    <string name="memory_apps_usage" msgid="8818570780540532952">"Rakendused ja rakenduste andmed"</string>
    <string name="memory_media_usage" msgid="5161308657995646963">"Meedium"</string>
    <string name="memory_downloads_usage" msgid="8252462247720191179">"Allalaadimised"</string>
    <string name="memory_dcim_usage" msgid="3568913845973164352">"Pildid, videod"</string>
    <string name="memory_music_usage" msgid="8100634000114206429">"Heli (muusika, helinad, Interneti-saated jne)"</string>
    <string name="memory_media_misc_usage" msgid="7066851245178533269">"Muud failid"</string>
    <string name="memory_media_cache_usage" msgid="780808666853685824">"Vahemälus olevad andmed"</string>
    <string name="sd_eject" product="nosdcard" msgid="6136102589751843304">"Lahuta jagatud mälu"</string>
    <string name="sd_eject" product="default" msgid="8062832622096296251">"Lahutage SD-kaart"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="6859940774161708871">"Sisemise USB lahutamine"</string>
    <string name="sd_eject_summary" product="default" msgid="5151243312587186226">"SD-kaardi lahutamine ohutuks eemaldamiseks"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="9164545135649775664">"USB sisest. paigaldam.-ks"</string>
    <string name="sd_insert_summary" product="default" msgid="5949168259622002192">"Sisestage SD-kaart ühendamiseks"</string>
    <string name="sd_mount" product="nosdcard" msgid="8305985249945415150">"Paigalda USB-mäluseade"</string>
    <string name="sd_mount" product="default" msgid="5279813999455776169">"SD-kaardi ühendamine"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="2190410240845521205"></string>
    <string name="sd_mount_summary" product="default" msgid="2190410240845521205"></string>
    <string name="sd_format" product="nosdcard" msgid="8657427883364711513">"Kustuta USB-mäluseade"</string>
    <string name="sd_format" product="default" msgid="9085302892248732329">"Kustuta SD-kaart"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6179784504937189658">"Sisemisest USB-mäluseadmest kõikide andmete, nagu muusika ja fotode, kustutamine"</string>
    <string name="sd_format_summary" product="default" msgid="60583152211068164">"Kustutab SD-kaardilt kõik andmed, nagu muusika ja fotod"</string>
    <string name="mtp_ptp_mode_summary" msgid="7969656567437639239">"MTP või PTP funktsioon on aktiivne"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="7694112411895701320">"Kas lahutada USB-seade?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="8251329019960361646">"Kas lahutada SD-kaart?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="1212025106709645023">"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="3887768438615563697">"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="2205587942165199845"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="7876201891724279436">"USB-mäluseadet ei saanud lahutada. Proovige hiljem uuesti."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="2185659901137961711">"SD-kaarti ei saanud lahutada. Proovige hiljem uuesti."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="5932607205977999175">"USB-mäluseade lahutatakse."</string>
    <string name="unmount_inform_text" product="default" msgid="716578785262713312">"SD-kaart lahutatakse."</string>
    <string name="sd_ejecting_title" msgid="1641122369013595273">"Eemaldamine"</string>
    <string name="sd_ejecting_summary" msgid="861928572729341132">"Eemaldamine pooleli"</string>
    <string name="storage_low_title" msgid="8002650511493419567">"Talletusruum saab täis"</string>
    <string name="storage_low_summary" msgid="7341022293583384506">"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="8549835371429159336">"Ümbernimetamine"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Ühendamine"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Eemaldamine"</string>
    <string name="storage_menu_format" msgid="5454870642788909443">"Vormindamine"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Vormindamine kaasaskantavana"</string>
    <string name="storage_menu_format_private" msgid="3208326980027382079">"Vormindamine sisemisena"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Andmete üleviimine"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Unustamine"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Seadistus"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Ruumi vabastamine"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Salvestusruumi haldamine"</string>
    <string name="keywords_storage_menu_free" msgid="2275406357317597106">"tühjendamine, salvestusruum"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Ruumi vabastamine"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Ruumi haldamiseks ja vabastamiseks minge rakendusse Failid"</string>
    <string name="storage_title_usb" msgid="1332488715547400452">"USB-arvutiühendus"</string>
    <string name="usb_connection_category" msgid="2288543238378907242">"Ühenda kui"</string>
    <string name="usb_mtp_title" msgid="9068009584556422314">"Meediumiseade (MTP)"</string>
    <string name="usb_mtp_summary" msgid="6293240861011560842">"Võimaldab teisaldada meediafaile Windowsis või rakendusega Android File Transfer Macis (vt www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="4496529268189091846">"Kaamera (PTP)"</string>
    <string name="usb_ptp_summary" msgid="8382539472311655671">"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="1139558846427981761">"MIDI"</string>
    <string name="usb_midi_summary" msgid="1842457325845863840">"Võimaldab MIDI toega rakendustel teie arvutis oleva MIDI-tarkvara abil töötada USB kaudu."</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Teised kasutajad"</string>
    <string name="storage_internal_title" msgid="3265098802217660829">"Seadme salvestusruum"</string>
    <string name="storage_external_title" msgid="8984075540312137135">"Kaasaskantav salvestusruum"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="5031288167242496837">"Kasutatud <xliff:g id="TOTAL">%1$s</xliff:g>-st"</string>
    <string name="storage_mount_success" msgid="393972242641313135">"Üksus <xliff:g id="NAME">%1$s</xliff:g> ühendati"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Üksust <xliff:g id="NAME">%1$s</xliff:g> ei saanud ühendada"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"Üksus <xliff:g id="NAME">%1$s</xliff:g> eemaldati ohutult"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Üksust <xliff:g id="NAME">%1$s</xliff:g> ei saanud ohutult eemaldada"</string>
    <string name="storage_format_success" msgid="3028114521294256851">"Üksus <xliff:g id="NAME">%1$s</xliff:g> vormindati"</string>
    <string name="storage_format_failure" msgid="2042691589726261987">"Üksust <xliff:g id="NAME">%1$s</xliff:g> ei saanud vormindada"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Salvestusruumi ümbernimetamine"</string>
    <string name="storage_dialog_unmounted" msgid="1187960789775910051">"Ü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="1761107904296941687">"Üksus <xliff:g id="NAME_0">^1</xliff:g> on rikutud. \n\nÜksuse <xliff:g id="NAME_1">^1</xliff:g> kasutamiseks peate selle esmalt seadistama."</string>
    <string name="storage_internal_format_details" msgid="8922023528848861812">"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="487689543322907311"><b>"Kui üksuse <xliff:g id="NAME_0">^1</xliff:g> eemaldate, lõpetavad sellesse salvestatud rakendused töö ja selles olevad meediafailid pole saadaval, kuni selle uuesti sisestate."</b>\n\n"Üksus <xliff:g id="NAME_1">^1</xliff:g> on vormindatud ainult selles seadmes töötamiseks. See ei tööta teistes seadmetes."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Seadmes <xliff:g id="NAME">^1</xliff:g> olevate rakenduste, fotode või andmete kasutamiseks sisestage see uuesti. \n\nKui seade pole saadaval, võite selle salvestusruumi ka unustada. \n\nKui otsustate selle unustada, kaotate kõik seadmes olevad andmed jäädavalt. \n\nSaate rakendused hiljem uuesti installida, kuid nende sellesse seadmesse salvestatud andmed lähevad kaotsi."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Kas unustada <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Kõik üksusele <xliff:g id="NAME">^1</xliff:g> salvestatud rakendused, fotod ja andmed kaovad jäädavalt."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Jaotis Süsteem hõlmab Androidi versiooni <xliff:g id="VERSION">%s</xliff:g> käitamiseks vajalikke faile"</string>
    <string name="storage_wizard_init_title" msgid="9036374223934708619">"Seadista üksus <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="6540132491909241713">"Kasuta kaasaskantava salvestusruumina"</string>
    <string name="storage_wizard_init_external_summary" msgid="5807552934494462984">"Fotode ja muu meedia teisaldamiseks seadmete vahel."</string>
    <string name="storage_wizard_init_internal_title" msgid="3256355049992147270">"Kasuta sisemise salvestusruumina"</string>
    <string name="storage_wizard_init_internal_summary" msgid="2283798331883929674">"Ü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="4898014527956178762">"Vorminda sisem. salvestusruumina"</string>
    <string name="storage_wizard_format_confirm_body" msgid="5514665245241830772">"Ü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="649252654496577680">"Vorm. kaasask. salvestusruumina"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="6219883780307218266">"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="4412063054982084056">"Kustuta ja vorminda"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Üksuse <xliff:g id="NAME">^1</xliff:g> vormindamine …"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Ärge eemaldage üksust <xliff:g id="NAME">^1</xliff:g> vormindamise ajal."</string>
    <string name="storage_wizard_migrate_title" msgid="3013711737005104623">"Teis. andmed uude salvestusruumi"</string>
    <string name="storage_wizard_migrate_body" msgid="1630853797296198275">"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="175023718337037181">"Teisalda kohe"</string>
    <string name="storage_wizard_migrate_later" msgid="6573789572520980112">"Teisalda hiljem"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="255346780598924540">"Teisalda andmed kohe"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="5039938578355576124"><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="217478540562501692">"Teisalda"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="462238335086734131">"Andmete teisaldamine …"</string>
    <string name="storage_wizard_migrate_details" msgid="7474061662976940407">"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="3093468548660255543">"Seade <xliff:g id="NAME">^1</xliff:g> on kasutamiseks valmis"</string>
    <string name="storage_wizard_ready_external_body" msgid="45040717412844114">"Üksus <xliff:g id="NAME">^1</xliff:g> on valmis fotode ja muu meediaga kasutamiseks."</string>
    <string name="storage_wizard_ready_internal_body" msgid="7734817996475607447">"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="6812469630804101590">"Teisalda rakendus <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Rakenduse <xliff:g id="APP">^1</xliff:g> ja selle andmete teisaldamine üksusesse <xliff:g id="NAME_0">^2</xliff:g> võtab vaid mõne hetke. Te ei saa rakendust kasutada enne, kui teisaldamine on lõpetatud. \n\nTeisaldamise ajal ärge eemaldage üksust <xliff:g id="NAME_1">^2</xliff:g>."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Andmete teisaldamiseks peate avama kasutaja <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Rakenduse <xliff:g id="APP">^1</xliff:g> teisaldamine …"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Ärge eemaldage teisaldamise ajal üksust <xliff:g id="NAME">^1</xliff:g>. \n\nRakendus <xliff:g id="APP">^2</xliff:g> pole seadmes saadaval enne, kui teisaldamine on lõpetatud."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="3494022998599718937">"Tühista teisaldamine"</string>
    <string name="storage_wizard_slow_body" msgid="8293565076885232029">"Ü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="2538630338392381113">"Kuidas seadet <xliff:g id="NAME">^1</xliff:g> kasutate?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="1884468440013151482">"Kasuta tahvelar. lisasalvestusr."</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="2907833056467441047">"Ainult selles tahvelarv. olevate raken., failide ja meedia jaoks"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="3278694259614995649">"Tahvelarvuti salvestusruum"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="5941952998075252284">"Kasuta telefoni lisasalvestusr."</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="3022584310096954875">"Ainult selles telef. olevate rakenduste, failide ja meedia jaoks"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="5645732875040797464">"Telefoni salvestusruum"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Või"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="8129096036551264207">"Kasuta kaasask. salv.ruumi jaoks"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="6436419488235871823">"Failide ja meedia edastamiseks seadmete vahel"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="781928899530539860">"Kaasaskantav salvestusruum"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Seadista hiljem"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Kas vormindada seade <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"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="5718254101386377126">"Vorminda seade <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Kas teisaldada sisu seadmesse <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4541523202790415721">"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="809730501314645325">"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="2618258869444553060">"Teisaldamise ajal pidage silmas järgmist."</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Ärge eemaldage seadet <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Mõni rakendus ei pruugi töötada"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="6111770421449869539">"Hoidke tahvelarvuti laetuna"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="8826915870192535008">"Hoidke telefon laetuna"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Teisalda sisu"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Teisalda sisu hiljem"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Sisu teisaldamine …"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Aeglane seade <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Võite seadet <xliff:g id="NAME_0">^1</xliff:g> siiski kasutada, kuid see võib olla aeglane. \n\nSeadmesse <xliff:g id="NAME_1">^2</xliff:g> salvestatud rakendused ei pruugi õigesti töötada ja sisu teisaldamine võib kaua aega võtta. \n\nKasutage kiiremat seadet <xliff:g id="NAME_2">^3</xliff:g> või selle asemel seda seadet <xliff:g id="NAME_3">^4</xliff:g> kaasaskantava salvestusruumina."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Alusta uuesti"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Jätka"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="3896836008684280905">"Sisu saab teisaldada seadmesse <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="5710665992219332454">"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="1269878056598666852">"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="4661768220545945771">"Aku olek"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Aku tase"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Pääsupunktid (APN-id)"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Pääsupunkti muutmine"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Määramata"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Määramata"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nimi"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Pääsupunkti nimi"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Puhverserver"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Kasutajanimi"</string>
    <string name="apn_password" msgid="7435086635953953029">"Parool"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS-i puhverserver"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS-port"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Autentimise tüüp"</string>
    <string name="apn_auth_type_none" msgid="6845031410929644238">"Puudub"</string>
    <string name="apn_auth_type_pap" msgid="9003475621032514182">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3587713509473187621">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="6852124741245095775">"PAP või CHAP"</string>
    <string name="apn_type" msgid="1835573305077788773">"APN-i tüüp"</string>
    <string name="apn_protocol" msgid="181529867160380010">"APN-i protokoll"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"APN-i rändlusprotokoll"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Luba/keela APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN on lubatud"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN on keelatud"</string>
    <string name="bearer" msgid="3231443241639159358">"Kandja"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO tüüp"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO väärtus"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Kustuta pääsupunktinimi"</string>
    <string name="menu_new" msgid="6571230342655509006">"Uus pääsupunkt"</string>
    <string name="menu_save" msgid="6611465355127483100">"Salvesta"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Tühista"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Nimeväli ei tohi tühi olla."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN ei saa olla tühi."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC-väli peab olema kolmekohaline."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC-väli peab olema kahe- või kolmekohaline."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operaator ei luba tüübiga %s APN-ide lisamist."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"APN-i vaikeseadete taastamine."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Lähtesta vaikeseadetele"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"APN-i vaikeseadete lähtestamine on lõpule viidud."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Lähtestamise valikud"</string>
    <string name="reset_dashboard_summary" msgid="4390780188264852956">"Võrgu, rakendused või seadme saab lähtestada"</string>
    <string name="reset_dashboard_summary_onlyApps" msgid="3304252260039419584">"Rakendused saab lähtestada"</string>
    <string name="reset_network_title" msgid="1395494440355807616">"WiFi, mobiilside ja Bluetoothi lähtestamine"</string>
    <string name="reset_network_desc" msgid="1112523764899788246">"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="erase_euicc_data_button" msgid="728078969563311737">"Kustuta"</string>
    <string name="reset_esim_title" msgid="6152167073280852849">"Allalaaditud SIM-ide kustutamine"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"See ei tühista mobiilsideteenuse pakette. Asendus-SIM-ide allalaadimiseks võtke ühendust operaatoriga."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Lähtesta seaded"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Kas soovite kõik võrguseaded lähtestada? Seda toimingut ei saa tagasi võtta."</string>
    <string name="reset_network_final_desc_esim" msgid="8342882682282693844">"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="2433867118414000462">"Lähtesta seaded"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Kas lähtestada?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Võrguseadete lähtestamine pole selle kasutaja puhul saadaval"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Võrguseaded lähtestati"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"SIM-kaarte ei saa kustutada"</string>
    <string name="reset_esim_error_msg" msgid="4441504470684307370">"Allalaaditud SIM-kaarte ei saa vea tõttu kustutada.\n\nTaaskäivitage seade ja proovige uuesti."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Kõikide andmete kustutamine (tehaseseadetele lähtestamine)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Kõigi andmete kustutamine (tehaseseaded)"</string>
    <string name="main_clear_desc" product="tablet" msgid="1651178880680056849">"See kustutab teie tahvelarvuti "<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="main_clear_desc" product="default" msgid="6984348811887162647">"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="main_clear_accounts" product="default" msgid="7675859115108318537">\n\n"Olete praegu sisse logitud järgmistele kontodele:\n"</string>
    <string name="main_clear_other_users_present" product="default" msgid="2672976674798019077">\n\n"Seadmes on teisi kasutajaid.\n"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Muusika"</li>\n<li>"Fotod"</li>\n<li>"Muud kasutajaandmed"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM-id"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"See ei tühista teie mobiilsideteenuse paketti."</string>
    <string name="main_clear_desc_erase_external_storage" product="nosdcard" msgid="4441604184663452046">\n\n"Muusika, piltide ja muude kasutajaandmete kustutamiseks tuleb tühjendada ka "<b>"USB-mäluseade"</b>"."</string>
    <string name="main_clear_desc_erase_external_storage" product="default" msgid="1498514970618215728">\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="2182181846128639635">"Kustuta USB-mäluseade"</string>
    <string name="erase_external_storage" product="default" msgid="2610056855012660451">"Kustuta SD-kaart"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="6358699244894944843">"Sisemiselt USB-mäluseadmelt kõikide andmete (nt muusika või fotode) kustutamine"</string>
    <string name="erase_external_storage_description" product="default" msgid="3367779850546310380">"SD-kaardilt kõigi andmete (nt muusika või fotode) kustutamine"</string>
    <string name="main_clear_button_text" product="tablet" msgid="6246087475569640671">"Kustuta kõik andmed"</string>
    <string name="main_clear_button_text" product="default" msgid="6246087475569640671">"Kustuta kõik andmed"</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Kõik teie isiklikud andmed ja allalaaditud rakendused kustutatakse. Seda toimingut ei saa tagasi võtta."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Kõik teie isiklikud andmed, sealhulgas allalaaditud rakendused ja SIM-kaardid kustutatakse. Seda toimingut ei saa tagasi võtta."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Kas kustutada kõik andmed?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Tehaseseadetele lähtestamine pole selle kasutaja puhul saadaval"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Kustutamine"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Oodake …"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Kõneseaded"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Seadista kõnepost, kõne edastamine, ootel kõne, helistaja ID"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Jagamine USB-ga"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Mobiilne kuumkoht"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Jagamine Bluetoothiga"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Jagamine"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Kuumkoht ja jagamine"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Kuumkoht on sees, jagamine"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Kuumkoht on sees"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Jagamine"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Kui andmemahu säästja on sisse lülitatud, siis ei saa jagada ega kasutada teisaldatavat kuumkohta"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Ainult kuumkoht"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Ainult USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Ainult Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Ainult Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Kuumkoht, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Kuumkoht, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Kuumkoht, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Kuumkoht, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Kuumkoht, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Kuumkoht, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Kuumkoht, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internetiühendust ei jagata teiste seadmetega"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Jagamine"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Ära kasuta WiFi-kuumkohta"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Jaga internetti ainult USB kaudu"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Jaga internetti ainult Bluetoothi kaudu"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Jaga internetti ainult Etherneti kaudu"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Jaga internetti ainult USB või Bluetoothi kaudu"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Jaga internetti ainult USB ja Etherneti kaudu"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Jaga internetti ainult Bluetoothi ja Etherneti kaudu"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Jaga internetti ainult USB, Bluetoothi ja Etherneti kaudu"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Jagamine USB-ga"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3168636595109044213">"Telefoni internetiühenduse jagamine USB kaudu"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="1749659335004856576">"Tahvelarvuti Interneti-ühenduse jagamine USB kaudu"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Jagamine Bluetoothiga"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="2023654677593885805">"Tahvelarvuti Interneti-ühenduse jagamine Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="4322810060538179348">"Telefoni internetiühenduse jagamine Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6941934844527406581">"Seadme <xliff:g id="DEVICE_NAME">%1$d</xliff:g> Interneti-ühenduse jagamine Bluetoothi kaudu"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="5292358672240161566">"Ei saa jagada rohkem kui <xliff:g id="MAXCONNECTION">%1$d</xliff:g> seadmele."</string>
    <string name="bluetooth_untether_blank" msgid="5087548945727762308">"Seadme <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ühenduse jagamine lõpetatakse."</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Jagamine Ethernetiga"</string>
    <string name="ethernet_tethering_subtext" product="default" msgid="5998100693350351694">"Telefoni internetiühenduse jagamine Etherneti kaudu"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Teistele seadmetele mobiilse andmesidevõrgu kaudu Interneti-ühenduse pakkumiseks kasutage kuumkohta ja ühenduse jagamist. Samuti saavad kuumkoha luua rakendused, et jagada sisu läheduses olevate seadmetega."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Teistele seadmetele WiFi- või mobiilse andmesidevõrgu kaudu internetiühenduse pakkumiseks kasutage kuumkohta ja ühenduse jagamist. Samuti saavad kuumkoha luua rakendused, et jagada sisu läheduses olevate seadmetega."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Abi"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobiilsidevõrk"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobiilipakett"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS-rakendus"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Kas muuta SMS-i rakendust?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Kas kasutada SMS-i rakendusena rakenduse <xliff:g id="NEW_APP">%1$s</xliff:g> asemel rakendust <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Kas kasutada SMS-i rakendusena rakendust <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="network_scorer_picker_title" msgid="2022922801936206195">"Võrgukvaliteedi hinnangupakkuja"</string>
    <string name="network_scorer_picker_none_preference" msgid="8894034333043177807">"Mitte ükski"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Kas muuta WiFi Assistanti?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Kas kasutada võrguühenduste haldamiseks rakenduse <xliff:g id="CURRENT_APP">%2$s</xliff:g> asemel rakendust <xliff:g id="NEW_APP">%1$s</xliff:g>?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Kas kasutada võrguühenduste haldamiseks rakendust <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Tundmatu SIM-kaardi operaator"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"Operaatoril <xliff:g id="OPERATOR">%1$s</xliff:g> pole ettevalmistuse veebisaite"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Sisestage SIM-kaart ja taaskäivitage"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Looge Interneti-ühendus"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Hiljutised asukohapäringud"</string>
    <string name="location_recent_location_requests_see_all" msgid="7918405176741692524">"Kuva kõik"</string>
    <string name="location_category_location_services" msgid="8163798686832434284">"Asukohateenused"</string>
    <string name="location_title" msgid="5819154746934945021">"Minu asukoht"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Tööprofiili asukohaluba"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Asukohale juurdepääsu load"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Asukoht on välja lülitatud"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="8286873148858526214">
      <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="2558063524482178146">"Hiljutine juurdepääs"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Kuva kõik"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Kuva üksikasjad"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Ükski rakendus pole hiljuti asukohateavet küsinud"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Ükski rakendus ei ole hiljuti asukohale juurde pääsenud"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Suur akukasutus"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Madala tarbimisega akukasutus"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"WiFi-skannimine"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Lubage rakendustel ja teenustel alati otsida WiFi-võrke, isegi kui WiFi on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetoothi skannimine"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Lubage rakendustel ja teenustel alati otsida läheduses olevaid seadmeid, isegi kui Bluetooth on väljas. Seda saab kasutada näiteks asukohapõhiste funktsioonide ja teenuste täiustamiseks."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Asukohateenused"</string>
    <string name="location_services_screen_title" msgid="9204334551361202877">"Asukohateenused"</string>
    <string name="managed_profile_location_services" msgid="8172092734138341880">"Asukohateenused töö jaoks"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6518338597250564260">"Kasuta ajavööndi määramiseks asukohta"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Seadme asukoht on vajalik"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Selleks et ajavöönd kasutaks teie asukohta, lülitage sisse asukoht ja värskendage ajavööndi seadeid"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Asukohaseaded"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Tühista"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automaatne ajavöönd on välja lülitatud"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Asukohapõhine ajavööndi tuvastamine on keelatud"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Asukohapõhine ajavööndi tuvastamine pole toetatud"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Asukohapõhise ajavööndi tuvastamise muudatused pole lubatud"</string>
    <string name="location_network_based" msgid="5247042890080021887">"WiFi/mobiilsidevõrgu asukoht"</string>
    <string name="location_neighborhood_level" msgid="3668890550358558267">"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="6227393490651891977">"WiFi järgi määratud asukoht"</string>
    <string name="location_gps" msgid="8783616672454701134">"GPS-i satelliidid"</string>
    <string name="location_street_level" product="tablet" msgid="865953107414742784">"Lubage rakendustel tahvelarvuti GPS-i abil teie asukohta määrata"</string>
    <string name="location_street_level" product="default" msgid="3813836654645896185">"Lubage rakendustel telefoni GPS-i abil teie asukohta määrata"</string>
    <string name="assisted_gps" msgid="1714546606018821498">"Kasuta abistatud GPS-i"</string>
    <string name="assisted_gps_enabled" msgid="6220188450779319248">"Kasuta serverit GPS-i abistamiseks (eemaldage märge võrgukasutuse vähendamiseks)"</string>
    <string name="assisted_gps_disabled" msgid="1062496503892849">"Kasutage serverit GPS-i assisteerimiseks (eemaldage märge GPS-i toimivuse parandamiseks)"</string>
    <string name="use_location_title" msgid="1345594777162897654">"Asukoht ja Google\'i otsing"</string>
    <string name="use_location_summary" msgid="377322574549729921">"Lubage Google\'il otsingutulemuste ja muude teenuste parandamiseks kasutada teie asukohta"</string>
    <string name="location_access_title" msgid="4052667453826272040">"Juurdepääs minu asukohale"</string>
    <string name="location_access_summary" msgid="8634100005481578143">"Laske rakendustel, mis on palunud teie luba, kasutada teie asukohateavet"</string>
    <string name="location_sources_heading" msgid="6126965815860570524">"Asukohaallikad"</string>
    <string name="about_settings" product="tablet" msgid="2888705054709289693">"Teave tahvelarvuti kohta"</string>
    <string name="about_settings" product="default" msgid="4038626127378127613">"Telefoni teave"</string>
    <string name="about_settings" product="device" msgid="9012888717090302815">"Teave seadme kohta"</string>
    <string name="about_settings" product="emulator" msgid="2516560858771320366">"Teave jäljendatud seadme kohta"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Vaadake juriidilist teavet, olekut, tarkvara versiooni"</string>
    <string name="legal_information" msgid="7509900979811934843">"Juriidiline teave"</string>
    <string name="contributors_title" msgid="7965640251547037965">"Kaasautorid"</string>
    <string name="manual" msgid="3651593989906084868">"Käsitsi"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulatiivsildid"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Ohutus- ja regulatiivjuhend"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autoriõigus"</string>
    <string name="license_title" msgid="8745742085916617540">"Litsents"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Google Play süsteemivärskenduste litsentsid"</string>
    <string name="terms_title" msgid="2071742973672326073">"Nõuded ja tingimused"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Süsteemi WebView\' litsents"</string>
    <string name="wallpaper_attributions" msgid="3080339190260272255">"Taustapildid"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Satelliitpiltide pakkujad:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Käsitsi"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Juhendi laadimisel ilmnes probleem."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Kolmanda osapoole litsentsid"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Litsentside laadimisega on probleem."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Laadimine ..."</string>
    <string name="settings_safetylegal_title" msgid="1334501164265709288">"Ohutusteave"</string>
    <string name="settings_safetylegal_activity_title" msgid="2218587051061093358">"Ohutusteave"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="6571695168138207587">"Teil ei ole andmesideühendust. Selle teabe praegu vaatamiseks minge Interneti-ühendusega arvutis aadressile %s."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Laadimine ..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Määrake parool"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Määrake tööprofiili parool"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Määrake PIN-kood"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Määrake tööprofiili PIN-kood"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Määrake muster"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Määrake tööprofiili muster"</string>
    <string name="lockpassword_choose_password_description" product="phone" msgid="5577129054698844787">"Turvalisuse huvides seadistage telefoni avamiseks parool"</string>
    <string name="lockpassword_choose_pin_description" product="phone" msgid="6918551978526104693">"Turvalisuse huvides seadistage telefoni avamiseks PIN-kood"</string>
    <string name="lockpattern_choose_pattern_description" product="phone" msgid="9192075941504119893">"Turvalisuse huvides seadistage telefoni avamiseks muster"</string>
    <string name="lockpassword_choose_password_description" product="tablet" msgid="8643302878337665976">"Turvalisuse huvides seadistage tahvelarvuti avamiseks parool"</string>
    <string name="lockpassword_choose_pin_description" product="tablet" msgid="4655253942098525998">"Turvalisuse huvides seadistage tahvelarvuti avamiseks PIN-kood"</string>
    <string name="lockpattern_choose_pattern_description" product="tablet" msgid="6921239531465577215">"Turvalisuse huvides seadistage tahvelarvuti avamiseks muster"</string>
    <string name="lockpassword_choose_password_description" product="default" msgid="5003299048956319434">"Turvalisuse huvides seadistage seadme avamiseks parool"</string>
    <string name="lockpassword_choose_pin_description" product="default" msgid="4979785114465985543">"Turvalisuse huvides seadistage seadme avamiseks PIN-kood"</string>
    <string name="lockpattern_choose_pattern_description" product="default" msgid="3226044648785762351">"Turvalisuse huvides seadistage seadme avamiseks muster"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Sõrmejälje kasutamiseks määrake parool"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Sõrmejälje kasutamiseks määrake muster"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Turvalisuse huvides määrake PIN-kood"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Sõrmejälje kasutamiseks määrake PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Sisestage oma parool uuesti"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Sisestage tööprofiili parool uuesti"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Sisestage tööprofiili parool"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Sisestage tööprofiili muster"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Sisestage oma PIN-kood uuesti"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Sisestage tööprofiili PIN-kood uuesti"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Sisestage tööprofiili PIN-kood"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Paroolid ei ühti"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN-koodid ei ühti"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Joonistage oma muster uuesti"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Lukust avamise meetod"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Parool on määratud"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN-kood on määratud"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Muster on määratud"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Looge näoga avamise kasutamiseks parool"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Looge näoga avamise kasutamiseks muster"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Looge näoga avamise kasutamiseks PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Näo või sõrmejälje kasutamiseks seadistage parool"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Näo või sõrmejälje kasutamiseks seadistage muster"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Näo või sõrmejälje kasutamiseks seadistage PIN-kood"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Kas unustasite parooli?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Kas unustasite mustri?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Kas unustasite PIN-koodi?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Jätkamiseks kasutage seadme mustrit"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Jätkamiseks sisestage seadme PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Jätkamiseks sisestage seadme parool"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Jätkamiseks kasutage oma tööprofiili mustrit"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Jätkamiseks sisestage oma tööprofiili PIN-kood"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Jätkamiseks sisestage oma tööprofiili parool"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Lisaturvalisuse jaoks kasutage seadme mustrit"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Lisaturvalisuse jaoks sisestage oma seadme PIN-kood"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Lisaturvalisuse jaoks sisestage oma seadme parool"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Lisaturvalisuse jaoks kasutage oma tööprofiili mustrit"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Lisaturvalisuse jaoks sisestage oma tööprofiili PIN-kood"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Lisaturvalisuse jaoks sisestage oma tööprofiili parool"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6351784282865851482">"Teie telefon lähtestati tehaseseadetele. Selle telefoni kasutamiseks sisestage oma eelmine muster."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="2128795640346033349">"Teie telefon lähtestati tehaseseadetele. Selle telefoni kasutamiseks sisestage oma eelmine PIN-kood."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="4031863562975125016">"Teie telefon lähtestati tehaseseadetele. Selle telefoni kasutamiseks sisestage oma eelmine parool."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Mustri kinnitamine"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"PIN-koodi kinnitamine"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Parooli kinnitamine"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Vale PIN-kood"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Vale parool"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Vale muster"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Seadme turvalisus"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Muuda avamismustrit"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Muuda avamise PIN-koodi"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Joonistage avamismuster"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Abi saamiseks vajutage valikut Menüü."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Kui olete valmis, siis tõstke sõrm"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Ühendage vähemalt <xliff:g id="NUMBER">%d</xliff:g> punkti. Proovige uuesti."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Muster on salvestatud"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Joonistage muster kinnitamiseks uuesti"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Teie uus avamismuster"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Kinnita"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Koosta uuesti"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Kustuta"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Jätka"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Avamismuster"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Mustri nõudmine"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Ekraani avamiseks tuleb koostada muster"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Tee muster nähtavaks"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Muuda profiilimuster nähtavaks"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibreeri puudutamisel"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Lukustamine toitenupuga"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Välja arvatud siis, kui <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> hoiab seadet avatuna"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Määra avamismuster"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Muuda avamismustrit"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kuidas joonistada avamismustrit"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Liiga palju valesid katseid. Proovige uuesti <xliff:g id="NUMBER">%d</xliff:g> sekundi pärast."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Rakendus pole teie telefoni installitud."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Tööprofiili turvalisus"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Tööprofiili ekraanilukk"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Kasuta ühte lukku"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Tööprofiili ja seadme ekraani puhul kasutatakse ühte lukku"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Kas kasutada ühte lukku?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Seade kasutab teie tööprofiili ekraanilukku. Mõlema luku puhul kehtivad tööreeglid."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Teie tööprofiili lukk ei vasta teie organisatsiooni turvanõuetele. Seadme ekraani ja tööprofiili puhul saate kasutada sama lukku, kuid selle puhul kehtivad tööprofiili luku eeskirjad."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Kasuta ühte lukku"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Kasuta ühte lukku"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Sama mis seadme ekraanilukk"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Halda rakendusi"</string>
    <string name="manageapplications_settings_summary" msgid="848586372489062357">"Installitud rakenduste haldamine ja eemaldamine"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Rakenduste teave"</string>
    <string name="applications_settings_summary" msgid="8206066893744768531">"Rakenduste haldamine, kiirkäivituse otseteede seadistamine"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Rakenduse seaded"</string>
    <string name="install_applications" msgid="3921609656584369901">"Tundmatud allikad"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Luba kõik rakenduse allikad"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Hiljuti avatud rakendused"</string>
    <plurals name="see_all_apps_title" formatted="false" msgid="6864581406735745400">
      <item quantity="other">Kuva kõik %1$d rakendust</item>
      <item quantity="one">Kuva kõik rakendused</item>
    </plurals>
    <string name="forgot_password_title" msgid="3967873480875239885">"Võtke ühendust IT-administraatoriga"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Need aitavad teil lähtestada PIN-koodi, mustri või parooli"</string>
    <string name="install_all_warning" product="tablet" msgid="7010749217925069520">"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="652516435709047343">"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="2348262609815354500">"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="2368905204839169094">"Täpsemad seaded"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Luba rohkem seadete valikuid"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Rakenduste teave"</string>
    <string name="storage_label" msgid="2522307545547515733">"Mäluruum"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Avamine vaikimisi"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Vaikeseaded"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Ekraani ühilduvus"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Load"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Vahemälu"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Tühjenda vahemälu"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Vahemälu"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="8212425823423508096">
      <item quantity="other">%d üksust</item>
      <item quantity="one">1 üksus</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Tühista juurdepääs"</string>
    <string name="controls_label" msgid="8671492254263626383">"Juhtnupud"</string>
    <string name="force_stop" msgid="2681771622136916280">"Sunni peatuma"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Kokku"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Rakenduse suurus"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Rakendus USB-mäluseadmel"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Kasutajaandmed"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="1054860423004751290">"USB-mäluseadme andmed"</string>
    <string name="external_data_size_label" product="default" msgid="3370825186202856353">"SD-kaart"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Desinstalli"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Kõikidelt kasutajatelt desinstallimine"</string>
    <string name="install_text" msgid="4558333621516996473">"Installi"</string>
    <string name="disable_text" msgid="5146002260857428005">"Keela"</string>
    <string name="enable_text" msgid="8570798764647110430">"Luba"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Tühjenda salvestusruum"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Desinstalli värskendused"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Mõni teie valitud tegevus avaneb selles rakenduses vaikimisi."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Olete lubanud sellel rakendusel vidinaid luua ja nende andmetele juurde pääseda."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Vaike-eelistusi pole määratud."</string>
    <string name="clear_activities" msgid="488089228657585700">"Tühista vaike-eelistused"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"See rakendus ei pruugi teie ekraanile sobida. Sobivust saate kontrollida siin."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Küsi käivitamisel"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Skaleeri rakendus"</string>
    <string name="unknown" msgid="8192160131923461175">"Tundmatu"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Sordi nime alusel"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Sordi suuruse järgi"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Kõige hiljutisemad"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Kõige sagedasemad"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Kuva töötavad teenused"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Kuva vahemällu salvestatud protsessid"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Hädaabirakendus"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Rakenduste eelistuste lähtestamine"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Lähtestada rakenduste eelistused?"</string>
    <string name="reset_app_preferences_desc" msgid="6509978724602405805">"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="2591318711372850058">"Lähtesta rakendused"</string>
    <string name="manage_space_text" msgid="9013414693633572277">"Halda ruumi"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Filtrivalikute valimine"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Kõik rakendused"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Keelatud rakendused"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Allalaaditud"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Töös"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="5140211657134608469">"USB-mäluseade"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1774499644768369891">"SD-kaardil"</string>
    <string name="not_installed" msgid="5074606858798519449">"Pole selle kasutaja jaoks installitud"</string>
    <string name="installed" msgid="2837449358488825884">"Installitud"</string>
    <string name="no_applications" msgid="985069304755391640">"Rakendusi pole."</string>
    <string name="internal_storage" msgid="999496851424448809">"Sisemälu"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Suuruse ümberarvutamine ..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Kas kustutada rakenduse andmed?"</string>
    <string name="clear_data_dlg_text" msgid="7870723948123690332">"Rakenduse kõik andmed kustutatakse lõplikult. See hõlmab kõiki faile, seadeid, kontosid, andmebaase jne."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Tühista"</string>
    <string name="app_not_found_dlg_title" msgid="7122106240981109930"></string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Rakendust ei leitud installitud rakenduste loendist."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Rakenduse salvestusruumi ei õnnestunud tühjendada."</string>
    <string name="join_two_items" msgid="7893073836681382429">"<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="5301233410730513655">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="4915310659841174866">"Arvutamine ..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Paketi suurust ei saanud arvutada."</string>
    <string name="version_text" msgid="7628938665256107608">"versioon <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Teisalda"</string>
    <string name="move_app_to_internal" product="tablet" msgid="5799782476959541144">"Teisalda tahvelarvutisse"</string>
    <string name="move_app_to_internal" product="default" msgid="7395498801589544372">"Teisalda telefoni"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="1145367822171576972">"Teisalda USB-mällu"</string>
    <string name="move_app_to_sdcard" product="default" msgid="7161667212614143767">"Teisalda SD-kaardile"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Teine üleviimine on juba pooleli."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Ei ole piisavalt ruumi."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Rakendust ei ole olemas."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Installimise asukoht ei ole kehtiv."</string>
    <string name="system_package" msgid="7559476279008519360">"Süsteemivärskendusi ei saa installida välisele kandjale."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Seadme administraatori rakendust ei saa installida välisele andmekandjale"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Kas peatada sunniviisiliselt?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Kui sunnite rakenduse peatuma, võib see toimida valesti."</string>
    <string name="app_install_location_title" msgid="8932938164156303191">"Eelistatud installiasukoht"</string>
    <string name="app_install_location_summary" msgid="4948270795544357021">"Muutke uute rakenduste eelistatud installiasukohta"</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Keela rakendus"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Selle rakenduse keelamisel ei pruugi Android ja muud rakendused enam ootuspäraselt töötada. Pange tähele, et seda rakendust ei saa kustutada, kuna see on seadmesse eelinstallitud. Rakenduse keelamisel lülitatakse see välja ja peidetakse seadmes."</string>
    <string name="app_disable_notifications_dlg_title" msgid="6686569904059411780">"Kas lülitada teatised välja?"</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Pood"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Rakenduse üksikasjad"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Rakendus installiti poest <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Lisateavet leiate teenusest <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Töötab"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Pole kasutatud)"</string>
    <string name="no_default_apps" msgid="8966319676910104570">"Vaikerakendusi pole."</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Kasutatud mälu"</string>
    <string name="storageuse_settings_summary" msgid="5001621552305431831">"Vaadake rakenduste kasutatavat mälu"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Taaskäivitamine"</string>
    <string name="cached" msgid="5379485147573438201">"Vahemällu salvestatud taustaprotsess"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Midagi ei esitata"</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Käivitas rakendus"</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> vaba"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> kasutusel"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Kasutaja: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Eemaldatud kasutaja"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsess ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenus"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsess ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenust"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsessi ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenus"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> protsessi ja <xliff:g id="NUMSERVICES">%2$d</xliff:g> teenust"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Seadme mälu"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Rakenduse RAM-i kasutus"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Süsteem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Rakendused"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Vaba"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Kasutati"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Vahemälus"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-i"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Käitatav rakendus"</string>
    <string name="no_services" msgid="3898812785511572899">"Pole aktiivne"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Teenused"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Protsessid"</string>
    <string name="service_stop" msgid="5712522600201308795">"Peata"</string>
    <string name="service_manage" msgid="3896322986828332075">"Seaded"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Selle teenuse käivitas tema rakendus. Selle peatamine võib põhjustada rakenduse sulgemise."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Seda rakendust ei saa ohutult peatada. Peatamisel võite kaotada osa oma praegusest tööst."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"See on vana rakenduse protsess, mida igaks juhuks ikka veel käitatakse. Selle peatamiseks pole tavaliselt põhjust."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: praegu kasutusel. Puudutage selle juhtimiseks valikut Seaded."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Peamine protsess on kasutusel."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Teenus <xliff:g id="COMP_NAME">%1$s</xliff:g> on kasutusel."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Teenusepakkuja <xliff:g id="COMP_NAME">%1$s</xliff:g> on kasutusel."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Kas peatada süsteemi teenus?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="2076922609580490122">"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="2625863973434309085">"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="3292455685728572960">"Keeled, sisestus ja liigutused"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="8670153838520237089"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="2738661322747920463"></string>
    <string name="language_input_gesture_summary_off" msgid="1604575860215661606"></string>
    <string name="language_settings" msgid="8700174277543875046">"Keeled ja sisend"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Teil pole luba seadme keele muutmiseks."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Keeled ja sisend"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Tööriistad"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Klaviatuur ja sisestusmeetodid"</string>
    <string name="phone_language" msgid="5986939176239963826">"Keeled"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automaatne asendamine"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Paranda valesti sisestatud sõnad"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Autom. suurtähtede kasut."</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Lausete alguses suurtähtede kasutamine"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automaatsed kirjavahemärgid"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Füüsilise klaviatuuri seaded"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Vajutage kaks korda tühikuklahvi, et sisestada „.”"</string>
    <string name="show_password" msgid="7101900779571040117">"Kuva paroolid"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Sisestamisel kuvatakse hetkeks tähemärgid"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"See õigekirjakontrollija võib koguda kogu sisestatava teksti, sh isiklikud andmed (nt paroolid ja krediitkaardinumbrid). See pärineb rakendusest <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Kas soovite seda õigekirjakontrolli kasutada?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Seaded"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Keel"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Klaviatuurid"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Ekraanil kuvatav klaviatuur"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Saadaolev ekraanil kuvatav klaviatuur"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Ekraanil kuvatavate klaviatuuride haldamine"</string>
    <string name="keyboard_assistance_category" msgid="7320599809770932032">"Klaviatuuri abi"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Füüsiline klaviatuur"</string>
    <string name="show_ime" msgid="4334255501724746849">"Kasuta ekraaniklaviatuuri"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Hoia seda ekraanil, kui füüsiline klaviatuur on aktiivne"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Klaviatuuri otseteed"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="8649760728213630156">"Saadaolevate otseteede kuvamine"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tööprofiili klaviatuurid ja tööriistad"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Ekraanil kuvatav klaviatuur tööks"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Vaikeseade"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Kursori kiirus"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Mängukontroller"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Vibreerimise ümbersuunamine"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Saadab vibreerimise mängukontrollerisse, kui see on ühendatud"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Klaviatuuri paigutuse valimine"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Seadista klaviatuuri paigutus"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Vahetamiseks vajutage Ctrl+tühikut"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Vaikepaigutus"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Klaviatuuri paigutused"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Isiklik sõnaraamat"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Isiklik kataloog töö jaoks"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Lisage sõnu, mida kasutada sellistes rakendustes nagu Õigekirjakontroll"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Lisa"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Sõnastikku lisamine"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Fraas"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Rohkem valikuid"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Vähem valikuid"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Sõna:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Otsetee:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Keel:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Sisestage sõna"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Valikuline otsetee"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Muuda sõna"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Muuda"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Kustuta"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Kasutaja sõnaraamatus ei ole ühtki sõna. Sõna lisamiseks puudutage nuppu Lisa (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Kõikides keeltes"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Rohkem keeli ..."</string>
    <string name="testing" msgid="6294172343766732037">"Testimine"</string>
    <string name="testing_phone_info" product="tablet" msgid="1910768200608214456">"Teave tahvelarvuti kohta"</string>
    <string name="testing_phone_info" product="default" msgid="1150527695827743906">"Telefoni andmed"</string>
    <string name="input_methods_settings_title" msgid="7796027458321225550">"Tekstisisestus"</string>
    <string name="input_method" msgid="2982805181425436775">"Sisestusmeetod"</string>
    <string name="current_input_method" msgid="3471068842881330883">"Praegune klaviatuur"</string>
    <string name="input_method_selector" msgid="8463209725824763600">"Sisestusmeetodi valija"</string>
    <string name="input_method_selector_show_automatically_title" msgid="6483428482089875034">"Automaatne"</string>
    <string name="input_method_selector_always_show_title" msgid="2479533500357556146">"Kuva alati"</string>
    <string name="input_method_selector_always_hide_title" msgid="807424180027384849">"Peida alati"</string>
    <string name="configure_input_method" msgid="8831343065130376880">"Sisestusmeetodite seadistamine"</string>
    <string name="input_method_settings" msgid="4177883733022569830">"Seaded"</string>
    <string name="input_method_settings_button" msgid="5145039044301426311">"Seaded"</string>
    <string name="input_methods_settings_label_format" msgid="5809693308957109022">"Üksuse <xliff:g id="IME_NAME">%1$s</xliff:g> seaded"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="8940326108334307057">"Aktiivsete sisestusmeetodite valim."</string>
    <string name="onscreen_keyboard_settings_summary" msgid="3975358507879701606">"Ekraaniklaviatuuri seaded"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Füüsiline klaviatuur"</string>
    <string name="builtin_keyboard_settings_summary" msgid="4332792334499933856">"Füüsilise klaviatuuri seaded"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Valige vidin"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Valige vidin"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Kas luua vidin ja lubada juurdepääs?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5694218981358874429">"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="7268758525344468364">"Luba rakendusel <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> alati vidinaid luua ja nende andmetele juurdepääs hankida"</string>
    <string name="usage_stats_label" msgid="6523644917803320085">"Kasutusstatistika"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Kasutusstatistika"</string>
    <string name="display_order_text" msgid="7120394778684605892">"Sortimisalus:"</string>
    <string name="app_name_label" msgid="3809910527680143673">"Rakendus"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Viimane kasutamine"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Kasutusaeg"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Juurdepääsetavus"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Juurdepääsetavuse seaded"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Ekraan, interaktsioon, heli"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Nähtavuse seaded"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Seadet saab kohandada vastavalt oma vajadustele. Neid juurdepääsetavuse funktsioone saab hiljem muuta menüüs Seaded."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Muutke fondi suurust"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekraanilugeja"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Subtiitrid"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Heli"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Üldine"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Ekraan"</string>
    <string name="accessibility_text_and_display_title" msgid="1398507755501334961">"Tekst ja ekraanikuva"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekraanikuva muutmine tumedamaks"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktsiooni juhtnupud"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Aja juhtnupud"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Süsteemi juhtelemendid"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Allalaaditud rakendused"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Katseline"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Funktsiooni märgistamised"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Peamiselt pimedatele ja halva nägemisega inimestele mõeldud ekraanilugeja"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Ekraanil olevate üksuste ettelugemise kuulmiseks puudutage neid"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Subtiitrite eelistused"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Suurendus"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Suurendamise viis"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Suurendage täisekraani, konkreetset ala või vahetage mõlema võimaluse vahel"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Täisekraan"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Ekraani osa"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Täisekraani ja ekraani osa vahel vahetamine"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Valige suurendamise viis"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Täisekraani suurendamine"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Ekraanikuva osa suurendamine"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Täisekraani ja ekraani osa vahel vahetamine"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Mõlema valiku vahel vahetamiseks puudutage lülitusnuppu"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Kas lülitada juurdepääsetavuse nupule?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Kolmikpuudutuse kasutamine ekraanikuva teatud osa suurendamiseks põhjustab teksti sisestamisel ja muudel juhtudel viiteid.\n\nJuurdepääsetavuse nupp hõljub ekraanikuval teiste rakenduste kohal. Suurendamiseks puudutage seda."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Lülita juurdepääsetavuse nupule"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Kasuta kolmikpuudutust"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Suurendamisseaded"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Kolmikpuudutusega suurendamine"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Otsetee abil suurendamine"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Otsetee ja kolmikpuudutusega suurendamine"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Teave funktsiooni <xliff:g id="SERVICE">%1$s</xliff:g> kohta"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Valikud"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Suumige ekraanil sisse"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Suumimiseks puudutage kolm korda"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Suumimiseks puudutage nuppu"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2527664482392097865">"Suumige ekraanikuval kiiresti sisse, et sisu suuremalt kuvada.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Sissesuumimiseks toimige järgmiselt.&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Kasutage suurendamise alustamiseks otseteed.&lt;br/&gt; {1,number,integer}. Puudutage ekraani.&lt;br/&gt; {2,number,integer}. Ekraanikuval liikumiseks lohistage kahe sõrmega.&lt;br/&gt; {3,number,integer}. Suumi kohandamiseks liigutage ekraanil kaht sõrme kokku-lahku.&lt;br/&gt; {4,number,integer}. Kasutage suurendamise lõpetamiseks otseteed.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Ajutiseks sissesuumimiseks toimige järgmiselt.&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Kasutage suurendamise alustamiseks otseteed.&lt;br/&gt; {1,number,integer}. Hoidke sõrme kus tahes ekraanikuval.&lt;br/&gt; {2,number,integer}. Lohistage ekraanikuval liikumiseks sõrme.&lt;br/&gt; {3,number,integer}. Suurendamise lõpetamiseks tõstke sõrm ekraanikuvalt."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Kui suurendusfunktsioon on sisse lülitatud, saate oma ekraanikuval sisse suumida.\n\n"<b>"Suumimiseks"</b>" käivitage suurendusfunktsioon ja puudutage siis ekraanikuval mis tahes kohta.\n"<ul><li>"Kerimiseks lohistage kahe või enama sõrmega."</li>\n<li>"Suumi kohandamiseks pigistage kahte või enamat sõrme kokku."</li></ul>\n\n<b>"Ajutiseks suumimiseks"</b>" käivitage suurendusfunktsioon ja puudutage siis ekraanikuval pikalt mis tahes kohta.\n"<ul><li>"Ekraanikuval teisaldamiseks lohistage sõrme."</li>\n<li>"Väljasuumimiseks tõstke sõrm ekraanilt."</li></ul>\n\n"Klaviatuuril ega navigeerimisribal ei saa sisse suumida."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"<xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. leht <xliff:g id="NUM_PAGES">%2$d</xliff:g>-st"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Avamiseks juurdepääsetavuse nupu kasutamine"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Avamiseks hoidke helitugevuse klahve all"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Avamiseks puudutage ekraani kolm korda"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Kasutage avamiseks liigutust"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8485448068531147828">"Kasutage uut juurdepääsetavuse liigutust"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Selle funktsiooni kasutamiseks puudutage ekraanikuva allosas juurdepääsetavuse nuppu <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nFunktsioonide vahel vahetamiseks puudutage juurdepääsetavuse nuppu pikalt."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Selle funktsiooni kasutamiseks puudutage ekraanikuval juurdepääsetavuse nuppu"</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Selle funktsiooni kasutamiseks vajutage pikalt mõlemat helitugevuse klahvi."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Suurenduse käivitamiseks ja peatamiseks puudutage ekraani kolm korda."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Selle funktsiooni kasutamiseks pühkige ekraanikuva allosast kahe sõrmega üles.\n\nFunktsioonide vahel vahetamiseks pühkige kahe sõrmega üles ja hoidke sõrmi ekraanil."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Selle funktsiooni kasutamiseks pühkige ekraanikuva allosast kolme sõrmega üles.\n\nFunktsioonide vahel vahetamiseks pühkige kolme sõrmega üles ja hoidke sõrmi ekraanil."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Juurdepääsufunktsiooni kasutamiseks pühkige ekraanikuva allosast kahe sõrmega üles.\n\nFunktsioonide vahel vahetamiseks pühkige kahe sõrmega üles ja hoidke sõrmi ekraanil."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Juurdepääsufunktsiooni kasutamiseks pühkige ekraanikuva allosast kolme sõrmega üles.\n\nFunktsioonide vahel vahetamiseks pühkige kolme sõrmega üles ja hoidke sõrmi ekraanil."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Selge"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Funktsiooni <xliff:g id="SERVICE">%1$s</xliff:g> otsetee"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Juurdepääsetavuse nupp"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Juurdepääsuliigutus"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Pühkige kahe sõrmega üles"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Pühkige kolme sõrmega üles"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Juurdepääsetavuse nupu puudutamine"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Juurdepääsuliigutuse kasutamine"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Puudutage ekraanikuva allosas olevat juurdepääsetavuse nuppu <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nFunktsioonide vahel vahetamiseks vajutage juurdepääsetavuse nuppu pikalt."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Pühkige kahe sõrmega ekraanikuva allosast üles.\n\nFunktsioonide vahel vahetamiseks pühkige kahe sõrmega üles ja hoidke."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Pühkige kolme sõrmega ekraanikuva allosast üles.\n\nFunktsioonide vahel vahetamiseks pühkige kolme sõrmega üles ja hoidke."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Rohkem valikuid"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Lisateave: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Helitugevuse klahvide allhoidmine"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"helitugevuse klahvide allhoidmine"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Hoidke all mõlemat helitugevuse klahvi"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Ekraani kolm korda puudutamine"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"ekraani puudutamine kolm korda"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Puudutage ekraani kiiresti {0,number,integer} korda. See otsetee võib teie seadme tööd aeglustada."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Täpsemad"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Juurdepääsetavuse nupu jaoks on valitud seade <xliff:g id="SERVICE">%1$s</xliff:g>. Suurenduse kasutamiseks puudutage ja hoidke juurdepääsetavuse nuppu ning seejärel valige suurendus."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"See juurdepääsetavuse liigutus on määratud teenusele <xliff:g id="SERVICE">%1$s</xliff:g>. Suurenduse kasutamiseks pühkige kahe sõrmega ekraanikuva allosast üles ja hoidke sõrmi ekraanil. Seejärel tehke valik Suurendus."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Helitugevuse nupu otsetee"</string>
    <string name="accessibility_shortcut_service_title" msgid="6842883700702723355">"Otsetee teenus"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Otsetee seaded"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Otsetee lukustuskuval"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Lukustuskuval sisselülitamiseks lubage funktsiooni otsetee. Hoidke mõlemat helitugevuse klahvi mõni sekund all."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Juurdepääsetavuse nupp"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Juurdepääsetavuse nupp ja liigutus"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Juurdepääsetavuse nupu kasutamine. Liigutus ei ole kolme nupuga navigeerimise puhul saadaval."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Kiirjuurdepääs juurdepääsufunktsioonidele"</string>
    <string name="accessibility_button_gesture_description" msgid="2516420653060025670">"Pääsege juurdepääsufunktsioonidele kiiresti juurde igalt kuvalt.\n\nAlustamiseks avage juurdepääsetavuse seaded ja valige funktsioon. Puudutage otseteed ja valige juurdepääsetavuse nupp.\n\nKui soovite juurdepääsetavuse nuppu hoopis navigeerimisribal kasutada, lülitage ümber kahe nupuga navigeerimisele või kolme nupuga navigeerimisele."</string>
    <string name="accessibility_button_description" msgid="7372405202698400339">"Pääsege juurdepääsufunktsioonidele kiiresti juurde igalt kuvalt. \n\nAlustamiseks avage juurdepääsetavuse seaded ja valige funktsioon. Puudutage otseteed ja valige juurdepääsetavuse nupp."</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Nupu või liigutuse kasutamine"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Asukoht"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Suurus"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Hajuta, kui seda ei kasutata"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Hajub mõne sekundi pärast, et kuva oleks hõlpsam näha"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Läbipaistvus, kui nuppu ei kasutata"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Läbipaistev"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Läbipaistmatu"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Suure kontrastsusega tekst"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ekraanisuurenduse värskendus"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Ekraanisuurenduse kasutus rakenduste vahetamisel"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Toitenupp lõpetab kõne"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Suur hiirekursor"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Animatsioonide eemaldamine"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Monoheli"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Kanalite ühendamine heli esitamisel"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Heli tasakaal"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Vasak"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Parem"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Vaikeseade"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekundit"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekundit"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minut"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minutit"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Aeg toimingu tegemiseks (juurdepääsu ajalõpp)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Aeg toimingu tegemiseks"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="5283566580551714506">"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="5237764682976688855">"Puute ja hoidmise viide"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Värvide ümberpööramine"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Kasuta värvide ümberpööramist"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="6955835010409034745">"Värvide ümberpööramine muudab ekraanikuva tumedaks.&lt;br/&gt;&lt;br/&gt; Märkus. &lt;ol&gt; &lt;li&gt; Samuti muudab värvide ümberpööramine tumedad ekraanikuvad heledaks.&lt;/li&gt; &lt;li&gt; Meedia ja piltide värvid muutuvad.&lt;/li&gt; &lt;li&gt; Tumeda tausta kuvamiseks saab kasutada ka tumedat teemat. Tume teema töötab toetatud rakendustes. Värvide ümberpööramine töötab kõigis rakendustes.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automaatklikk (peatumisaeg)"</string>
    <string name="accessibility_autoclick_description" msgid="6827042379062255307">"Automaatklikk toimib ühendatud hiire korral. Saate hiirekursori seadistada automaatselt klõpsama, kui kursor teatud ajaks peatub."</string>
    <string name="accessibility_autoclick_default_title" msgid="752429113115293087">"Väljas"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Lühike"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekundit"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Keskmine"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundit"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Pikk"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekund"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Kohandatud"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Lühem"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Pikem"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Automaatse kliki aeg"</string>
    <string name="accessibility_vibration_settings_title" msgid="5198184603753129450">"Vibreerimise ja värintagasiside tugevus"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Märguanne koos vibreerimisega"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Helin koos vibreerimisega"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Puudutuste tagasiside"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Kasuta rakendust <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"URL-i <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> avamine"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Kasuta värvide korrigeerimist"</string>
    <string name="accessibility_caption_primary_switch_title" msgid="8901149325574757370">"Kuva subtiitrid"</string>
    <string name="accessibility_caption_primary_switch_summary" msgid="2754071646412717674">"Ainult toetatud rakendustes"</string>
    <string name="captioning_caption_appearance_title" msgid="4501313548541670063">"Subtiitrite suurus ja stiil"</string>
    <string name="captioning_caption_appearance_summary" msgid="7340741178479381312">"Teksti suurus – <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Rohkem valikuid"</string>
    <string name="accessibility_caption_preference_summary" msgid="1191356970836416954">"Kõik rakendused ei toeta neid subtiitrite eelistusi"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Juurdepääsetavuse nupp"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Kahe sõrmega alt üles pühkimine"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Helitugevuse klahvide allhoidmine"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Kolmikpuudutuse ekraanikuva"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Jätka"</string>
    <string name="accessibility_hearingaid_title" msgid="427173678199203191">"Kuuldeaparaadid"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"Ühtegi kuuldeaparaati pole ühendatud"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Lisa kuuldeaparaate"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="8913409742121315657">"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="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> on aktiivne"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="776000580683647556">
      <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_audio_adjustment_title" msgid="1332113739136802997">"Heli kohandamine"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Otsetee on sees"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Väljas"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Sees"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Väljas"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Ei tööta. Puudutage teabe nägemiseks."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Selle teenuse töös esineb häireid."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Juurdepääsetavuse otseteed"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Kuva kiirseadetes"</string>
    <string name="daltonizer_type" msgid="1715154680803795947">"Korrigeerimise režiim"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="3811397143576433035">"Deuteranomaalia"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6787594316700223938">"Protanomaalia"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="1869867447813349033">"Tritanomaalia"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Halltoonid"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="791173297742998942">"Punane-roheline"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="482834207025141433">"Punane-roheline"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2837137091067433059">"Sinine-kollane"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Eriti tume"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Ekraanikuva eriti tumedaks muutmine"</string>
    <string name="reduce_bright_colors_preference_summary" product="default" msgid="7878756844769221647">"Muutke ekraanikuva tumedamaks kui teie telefoni miinimumeredus"</string>
    <string name="reduce_bright_colors_preference_summary" product="tablet" msgid="8959794720356934888">"Muutke ekraanikuva tumedamaks kui teie tahvelarvuti miinimumeredus"</string>
    <string name="reduce_bright_colors_preference_subtitle" product="default" msgid="1061317523242240222">"Muutke ekraanikuva tumedamaks, et seda oleks mugavam lugeda.&lt;br/&gt;&lt;br/&gt; See võib olla kasulik järgmistel juhtudel. &lt;ol&gt; &lt;li&gt; Teie telefoni vaikemiinimumeredus on siiski liiga ere.&lt;/li&gt; &lt;li&gt; Kasutate oma telefoni pimedas, näiteks öösel või pimedas ruumis enne magamaminekut.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="reduce_bright_colors_preference_subtitle" product="tablet" msgid="7839714100830254580">"Muutke ekraanikuva tumedamaks, et seda oleks mugavam lugeda.&lt;br/&gt;&lt;br/&gt; See võib olla kasulik järgmistel juhtudel. &lt;ol&gt; &lt;li&gt; Teie tahvelarvuti vaikemiinimumheledus on siiski liiga ere.&lt;/li&gt; &lt;li&gt; Kasutate oma tahvelarvutit pimedas, näiteks öösel või pimedas ruumis enne magamaminekut.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensiivsus"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Tuhmim"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Heledam"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Hoia pärast seadme taaskäivitumist sisselülitatuna"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5354221071353645263">
      <item quantity="other">Lühike (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundit)</item>
      <item quantity="one">Lühike (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekund)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_medium_delay" formatted="false" msgid="1550891909800510628">
      <item quantity="other">Keskmine (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundit)</item>
      <item quantity="one">Keskmine (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekund)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="2230755548820485984">
      <item quantity="other">Pikk (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> sekundit)</item>
      <item quantity="one">Pikk (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekund)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_delay_unit_second" formatted="false" msgid="4537791441118261556">
      <item quantity="other"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> sekundit</item>
      <item quantity="one"><xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> sekund</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="27904038683405084">"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="7776105450117095736">"Helina ja märguannete vibreerimine lülitati välja"</string>
    <string name="accessibility_vibration_summary_low" msgid="6482721005400340317">"Helina ja märguannete vibreerimine seati tasemele Nõrk"</string>
    <string name="accessibility_vibration_summary_medium" msgid="2348889320548746469">"Helina ja märguannete vibreerimine seati tasemele Keskmine"</string>
    <string name="accessibility_vibration_summary_high" msgid="1764693979030913712">"Helina ja märguannete vibreerimine seati tasemele Tugev"</string>
    <string name="accessibility_vibration_intensity_off" msgid="972159695404061944">"Väljas"</string>
    <string name="accessibility_vibration_intensity_low" msgid="6311161118835287335">"Nõrk"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="1734058611879392797">"Keskmine"</string>
    <string name="accessibility_vibration_intensity_high" msgid="5982896399775212514">"Tugev"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Seaded"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Sees"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Väljas"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Eelvaade"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardvalikud"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Keel"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Teksti suurus"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Subtiitri stiil"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Kohandatud valikud"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Tausta värv"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Tausta läbipaistvus"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Tiitrite akna värv"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Tiitrite akna läbipaistvus"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Teksti värv"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Teksti läbipaistvus"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Serva värv"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Serva tüüp"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Fondi perekond"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Subtiitrid näevad välja sellised"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Vaikeseade"</string>
    <string name="color_title" msgid="2511586788643787427">"Värv"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Vaikevärv"</string>
    <string name="color_none" msgid="3703632796520710651">"Puudub"</string>
    <string name="color_white" msgid="1896703263492828323">"Valge"</string>
    <string name="color_gray" msgid="8554077329905747877">"Hall"</string>
    <string name="color_black" msgid="9006830401670410387">"Must"</string>
    <string name="color_red" msgid="5210756997426500693">"Punane"</string>
    <string name="color_green" msgid="4400462091250882271">"Roheline"</string>
    <string name="color_blue" msgid="4997784644979140261">"Sinine"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Tsüaan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Kollane"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Fuksia"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Kas anda teenusele <xliff:g id="SERVICE">%1$s</xliff:g> teie seadme üle täielik kontroll?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> teeb järgmist:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Seaded ei saa teie vastust kinnitada, sest rakendus varjab loataotlust."</string>
    <string name="enable_service_encryption_warning" msgid="931082737770453755">"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="669152607190123579">"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="6832846117817938536">"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="6040417014360237703">"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="6962544350351734238">"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="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> taotleb seadme täielikku haldusõigust. Teenus saab juurdepääsufunktsioone vajavate kasutajate nimel ekraani lugeda ja tegutseda. See haldusõiguse tase ei ole enamiku rakenduste puhul sobilik."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Täielik haldusõigus sobib rakendustele, mis pakuvad juurdepääsufunktsioone. Enamiku rakenduste puhul seda ei soovitata."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Ekraanikuva vaatamine ja haldamine"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"See saab lugeda kogu ekraanil kuvatud sisu ja kuvada sisu rakenduste peal."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Toimingute vaatamine ja tegemine"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"See saab jälgida teie suhtlust rakenduse või riistvaraanduriga ja teie eest rakendustega suhelda."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Luba"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Keela"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Peata"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Tühista"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Kas peatan teenuse <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Nupu <xliff:g id="STOP">%1$s</xliff:g> puudutamisel teenus <xliff:g id="SERVICE">%2$s</xliff:g> peatatakse."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Ühtki teenust pole installitud"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Ükski teenus ei ole valitud"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Kirjeldust ei ole sisestatud."</string>
    <string name="settings_button" msgid="2195468788019730377">"Seaded"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"valgustundlikkus, fotofoobia, tume teema, migreen, peavalu, lugemisrežiim, öörežiim, ereduse vähendamine, valge punkt"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Lihtne kasutada, lihtne juurdepääs, abi, abistav"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Akna suurendaja, suum, suurendamine, halb nähtavus, suurendus, suuremaks muutmine"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Subtiitrid, reaalajas transkriptsioon, kuulmislangus, kuulmiskadu, CART, kõnesüntees"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"ekraani suurus, suur ekraan"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Kõrge kontrastsus, halb nähtavus, paks font, paks esiletõst"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"värvide korrigeerimine"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"ekraanikuva tumendamine, ekraanikuva helendamine"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motoorika, hiir"</string>
    <string name="keywords_hearing_aids" msgid="524979615168196199">"kuulmislangus, kuulmiskadu"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"kuulmislangus, kuulmiskadu, subtiitrid, teletaip, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Printimine"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Väljas"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="1034273609054146099">
      <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="3933688846338306536">
      <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="7680498284751129935">"Printimisteenused"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Ühtki teenust pole installitud"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Printereid ei leitud"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Seaded"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Printerite lisamine"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Sees"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Väljas"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Lisa teenus"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Lisa printer"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Otsing"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Printerite otsimine"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Teenus on keelatud"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Prinditööd"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Prinditöö"</string>
    <string name="print_restart" msgid="4424096106141083945">"Taaskäivita"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Tühista"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> seadistamine"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> printimine"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Prinditöö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> tühistamine"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Printeri viga: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printer blokeeris töö <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Otsingukast on kuvatud"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Otsingukast on peidetud"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Lisateave selle printeri kohta"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Aku"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Mis on akut kasutanud"</string>
    <string name="power_usage_not_available" msgid="3425302437465106036">"Aku andmed pole saadaval."</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Jäänud on <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> laadimise lõpuni"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Akutase on madal"</string>
    <string name="background_activity_title" msgid="8214332017349791380">"Taustal kasutamise piiramine"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Lubatakse rakenduse taustal käitamine"</string>
    <string name="background_activity_summary_disabled" msgid="32459916080651444">"Rakendusel ei ole lubatud taustal töötada"</string>
    <string name="background_activity_summary_allowlisted" msgid="6240154358657454651">"Taustal kasutamist ei saa piirata"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Kas piirata taustal tegevust?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Kui piirate rakenduse tegevust taustal, võib rakendus toimida valesti."</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Kuna rak. pole aku optimeerimine seadistatud, ei saa te seda piirata.\n\nRak. piiramiseks lülit. esmalt sisse aku optimeerimine."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Piiranguteta"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimeeritud"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Piiratud"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Akukasutus taustal lubatakse ilma piiranguteta. See võib kasutada rohkem akut."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimeerimine kasutuse järgi. Soovitatav enamiku rakenduste puhul."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Taustal töötades piiratakse akukasutust. Rakendus ei pruugi töötada ootuspäraselt. Märguanded võivad viibida."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Rakenduse akukasutuse muutmine võib mõjutada rakenduse toimivust."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"See rakendus nõuab akukasutust järgmises ulatuses: <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"piiranguteta"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimeeritud"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Lisateave akukasutuse valikute kohta"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Ekraani kasutus alates täislaadimisest"</string>
    <string name="power_usage_list_summary" msgid="3237540201918492925">"Akukasutus alates täislaadimisest"</string>
    <string name="screen_usage_summary" msgid="1393184943010909471">"Ekraani töötamise aeg alates viimasest täislaadimisest"</string>
    <string name="device_usage_list_summary" msgid="242243537371697285">"Seadme kasutus alates viimasest täislaadimisest"</string>
    <string name="battery_since_unplugged" msgid="6991509383429936921">"Akukasutus alates lahutamisest"</string>
    <string name="battery_since_reset" msgid="2930376112877476562">"Akukasutus alates lähtestamisest"</string>
    <string name="battery_stats_on_battery" msgid="1553011980384645514">"<xliff:g id="TIME">%1$s</xliff:g> akutoitel"</string>
    <string name="battery_stats_duration" msgid="6918768703070999743">"<xliff:g id="TIME">%1$s</xliff:g> alates lahutamisest"</string>
    <string name="battery_stats_charging_label" msgid="6204814386861342145">"Laadimine"</string>
    <string name="battery_stats_screen_on_label" msgid="8989312180491200138">"Ekraan sees"</string>
    <string name="battery_stats_gps_on_label" msgid="5626424078405382686">"GPS on sisse lülitatud"</string>
    <string name="battery_stats_camera_on_label" msgid="555635201416769359">"Kaamera on sees"</string>
    <string name="battery_stats_flashlight_on_label" msgid="1621027969559427783">"Taskulamp on sees"</string>
    <string name="battery_stats_wifi_running_label" msgid="6461551370010379049">"WiFi"</string>
    <string name="battery_stats_wake_lock_label" msgid="8115041205778441548">"Sisse lülitatud"</string>
    <string name="battery_stats_phone_signal_label" msgid="679649411998679555">"Mobiilsidevõrgu signaal"</string>
    <!-- no translation found for battery_stats_last_duration (3088100394725340600) -->
    <skip />
    <string name="awake" msgid="5405871714019268978">"Seadme ärkveloleku aeg"</string>
    <string name="wifi_on_time" msgid="3880778525760926066">"WiFi õigel ajal"</string>
    <string name="bluetooth_on_time" msgid="8424625554628450028">"WiFi õigel ajal"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Akukasutus"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Ajaloo üksikasjad"</string>
    <string name="advanced_battery_preference_title" msgid="3017771848679952419">"Akukasutus"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Kasutus viimase 24 tunni jooksul"</string>
    <string name="advanced_battery_preference_summary" msgid="6088389774708000305">"Kasutus viimasest täislaadimisest"</string>
    <string name="battery_details_title" msgid="4531369291819754178">"Akukasutus"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Kasuta detaile"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Reguleerige energiakasutust"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Kaasnevad paketid"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Rakendused töötavad tavapäraselt"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="6077959765904507849">"Telefon kasutab akut taustal tavapärases ulatuses"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="5063158368808711973">"Tahvelarvuti kasutab akut taustal tavapärases ulatuses"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="4242899844618910548">"Seade kasutab akut taustal tavapärases ulatuses"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Akutase on madal"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Lülitage aku tööea pikendamiseks sisse akusäästja"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Pikendage aku tööiga"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Lülitage sisse akuhaldur"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Lülitage akusäästja sisse"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Aku võib tavapärasest kiiremini tühjaks saada"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Akusäästja on sees"</string>
    <string name="battery_saver_link_a11y" msgid="740558184830458845">"Lisateave akusäästja kohta"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Mõned funktsioonid võivad olla piiratud"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Suur akukasutus"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Vaadake suurima akukasutusega rakendusi"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="5231061779363606924">"Laadimine on ajutiselt piiratud"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="8504402301403419444">"Aku säästmiseks. Vaadake lisateavet."</string>
    <!-- no translation found for battery_tip_dialog_message (4592387206991500075) -->
    <skip />
    <!-- no translation found for battery_tip_dialog_message (111303605119856034) -->
    <skip />
    <!-- no translation found for battery_tip_dialog_message (3896805213768863874) -->
    <skip />
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Hõlmab akut koormavaid taustategevusi"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="3108195491484891588">
      <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="5862649927574803958">
      <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="3328499737453686910">
      <item quantity="other">%2$d rakendust kasutavad taustal palju akut</item>
      <item quantity="one">Rakendus %1$s kasutab taustal palju akut</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="3036853535034350991">
      <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="7897944678619251740">
      <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="137856003724730751">"Aku säästmiseks peatage rakenduse <xliff:g id="APP">%1$s</xliff:g> jaoks taustal aku kasutamine. See rakendus ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Aku säästmiseks peatage nende rakenduste jaoks taustal aku kasutamine. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida.\n\nRakendused:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Aku säästmiseks peatage nende rakenduste jaoks taustal aku kasutamine. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida.\n\nRakendused:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Piira"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Kas eemaldada piirang?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"See rakendus saab taustal akut kasutada. Aku võib oodatust varem tühjaks saada."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Eemalda"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Tühista"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="6097167058237891756">"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="573297655597451123">"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="8222461068860745749">"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="3677620516657920364">"Akuhaldur"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Halda rakendusi automaatselt"</string>
    <string name="smart_battery_summary" product="default" msgid="1492277404000064998">"Akukasutuse piiramine rakenduste puhul, mida te ei kasuta sageli"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Kui akuhaldur tuvastab, et rakendused kurnavad akut, on teil võimalik nende rakenduste tööd piirata. Piiratud rakendused ei pruugi korralikult töötada ja märguanded võivad viibida."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Piiratud rakendused"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="6059772951505411003">
      <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="3097721884155913252">"Piiratud <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Need rakendused ei saa taustal akut kasutada. Need ei pruugi töötada oodatud viisil ja märguanded võivad viibida."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Akuhalduri kasutamine"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Tuvasta, kui rakendused kurnavad akut"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Tuvastatakse, kui rakendused kurnavad akut"</string>
    <string name="battery_manager_off" msgid="673547668722420924">"Väljas"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="6714534362166394848">
      <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="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Probleem akumõõdiku lugemisel."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Puudutage, et näha selle vea kohta lisateavet"</string>
    <string name="dialog_stop_title" msgid="5972757101865665655">"Kas peatada rakendus?"</string>
    <string name="dialog_stop_message" product="default" msgid="2063536418875183799">"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="426862716783569739">"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="4252335402634772603">"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="604462000476810125">"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="7737426241260791605">"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="1820679795932901383">"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="1171516542217183180">"Peata rakendus"</string>
    <string name="dialog_background_check_title" msgid="8571605969100408762">"Kas peatada rakendus ja lülitada taustal kasutamine välja?"</string>
    <string name="dialog_background_check_message" product="default" msgid="6203374578970183277">"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="1282389215667916176">"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="8005524265739819577">"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="5792934035264144797">"Lülita välja"</string>
    <string name="dialog_location_title" msgid="1323400468370901875">"Kas soovite asukohateabe edastamise välja lülitada?"</string>
    <string name="dialog_location_message" product="default" msgid="5597959072209122057">"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="7165269165194599595">"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="4606829479989940464">"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="6338680851382069716">"Lülita välja"</string>
    <string name="power_screen" msgid="4596900105850963806">"Ekraan"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Taskulamp"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kaamera"</string>
    <string name="power_wifi" msgid="4614007837288250325">"WiFi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="5507921058696341513">"Mobiilsidevõrk on ooterežiimis"</string>
    <string name="power_phone" msgid="2768396619208561670">"Tavakõned"</string>
    <string name="power_idle" product="tablet" msgid="4689321599298911021">"Tahvelarvuti on ooterežiimis"</string>
    <string name="power_idle" product="default" msgid="9132502722499465252">"Telefon tegevuseta"</string>
    <string name="power_unaccounted" msgid="2160811497426475703">"Muu"</string>
    <string name="power_overcounted" msgid="3681101460287472876">"Liigselt arvestatud"</string>
    <string name="usage_type_cpu" msgid="8544148642836549011">"CPU kokku"</string>
    <string name="usage_type_cpu_foreground" msgid="6120871498122604239">"CPU esiplaanil"</string>
    <string name="usage_type_wake_lock" msgid="3442487584173668904">"Hoia ärkvel"</string>
    <string name="usage_type_gps" msgid="4118035982288964651">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="5573404832197356206">"WiFi töötab"</string>
    <string name="usage_type_phone" product="tablet" msgid="4527092861928972130">"Tahvelarvuti"</string>
    <string name="usage_type_phone" product="default" msgid="4149330237181984782">"Telefon"</string>
    <string name="usage_type_data_send" msgid="4375755152437282184">"Saadetud mob.-andmeside paketid"</string>
    <string name="usage_type_data_recv" msgid="7821924049621005218">"Vastuvõetud m.-andmeside paketid"</string>
    <string name="usage_type_radio_active" msgid="1876069445855950097">"Mobiiliraadio on aktiivne"</string>
    <string name="usage_type_data_wifi_send" msgid="6154038607322769558">"Saadetud WiFi-paketid"</string>
    <string name="usage_type_data_wifi_recv" msgid="4821128213012023100">"Vastuvõetud WiFi-paketid"</string>
    <string name="usage_type_audio" msgid="1100651355357912864">"Heli"</string>
    <string name="usage_type_video" msgid="1068481638906679035">"Video"</string>
    <string name="usage_type_camera" msgid="3999579307204257822">"Kaamera"</string>
    <string name="usage_type_flashlight" msgid="5629235220169383309">"Taskulamp"</string>
    <string name="usage_type_on_time" msgid="104642441471272535">"Kestus"</string>
    <string name="usage_type_no_coverage" msgid="1385712176630900103">"Aeg ilma signaalita"</string>
    <string name="usage_type_total_battery_capacity" msgid="3878234027503885998">"Aku koguvmahtuvus"</string>
    <string name="usage_type_computed_power" msgid="5191902025833668752">"Arvutatud energiatarbimine"</string>
    <string name="usage_type_actual_power" msgid="1221358930299037926">"Tuvastatud energiatarbimine"</string>
    <string name="battery_action_stop" msgid="6998228610098034316">"Sunni peatuma"</string>
    <string name="battery_action_app_details" msgid="7201369216798227707">"Rakenduse teave"</string>
    <string name="battery_action_app_settings" msgid="2437124469335488464">"Rakenduse seaded"</string>
    <string name="battery_action_display" msgid="6515712081248863749">"Ekraani seaded"</string>
    <string name="battery_action_wifi" msgid="1829212604573932607">"WiFi-seaded"</string>
    <string name="battery_action_bluetooth" msgid="4723692623358386789">"Bluetoothi ​​seaded"</string>
    <string name="battery_desc_voice" msgid="6900799826084022585">"Tavakõnede akukasutus"</string>
    <string name="battery_desc_standby" product="tablet" msgid="5818742458684767043">"Akukasutus tahvelarvuti ooterežiimis"</string>
    <string name="battery_desc_standby" product="default" msgid="2543075041964578103">"Akukasutus telefoni ooterežiimis"</string>
    <string name="battery_desc_radio" msgid="454677140485133914">"Mobiiltelefoni raadio akukasutus"</string>
    <string name="battery_sugg_radio" msgid="5476234634503535270">"Aku säästmiseks lülitu mobiililevita kohtades lennurežiimile"</string>
    <string name="battery_desc_flashlight" msgid="6694895513133361404">"Taskulambi kasutatud akutoide"</string>
    <string name="battery_desc_camera" msgid="6152712271731518018">"Kaamera akukasutus"</string>
    <string name="battery_desc_display" msgid="7175017688954602685">"Ekraani ja taustvalguse akukasutus"</string>
    <string name="battery_sugg_display" msgid="3102137296547788111">"Vähenda ekraani heledust ja/või ekraani ajalõppu"</string>
    <string name="battery_desc_wifi" msgid="5276669172548928768">"WiFi kasutatav aku"</string>
    <string name="battery_sugg_wifi" msgid="359757575108350109">"Lülitage WiFi välja, kui te seda ei kasuta või see pole saadaval"</string>
    <string name="battery_desc_bluetooth" msgid="2237947137783306282">"Bluetoothi akukasutus"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="8943564578546832037">"Kui te Bluetoothi ei kasuta, lülitage see välja"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="6495519793211758353">"Proovige ühendus luua teise Bluetoothi seadmega"</string>
    <string name="battery_desc_apps" msgid="4187483940383266017">"Rakenduse akukasutus"</string>
    <string name="battery_sugg_apps_info" msgid="4796917242296658454">"Peatage või desinstallige rakendus"</string>
    <string name="battery_sugg_apps_gps" msgid="7221335088647925110">"Valige akut säästev režiim"</string>
    <string name="battery_sugg_apps_settings" msgid="6527223370162382166">"Rakendus võib pakkuda akukasutust vähendavaid seadeid"</string>
    <string name="battery_desc_users" msgid="1959428568888686847">"Kasutaja akukasutus"</string>
    <string name="battery_desc_unaccounted" msgid="1649497860893660763">"Muu energiatarbimine"</string>
    <string name="battery_msg_unaccounted" msgid="5647345548624995064">"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="5982079150027267539">"Liigselt arvestatud energiatarbimine"</string>
    <string name="mah" msgid="3604527474433227780">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="6401552215008504483">"Kasutatud <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="4416277218863232476">"Aktiivne <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Ekraanikasutus: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="APP">%2$s</xliff:g> kasutab <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> kogu akumahust"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Üksikasjalik teave alates viimasest täislaadimisest"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Viimane täislaadimine"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Täislaaditud seade kestab umbes"</string>
    <string name="battery_footer_summary" msgid="8221691063048377342">"Aku kasutuse andmed on ligikaudsed ja võivad sõltuvalt kasutusest muutuda."</string>
    <string name="battery_detail_foreground" msgid="3312280147931093967">"Aktiivselt kasutatud"</string>
    <string name="battery_detail_background" msgid="3333915023706228000">"Taustal"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Akukasutus"</string>
    <string name="battery_detail_info_title" msgid="5896661833554333683">"Alates viimasest täislaadimisest"</string>
    <string name="battery_detail_manage_title" msgid="7910805419446927887">"Akukasutuse haldamine"</string>
    <string name="battery_total_and_bg_usage" msgid="8266478675516886819">"Kokku <xliff:g id="TIME_0">^1</xliff:g> • <xliff:g id="TIME_1">^2</xliff:g> taustal\nalates viimasest täislaadimisest"</string>
    <string name="battery_total_and_bg_usage_24hr" msgid="2393832614028187281">"Kokku <xliff:g id="TIME_0">^1</xliff:g> • <xliff:g id="TIME_1">^2</xliff:g> taustal\nviimase 24 tunni jooksul"</string>
    <string name="battery_total_and_bg_usage_with_period" msgid="2809037516933951047">"Kokku <xliff:g id="TIME_0">^1</xliff:g> • Ajavahemikus <xliff:g id="TIME_PERIOD">^3</xliff:g>\ntaustal <xliff:g id="TIME_1">^2</xliff:g>"</string>
    <string name="battery_total_usage_less_minute" msgid="7614894994853812076">"Alates viimasest täislaadimisest kokku vähem kui minut"</string>
    <string name="battery_total_usage_less_minute_24hr" msgid="699268449496083696">"Viimase 24 tunni jooksul kokku vähem kui minut"</string>
    <string name="battery_total_usage_less_minute_with_period" msgid="571923652373556609">"Ajavahemikus <xliff:g id="TIME_PERIOD">^1</xliff:g> kokku vähem kui minut"</string>
    <string name="battery_bg_usage_less_minute" msgid="3919299699317615641">"Alates viimasest täislaadimisest taustal vähem kui minut"</string>
    <string name="battery_bg_usage_less_minute_24hr" msgid="5016983623297552985">"Viimase 24 tunni jooksul taustal vähem kui minut"</string>
    <string name="battery_bg_usage_less_minute_with_period" msgid="7624741677867017430">"Ajavahemikus <xliff:g id="TIME_PERIOD">^1</xliff:g> taustal vähem kui minut"</string>
    <string name="battery_total_usage" msgid="4685408616230899847">"Alates viimasest täislaadimisest kokku <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_total_usage_24hr" msgid="3907495067623665787">"Viimase 24 tunni jooksul kokku <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_total_usage_with_period" msgid="2849061229625950626">"Ajavahemikus <xliff:g id="TIME_PERIOD">^2</xliff:g> kokku <xliff:g id="TIME_0">^1</xliff:g>"</string>
    <string name="battery_bg_usage" msgid="548670902301883980">"<xliff:g id="TIME">^1</xliff:g> taustal alates viimasest täislaadimisest"</string>
    <string name="battery_bg_usage_24hr" msgid="1999734910656674710">"<xliff:g id="TIME">^1</xliff:g> taustal viimase 24 tunni jooksul"</string>
    <string name="battery_bg_usage_with_period" msgid="992952174445045711">"Ajavahemikus <xliff:g id="TIME_PERIOD">^2</xliff:g> taustal <xliff:g id="TIME_0">^1</xliff:g>"</string>
    <string name="battery_total_usage_and_bg_less_minute_usage" msgid="1460882261983325026">"Kokku <xliff:g id="TIME">^1</xliff:g> • Taustal vähem kui minut\nalates viimasest täislaadimisest"</string>
    <string name="battery_total_usage_and_bg_less_minute_usage_24hr" msgid="1721830675789709748">"Kokku <xliff:g id="TIME">^1</xliff:g> • Viimase 24 tunni jooksul taustal\nvähem kui minut"</string>
    <string name="battery_total_usage_and_bg_less_minute_usage_with_period" msgid="5943281928474598517">"Kokku <xliff:g id="TIME_0">^1</xliff:g> • Ajavahemikus <xliff:g id="TIME_PERIOD">^2</xliff:g>\ntaustal vähem kui minut"</string>
    <string name="battery_not_usage" msgid="1472275761547230196">"Pole alates viimasest täislaadimisest kasutatud"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Pole viimase 24 tunni jooksul kasutatud"</string>
    <string name="advanced_battery_graph_subtext" msgid="6816737986172678550">"Aku järelejäänud tööaja prognoos põhineb seadme kasutusel"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Hinnanguline järelejäänud aeg"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Täislaadimiseni"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Prognoos võib olenevalt kasutusest muutuda"</string>
    <string name="menu_stats_unplugged" msgid="7125297366200634285">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> alates lahutamisest"</string>
    <string name="menu_stats_last_unplugged" msgid="230678127178268655">"Alates viimasest lahutamisest <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="2713445396954503670">"Kasutus kokku"</string>
    <string name="menu_stats_refresh" msgid="6727628139586938835">"Värskenda"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Meediumiserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Rakenduse optimeerimine"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Akusäästja"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Lülita automaatselt sisse"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Ajakava puudub"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Põhineb teie rutiinil"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Lülitub sisse teie rutiini põhjal"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Põhineb protsendil"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Akusäästja lülitub sisse, kui teie aku saab enne tavapärast laadimisaega tõenäoliselt tühjaks"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Lülitub sisse <xliff:g id="PERCENT">%1$s</xliff:g> juures"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Ajakava määramine"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Aku tööea pikendamine"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Lülita välja, kui aku on täis laetud"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="492221102651829607">"Akusäästja lülitub välja, kui telefoni laetuse tase ületab <xliff:g id="NUMBER">^1</xliff:g><xliff:g id="UNIT">%</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="4566426833434375284">"Akusäästja lülitub välja, kui tahvelarvuti laetuse tase ületab <xliff:g id="NUMBER">^1</xliff:g><xliff:g id="UNIT">%</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="4128841327359445726">"Akusäästja lülitub välja, kui seadme laetuse tase ületab <xliff:g id="NUMBER">^1</xliff:g><xliff:g id="UNIT">%</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Lülita sisse"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Kasuta akusäästjat"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Automaatne sisselülitamine"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Mitte kunagi"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"aku taseme <xliff:g id="PERCENT">%1$s</xliff:g> juures"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Aku laetuse protsent"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Olekuribal kuvatakse aku laetuse protsent"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Akutase viimase 24 h jooksul"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Rakenduste kasutus viimase 24 h jooksul"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Süsteemi kasutus viimase 24 h jooksul"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Süsteemi kasutus: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Rakenduse kasutus: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_time_am" msgid="7783773965475697655">"am"</string>
    <string name="battery_usage_time_pm" msgid="1534468528902328570">"pm"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Kokku: vähem kui minut"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Taustal: vähem kui minut"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Kokku: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Taustal: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer" msgid="7899907241146636817">"Akukasutuse andmed on ligikaudsed ja kasutamist ei mõõdeta telefoni laadimise ajal"</string>
    <string name="battery_usage_screen_footer_empty" msgid="115806339713068930">"Akukasutuse andmed tulevad saadavale siis, kui olete telefoni mõni tund kasutanud"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Akukasutuse diagramm"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Protsessi statistika"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Tehnilised üksikasjad protsesside käitamise kohta"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Mälu kasutamine"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Viimase <xliff:g id="TIMEDURATION">%3$s</xliff:g> jooksul on kasutatud <xliff:g id="USEDRAM">%1$s</xliff:g> <xliff:g id="TOTALRAM">%2$s</xliff:g>-st"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="TIMEDURATION">%2$s</xliff:g> jooksul kasutati <xliff:g id="PERCENT">%1$s</xliff:g> RAM-i"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Taust"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Esiplaan"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Vahemälus"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Omaprotsessid"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Tuum"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Vahemälud"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM-i kasutus"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM-i kasutus (taustal)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Tööaeg"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Protsessid"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Teenused"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Kestus"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Mälu üksikasjad"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 tundi"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 tundi"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 tundi"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 päev"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Kuva süsteem"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Peida süsteem"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Kuva protsendid"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"USS-i kasutamine"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistika tüüp"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Taust"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Esiplaan"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Vahemälus"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Kõnesisend ja -väljund"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Kõnesisendi ja -väljundi seaded"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Häälotsing"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Androidi klaviatuur"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Häälsisendi seaded"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Häälsisend"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Häälsisendi teenused"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Täielik otsetee sõna ja interaktsioon"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Lihtne kõnesüntees"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"See häälsisendi teenus suudab pakkuda alati sisse lülitatud hääle jälgimisteenust ja juhtida teie nimel rakendusi, kus on lubatud häälefunktsioon. See pärineb rakendusest <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Kas lubada teenuse kasutamine?"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Eelistatud kõnesünteesi mootor"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Kõnesünteesi mootori seaded"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Kõne kiirus ja helikõrgus"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Kõnesünteesi mootor"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Hääled"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Hääle keel"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Häälte installimine"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Häälte installimiseks avage rakendus <xliff:g id="TTS_APP_NAME">%s</xliff:g>"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Ava rakendus"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Tühista"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Lähtesta"</string>
    <string name="tts_play" msgid="2945513377250757221">"Esita"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Pole turvaline"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> pole turvaline"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> pole turvaline"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Kohanduv ühenduvus"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Pikendab aku tööiga ja täiustab seadme toimivust, hallates automaatselt teie võrguühendusi"</string>
    <!-- no translation found for adaptive_connectivity_switch_on (3653067561620745493) -->
    <skip />
    <!-- no translation found for adaptive_connectivity_switch_off (5076172560836115265) -->
    <skip />
    <string name="credentials_title" msgid="7535942196886123656">"Mandaatide salvestusruum"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Sertifikaadi installimine"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="6644116499934553975">"Sertifikaatide installimine salvestusseadmelt"</string>
    <string name="credentials_install_summary" product="default" msgid="8161351950524166012">"Sertifikaatide installimine SD-kaardilt"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Mandaatide kustutamine"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Kõikide sertifikaatide eemaldamine"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Usaldusväärsed mandaadid"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Usaldusväärsete CA-sertifikaatide kuvamine"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Kasutaja mandaadid"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Salvestatud mandaatide vaatamine ja muutmine"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Täpsemad"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Mandaadid pole selle kasutaja jaoks saadaval"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Installitud VPN-i ja rakenduste jaoks"</string>
    <string name="credential_for_wifi" msgid="1963335263280604998">"Installitud WiFi jaoks"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Kas eemaldada kogu sisu?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Mandaatide mälu kustutatakse."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Mand. mälu ei saanud kustut."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Kasutusjuurdepääsuga rakend."</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA-sertifikaat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN ja rak. kasutaja sertifikaat"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"WiFi-sertifikaat"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Teie andmed ei ole privaatsed"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA-sertifikaate kasutavad krüpteerimiseks veebisaidid, rakendused ja VPN-id. Installige CA-sertifikaate ainult usaldusväärsetelt ettevõtetelt. \n\nKui installite CA-sertifikaadi, pääseb sertifikaadi omanik teie külastatud veebisaitidel või kasutatud rakendustes teie andmetele (nt paroolidele, sõnumitele või krediitkaardi üksikasjadele) juurde isegi siis, kui teie andmed on krüpteeritud."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Ära installi"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Installi ikkagi"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Sertifikaat on installimata"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Kas lubada rakendusel "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" sellesse seadmesse sertifikaate installida?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Need sertifikaadid aitavad teid tuvastada, jagades teie seadme kordumatut ID-d allolevate rakenduste ja URL-idega"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Ära luba"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Luba"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Kuva rohkem"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Sertifikaadihalduse rakendus"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Pole"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Sertifikaadid aitavad teid tuvastada, kui kasutate allolevaid rakendusi ja URL-e"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Desinstalli sertifikaadid"</string>
    <!-- no translation found for remove_credential_management_app (6089291496976812786) -->
    <skip />
    <!-- no translation found for remove_credential_management_app_dialog_title (5713525435104706772) -->
    <skip />
    <!-- no translation found for remove_credential_management_app_dialog_message (7739474298063646935) -->
    <skip />
    <plurals name="number_of_urls" formatted="false" msgid="403979258551655023">
      <item quantity="other"><xliff:g id="NUMBER_1">%d</xliff:g> URL-i</item>
      <item quantity="one"><xliff:g id="NUMBER_0">%d</xliff:g> URL</item>
    </plurals>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Hädaabikõne signaal"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Määra käitumine hädaabikõne korral"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Varundamine"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Sees"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Väljas"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Varundamine ja taastamine"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Isikuandmed"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Minu andmete varundamine"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Varundage rakenduse andmed, WiFi-paroolid ja muud seaded Google\'i serverites"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Varunduskonto"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Varundamiskonto haldamine"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Kaasa rakenduse andmed"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automaatne taastamine"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Rakenduse uuesti installimisel taasta varundatud seaded ja andmed"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Varundusteenus ei ole aktiivne"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Ühelegi kontole ei ole praegu salvestatud varundatud andmeid"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Kas soovite WiFi-paroolide, järjehoidjate, muude seadete ja rakenduse andmete varundamise lõpetada ja kõik Google\'i serverites olevad koopiad kustutada?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Kas soovite peatada seadme andmete (nt WiFi-paroolid ja kõneajalugu) ning rakenduse andmete (nt seaded ja rakenduste salvestatud failid) varundamise ning kustutada kõik kaugserverites olevad koopiad?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Varundage seadme andmed (nt WiFi-paroolid ja kõneajalugu) ning rakenduse andmed (nt seaded ja rakenduste salvestatud failid) kaugjuhtimisega automaatselt.\n\nKui lülitate automaatse varundamise sisse, salvestatakse seadme ja rakenduse andmed regulaarselt kaugjuhtimisega. Rakenduse andmed võivad olla mis tahes andmed, mille rakendus on salvestanud (arendaja seadete põhjal), sh potentsiaalselt tundlikud andmed, nagu kontaktid, sõnumid ja fotod."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Seadme administraatori seaded"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Seadme administraatori rakendus"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Inaktiveeri seadme administraatori rakendus"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Desinstalli rakendus"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Inaktiveeri ja desinstalli"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Seadme admin. rakendused"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Saadaval ei ole ühtki seadme administraatori rakendust"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Saadaval pole ühtegi usaldusväärset agenti"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Kas aktiveerida admin. rakendus?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Seadme administraatori rakenduse aktiveerimine"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Seadme administraator"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Selle administraatori rakenduse aktiveerimisel lubatakse rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid."</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Seda seadet haldab ja jälgib rakendus <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"See administraatori rakendus on aktiivne ja lubab rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> teha järgmisi toiminguid."</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Kas aktiveerida profiilihaldur?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Kas lubada järelevalve?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Kui jätkate, haldab teie kasutajat edaspidi administraator, kes saab võib-olla talletada peale teie isiklike andmete ka seotud andmeid.\n\nTeie administraator saab jälgida ja hallata selle kasutajaga seotud seadeid, juurdepääsu, rakendusi ja andmeid, sealhulgas veebitegevusi ja seadme asukohateavet."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Administraator on muud valikud keelanud."</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Lisateave"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Märguannete logi"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Märguannete ajalugu"</string>
    <string name="notification_history_today" msgid="5828496957208237230">"Viimased 24 tundi"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Edasi lükatud"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Hiljuti loobutud"</string>
    <plurals name="notification_history_count" formatted="false" msgid="1859304685071321991">
      <item quantity="other"><xliff:g id="NUMBER_1">%d</xliff:g> märguannet</item>
      <item quantity="one"><xliff:g id="NUMBER_0">%d</xliff:g> märguanne</item>
    </plurals>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Kõne helin ja vibreerimine"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Võrgu üksikasjad"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sünkroonimine lubatud"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sünkroonimine keelatud"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Kohe sünkroonimine"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Sünkroonimise viga"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sünkroonimine ebaõnnestus"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sünkroonimine on aktiivne"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sünkroonimine"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Sünkroonimisega on praegu probleeme. See on varsti tagasi."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Lisa konto"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Tööprofiil ei ole veel saadaval"</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Tööprofiil"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Haldab teie organisatsioon"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Rakendused ja märguanded on välja lülitatud"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Eemalda tööprofiil"</string>
    <string name="background_data" msgid="321903213000101158">"Andmeside kasutus taustal"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Rakendused saavad andmeid sünkroonida, saata ja vastu võtta"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Keel. taustaandmed?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Taustaandmete keelamine pikendab aku kestvust ja vähendab andmekasutust. Mõned rakendused võivad siiski andmesideühendusi taustal kasutada."</string>
    <string name="sync_automatically" msgid="4874122892765430304">"Rakenduse andmete automaatne sünkr."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sünkroonim. on SEES"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sünkroonimine VÄLJAS"</string>
    <string name="sync_error" msgid="846923369794727644">"Sünkroonimise viga"</string>
    <string name="last_synced" msgid="1527008461298110443">"Viimati sünkroonitud: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sünkroonimine ..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Varunda seaded"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Minu seadete varundamine"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sünkrooni kohe"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Loobu sünkroonimisest"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Puudutage kohe sünkroonimiseks<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Kalender"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontaktid"</string>
    <string name="sync_plug" msgid="7956982719077985381"><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="7427706834875419243">"Rakenduse sünkroonimisseaded"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Andmed ja sünkroonimine"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Parooli muutmine"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Konto seaded"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Eemalda konto"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Konto lisamine"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Kas eemaldada konto?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="8893801622174947887">"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="1217810840427479274">"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="5241756807386611084">"Selle konto eemaldamisel kustutatakse kõik seal olevad sõnumid, kontaktid ja muud seadmes olevad andmed."</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Administraator on selle muudatuse keelanud"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Ei saa käsitsi sünkroonida"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Selle üksuse sünkroonimine on praegu keelatud. Seade muutmiseks lülitage ajutiselt sisse taustaandmed ja automaatne sünkroonimine."</string>
    <string name="enter_password" msgid="6327051330258595331">"Androidi käivitamiseks sisestage parool"</string>
    <string name="enter_pin" msgid="1029287617551232681">"Androidi käivitamiseks sisestage oma PIN-kood"</string>
    <string name="enter_pattern" msgid="1747316785866742960">"Androidi käivitamiseks joonistage muster"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="340747269176120242">"Vale muster"</string>
    <string name="cryptkeeper_wrong_password" msgid="7295607881887114486">"Vale parool"</string>
    <string name="cryptkeeper_wrong_pin" msgid="2347961593970714201">"Vale PIN-kood"</string>
    <string name="checking_decryption" msgid="6111642972615688237">"Kontrollimine ..."</string>
    <string name="starting_android" msgid="6694154070215356186">"Androidi käivitamine ..."</string>
    <string name="delete" msgid="8330605554706263775">"Kustuta"</string>
    <string name="misc_files" msgid="6598066985800749585">"Mitmesugused failid"</string>
    <string name="misc_files_selected_count" msgid="5597802791672749532">"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="7622766714974500289">"<xliff:g id="NUMBER">%1$s</xliff:g>/<xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="7898929601615536401">"Vali kõik"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Andmeside kasutus"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobiilne andmeside, WiFi"</string>
    <string name="data_usage_accounting" msgid="6832015632699116754">"Operaatori andmemahuarvestus võib erineda seadme omast"</string>
    <string name="data_usage_app" msgid="6367974637783240699">"Rakenduse kasutamine"</string>
    <string name="data_usage_app_info_label" msgid="3542220416056122841">"RAKENDUSE TEAVE"</string>
    <string name="data_usage_cellular_data" msgid="1917226172511825849">"Mobiilne andmeside"</string>
    <string name="data_usage_data_limit" msgid="1120291692444009289">"Andmemahupiirangu määramine"</string>
    <string name="data_usage_cycle" msgid="6875568429140150029">"Andmete kasutamistsükkel"</string>
    <string name="data_usage_app_items_header_text" msgid="7513812163443595033">"Rakenduse kasutamine"</string>
    <string name="data_usage_menu_roaming" msgid="6864561338842056939">"Andmesiderändlus"</string>
    <string name="data_usage_menu_restrict_background" msgid="1414574366645086133">"Piira taustaandmeid"</string>
    <string name="data_usage_menu_allow_background" msgid="6242931073390680432">"Taustaandmete lubamine"</string>
    <string name="data_usage_menu_split_4g" msgid="3391899816926640583">"Eraldi 4G kasutamine"</string>
    <string name="data_usage_menu_show_wifi" msgid="6380926350184939975">"Kuva WiFi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="4694889089278302691">"WiFi peitmine"</string>
    <string name="data_usage_menu_show_ethernet" msgid="4401026240876938859">"Kuva Etherneti-kasutus"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="7792365022467586772">"Etherneti kasut. peitmine"</string>
    <string name="data_usage_menu_metered" msgid="4279260736172851951">"Võrgupiirangud"</string>
    <string name="data_usage_menu_auto_sync" msgid="2632694000068175025">"Andmete automaatne sünkroonimine"</string>
    <string name="data_usage_menu_sim_cards" msgid="8966135605336735887">"SIM-kaardid"</string>
    <string name="data_usage_cellular_data_summary" msgid="8139993171126153316">"Peatatud limiidi juures"</string>
    <string name="account_settings_menu_auto_sync" msgid="1660484779001900562">"Andmete autom. sünkroonimine"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Isiklike andmete autom. sünk."</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Tööandmete autom. sünkroon."</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Tsükli muutmine ..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Kuupäev andmekasutustsükli lähtestamiseks:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Sel perioodil ei kasut. andmeid ükski rakendus."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Esiplaanil"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Taustal"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"piiratud"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Kas lülitada mobiilne andmeside välja?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Seadke mobiilandmeside piirang"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Määrake 4G andmemahupiirang"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Määrake 2G-3G andmemahupiirang"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Määra WiFi andmepiirang"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"WiFi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobiil"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G–3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobiilne"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Mitte ükski"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobiilne andmeside"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G–3G-andmeside"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G-andmeside"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Rändlusteenus"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Esiplaanil:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Taustal:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Rakenduse seaded"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Andmeside kasutus taustal"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Luba mobiilse andmeside kasutus taustal"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Rakend. taustandm. piiramiseks määrake mob. andmeside piirang."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Kas soovite taustandmeid piirata?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Funktsiooni tõttu võivad taustaandmetel põhinev rakendus töötamast lakata, kui saadaval on ainult mobiilsidevõrgud.\n\nAndmekasutuse täpsemad juhtelemendid leiate rakenduse seadetest."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Taustandmete piiramine on võimalik vaid juhul, kui olete määranud mobiilse andmeside piirangu."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Kas lülitan andmete automaatse sünkroonimise sisse?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="6387714350903085918">"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="6457107552266187107">"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="1783917145440587470">"Kas lülitan andmete automaatse sünkroonimise välja?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"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="2019035830921480941">"Kasutustsükli lähtestuskuupäev"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Igakuine kuupäev:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Määra"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Andmekasutuse hoiatuse määramine"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Andmekasutuse piirangu määramine"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Andmekasutuse piiramine"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="6000062970083379466">"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="4942895670789168024">"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="2745551538820692821">"Kas soovite taustandmeid piirata?"</string>
    <string name="data_usage_restrict_background" msgid="1893102079135282794">"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="5588623586867665419">"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="6402714504088590463">"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="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"hoiatus"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"piir"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Eemaldatud rakendused"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Eemaldatud rakendused ja kasutajad"</string>
    <string name="data_usage_received_sent" msgid="1486740779864806124">"<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="2695893609573024612">"<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="45300375132284265">"<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="3183594094081558193">"<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="6421347352444253058">"Võrgupiirangud"</string>
    <string name="data_usage_metered_body" msgid="1206840367501998582">"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="3514227339274396401">"Mobiilsidevõrgud"</string>
    <string name="data_usage_metered_wifi" msgid="4807465959110473407">"Mahupõhised WiFi-võrgud"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="4664158157415362613">"Mahupõhiste võrkude valimiseks lülitage WiFi sisse."</string>
    <string name="data_usage_metered_auto" msgid="1560514082131687116">"Automaatne"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Võrgukasutus"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Mahupõhine"</string>
    <string name="data_usage_metered_no" msgid="1685828958417926268">"Pole mahupõhine"</string>
    <string name="data_usage_disclaimer" msgid="3271450299386176770">"Operaatori andmemahuarvestus võib erineda seadme omast"</string>
    <string name="cryptkeeper_emergency_call" msgid="8369322820475703306">"Hädaabikõne"</string>
    <string name="cryptkeeper_return_to_call" msgid="3857250752781151232">"Tagasi kõne juurde"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nimi"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tüüp"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Serveri aadress"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP krüpteerimine (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"L2TP saladus"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSeci tunnus"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"IPSeci eeljagatud võti"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSeci kasutaja sertifikaat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSeci CA-sertifikaat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Serveri IPSeci sertifikaat"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Kuva täpsemad valikud"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"DNS-i otsingudomeenid"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"DNS-serverid (nt 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Edastamismarsruudid (nt 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Kasutajanimi"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Parool"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Salvesta kontoteave"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ei kasutata)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ära kinnita serverit)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(serverist saadud)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Seda tüüpi VPN ei saa olla alati ühendatud"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Alati sisselülitatud VPN toetab ainult numbritest koosnevaid serveriaadresse"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Alati sisselülitatud VPN-i puhul peab olema määratud DNS-server"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Alati sisselülitatud VPN-i puhul peab DNS-serveri aadress koosnema numbritest"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Sisestatud teave ei toeta alati sisselülitatud VPN-i"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Tühista"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Loobu"</string>
    <string name="vpn_save" msgid="683868204634860888">"Salvesta"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Ühenda"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Asenda"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"VPN-profiili muutmine"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Unusta"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Profiiliga <xliff:g id="PROFILE">%s</xliff:g> ühendamine"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Kas soovite katkestada ühenduse selle VPN-iga?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Katkesta ühendus"</string>
    <string name="vpn_version" msgid="41856553718304367">"Versioon <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Unusta VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Kas asendada olemasolev VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Kas määrata alati sisselülitatud VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Kui see seade on sisse lülitatud, pole teil Interneti-ühendust, kuni VPN-iga ühenduse loomine õnnestub"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Teie olemasolev VPN asendatakse ja teil pole Interneti-ühendust, kuni VPN-iga ühenduse loomine õnnestub"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Teil juba on ühendus alati sisselülitatud VPN-iga. Kui jätkate mõne teisega, asendatakse teie olemasolev VPN ja alati sisselülitatud režiim lülitatakse välja."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Teil juba on ühendus VPN-iga. Kui jätkate mõne teisega, asendatakse teie olemasolev VPN."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Lülita sisse"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> ei saa ühendust luua"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"See rakendus ei toeta alati sisselülitatud VPN-i"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"VPN-profiili lisamine"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Muuda profiili"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Kustuta profiil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Alati sees VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Ühtegi VPN-i pole lisatud"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Säilita alati ühendus VPN-iga"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Rakendus ei toeta seda"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Alati sees"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Pole turvaline"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"VPN-ita ühenduste blokeerimine"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Kas vajate VPN-i ühendust?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Pole turvaline. Värskendage versioonile IKEv2 VPN."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Valige VPN-i profiil, millega olla alati ühendatud. Võrguliiklus on lubatud ainult siis, kui olete ühendatud selle VPN-iga."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Puudub"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Alati sees VPN-i jaoks on vaja IP-aadressi nii serverile kui ka DNS-ile."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Võrguühendus puudub. Proovige hiljem uuesti."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Ühendus VPN-iga katkestati"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Puudub"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Sertifikaat puudub. Proovige profiili muuta."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Süsteem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Kasutaja"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Keela"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Luba"</string>
    <!-- no translation found for trusted_credentials_remove_label (8296330919329489422) -->
    <skip />
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Usalda"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Kas lubada süsteemi CA-sertifikaat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Kas keelata süsteemi CA-sertifikaat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Kas eemaldada kasutaja CA-sertifikaat jäädavalt?"</string>
    <string name="credential_contains" msgid="407972262032275476">"See kirje sisaldab:"</string>
    <string name="one_userkey" msgid="4417212932385103517">"üks kasutajavõti"</string>
    <string name="one_usercrt" msgid="1865069301105101370">"üks kasutaja sertifikaat"</string>
    <string name="one_cacrt" msgid="7467796501404158399">"üks CA-sertifikaat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA-sertifikaati"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Mandaadi üksikasjad"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Mandaat eemaldati: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Ühtegi kasutaja mandaati ei ole installitud"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Õigekirjakontroll"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Õigekirjakontroll töö jaoks"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Sisestage oma täieliku varunduse praegune parool siia"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Sisestage täielike varunduste uus parool siia"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Sisestage siia uuesti oma täieliku varunduse uus parool"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Määra varundusparool"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Tühista"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Süsteemi lisavärskendused"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Võrku võidakse jälgida"</string>
    <string name="done_button" msgid="6269449526248267">"Valmis"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="5491460811755938449">
      <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="2788832560436163252">
      <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="3989916958347169622">
      <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="4374052724815563051">"Kolmas osapool saab jälgida teie tegevust võrgus, sh meile, rakendusi ja turvalisi veebisaite.\n\nSeda võimaldab teie seadmesse installitud usaldusväärne mandaat."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="125941406175485894">
      <item quantity="other">Kontrollige sertifikaate</item>
      <item quantity="one">Kontrollige sertifikaati</item>
    </plurals>
    <string name="user_settings_title" msgid="6550866465409807877">"Mitu kasutajat"</string>
    <string name="user_settings_footer_text" product="device" msgid="7523914344521302179">"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="3730074318510244552">"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="4420915712050349125">"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="1387379079186123404">"Kasutajad ja profiilid"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Lisa kasutaja või profiil"</string>
    <string name="user_add_user_menu" msgid="6395904234221724625">"Kasutaja lisamine"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Piiratud profiil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Pole seadistatud"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Pole seadistatud – piiratud profiil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Seadistamata – tööprofiil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administraator"</string>
    <string name="user_you" msgid="3070562015202859996">"Teie (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="5739771048517070983">"Saate lisada kuni <xliff:g id="USER_COUNT">%1$d</xliff:g> kasutajat"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="3405022988077682357">"Ainult tahvelarvuti omanik saab hallata kasutajaid."</string>
    <string name="user_cannot_manage_message" product="default" msgid="6434662649769855494">"Ainult telefoni omanik saab hallata kasutajaid."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Piiratud profiilid ei saa kontosid lisada"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Kustuta seadmest <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Lukustuskuva seaded"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Kasutajate lisamine lukustuskuval"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Kas soovite kustutada iseenda?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Kas kustutada kasutaja?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Kas eemaldada profiil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Kas eemaldada tööprofiil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="439222554798995592">"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="5991495192044543230">"Kaotate selles telefonis olevad ruumi ja andmed. Seda toimingut ei saa tagasi võtta."</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Kõik rakendused ja andmed kustutatakse."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Kui jätkate, kustutatakse kõik selle profiili rakendused ja andmed."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Kõik rakendused ja andmed kustutatakse."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Uue kasutaja lisamine ..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Kasutaja kustutamine"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Kustuta"</string>
    <string name="user_guest" msgid="4545590092001460388">"Külaline"</string>
    <string name="user_exit_guest_title" msgid="2653103120908427236">"Eemalda külaline"</string>
    <string name="user_exit_guest_confirm_title" msgid="1284823459630164754">"Kas eemaldada külaline?"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Seansi kõik rakendused ja andmed kustutatakse."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Eemalda"</string>
    <string name="user_enable_calling" msgid="264875360626905535">"Lülita telefonikõned sisse"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Lülita telefonikõned ja SMS-id sisse"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Kustuta kasutaja"</string>
    <string name="user_enable_calling_confirm_title" msgid="7868894792723368364">"Kas lülitada telefonikõned sisse?"</string>
    <string name="user_enable_calling_confirm_message" msgid="4924965198409050155">"Selle kasutajaga jagatakse kõneajalugu."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Kas lülitada telefonikõned ja SMS-id sisse?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Selle kasutajaga jagatakse kõne- ja SMS-ajalugu."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Hädaabiteave"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Kasutaja <xliff:g id="USER_NAME">%1$s</xliff:g> teave ja kontaktid"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Ava <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="more_settings_button" msgid="8988612279031242411">"Rohkem seadeid"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Rakenduste ja sisu lubamine"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Piirangutega rakendused"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Laienda rakenduste seadeid"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Kontaktivabad maksed"</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Kuidas see toimib?"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Makske poes oma telefoniga"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Vaikemakseviis"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Määramata"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="788899906312142803">"Kasuta vaikerakendust"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Alati"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"V.a siis, kui mõni teine makserakendus on avatud"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Kontaktivabas terminalis maksate rakendusega:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Terminali kaudu maksmine"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Seadistage makserakendus. Seejärel peate oma telefoni tagakülge hoidma lihtsalt mis tahes terminali lähedal, millel on kontaktivaba makse sümbol."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Selge"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Rohkem …"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Määrake vaikemakserakenduseks"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Värskendage vaikemakserakendust"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Kontaktivabas terminalis maksate rakendusega <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Kontaktivabas terminalis maksate rakendusega <xliff:g id="APP_0">%1$s</xliff:g>.\n\nSee määrab uueks vaikemakserakenduseks rakenduse <xliff:g id="APP_1">%2$s</xliff:g>."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Määra vaikeseadeks"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Värskenda"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Piirangud"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Eemalda piirangud"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Muuda PIN-koodi"</string>
    <string name="help_label" msgid="2896538416436125883">"Abi ja tagasiside"</string>
    <string name="support_summary" msgid="6137136608018134563">"Abiartiklid, telefon ja vestlus"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Sisu konto"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Foto ID"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Väga ohtlikud olukorrad"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Häirete vastuvõtmine, kui ilmneb väga tõsine oht elule ja varale"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ohtlikud olukorrad"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Häirete vastuvõtmine, kui ilmneb tõsine oht elule ja varale"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Lasteröövi märguanded"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Teadaannete vastuvõtmine lasteröövide kohta"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Kordamine"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Kõnehalduri lubamine"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Lubage sellel teenusel hallata, kuidas kõnesid tehakse."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Kõnehaldur"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Eriolukorra raadiosideteatised"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Võrguoperaatorid"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Pääsupunktide nimed"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Täiustatud helistamine"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G-helistamine"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="6776190202179584104">"Parema hääl- ja muu side kvaliteedi tagamiseks LTE-teenuste kasutamine (soovitatav)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="7814006095552641136">"Parema hääl- ja muu side kvaliteedi tagamiseks 4G-teenuste kasutamine (soovitatav)"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Kontaktide saatmine operaatorile"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Saatke oma kontaktide telefoninumbrid, et pakkuda täiustatud funktsioone"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Kas saata kontaktid operaatorile <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Kas saata kontaktid operaatorile?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Teie kontaktide telefoninumbrid saadetakse perioodiliselt operaatorile <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

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

</xliff:g>Selle teabe abil tuvastatakse, kas kontaktid saavad kasutada teatud funktsioone, nagu videokõned või mõned sõnumsidefunktsioonid."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Eelistatud võrgutüüp"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (soovitatav)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS-sõnumid"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Saatmine ja vastuvõtmine, kui mobiilne andmeside on väljas"</string>
    <string name="data_during_calls_title" msgid="3940276893360429144">"Kõnede ajal andmeside lubamine"</string>
    <string name="data_during_calls_summary" msgid="2289050189544214759">"Lubab kasutada seda SIM-i mobiilseks andmesideks ainult kõnede ajal"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Töökoha SIM-kaart"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Juurdepääs rakendusele ja sisule"</string>
    <string name="user_rename" msgid="8735940847878484249">"NIMETA ÜMBER"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Rakendusele piirangute määramine"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Juhib: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"See rakendus pääseb teie kontode juurde"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Sellel rakendusel on juurdepääs teie kontodele. Juhib: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"WiFi ja mobiilne andmeside"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"WiFi, mobiilside ja Bluetoothi lähtestamine"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Bluetoothi sidumiste ja seadete muutmise lubamine"</string>
    <string name="restriction_nfc_enable_title" msgid="525512312298242911">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="8065688740509581028">"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="6397567147629410131">"Andmete vahetuse lubamine, kui tahvelarvuti puudutab teist seadet"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="3331800894734678808">"Andmete vahetuse lubamine, kui telefon puudutab teist seadet"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Asukoht"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Rakendustel asukohateabe kasutamise lubamine"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Tagasi"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Järgmine"</string>
    <string name="wizard_finish" msgid="4220258401946825946">"Lõpeta"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_setup_wizard_title" msgid="3945520353564138219">"SIM-kaardid"</string>
    <string name="sim_settings_title" msgid="8392862852842113531">"SIM-kaardid"</string>
    <string name="sim_settings_summary" msgid="5777472623476930332">"<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="7726897488921853655">"SIM-kaardid on muutunud"</string>
    <string name="sim_cards_changed_message_summary" msgid="7338082681445213621">"Puudutage tegevuste määramiseks"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobiilne andmeside pole saadaval"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Puudutage andmeside SIM-kaardi valimiseks"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Kasuta helistamiseks alati seda"</string>
    <string name="select_sim_for_data" msgid="1577092784244587369">"Andmete SIM-kaardi valimine"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Valige SMS-i jaoks SIM-kaart"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Andmete SIM-kaardi vahetamine, selleks võib kuluda kuni üks minut …"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Helistamine SIM-kaardiga"</string>
    <string name="sim_select_card" msgid="1226182454109919045">"SIM-kaardi valimine"</string>
    <string name="sim_card_number_title" msgid="4728780444646439845">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_editor_name" msgid="5900178038499314621">"SIM-kaardi nimi"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Sisestage SIM-kaardi nimi"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM-kaardi pesa %1$d"</string>
    <string name="sim_editor_carrier" msgid="2424593350691002557">"Operaator"</string>
    <string name="sim_editor_number" msgid="3209002966895156006">"Number"</string>
    <string name="sim_editor_color" msgid="9067029630083892961">"SIM-kaardi värv"</string>
    <string name="sim_card_select_title" msgid="8146523005929848793">"SIM-kaardi valimine"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranž"</string>
    <string name="color_purple" msgid="6603701972079904843">"Lilla"</string>
    <string name="sim_no_inserted_msg" msgid="7272710974813741735">"Ühtegi SIM-kaarti pole sisestatud"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"SIM-i olek"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"SIM-kaardi olek (SIM-kaardi pesa %1$d)"</string>
    <string name="sim_call_back_title" msgid="4274099761123657464">"Tagasihelistamine vaike-SIM-kaardilt"</string>
    <string name="sim_outgoing_call_title" msgid="7759080345748128897">"SIM-kaart väljuvate kõnede jaoks"</string>
    <string name="sim_other_call_settings" msgid="5956308869284958883">"Muud kõne seaded"</string>
    <string name="preferred_network_offload_title" msgid="6453199586512609557">"Eelist. võrgu mahalaad."</string>
    <string name="preferred_network_offload_header" msgid="4842188794016376899">"Võrgunime levitamise keelamine"</string>
    <string name="preferred_network_offload_footer" msgid="374984523082849648">"Võrgunime levitamise keelamine ei lase kolmandatel osapooltel hankida juurdepääsu teie võrguteabele."</string>
    <string name="preferred_network_offload_popup" msgid="3949937898807213370">"Võrgunime levitamise keelamine takistab automaatset ühendamist varjatud võrkudega."</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="584752983048661108">"SIM-kaardid on muutunud."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Puudutage seadistamiseks"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Küsi iga kord"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Valik on tegemata"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"SIM-kaardi valik"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Seaded"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="6585075562837786847">
      <item quantity="other">Kuva %d peidetud üksust</item>
      <item quantity="one">Kuva %d peidetud üksus</item>
    </plurals>
    <string name="network_dashboard_title" msgid="788543070557731240">"Võrk ja internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobiilne andmeside, WiFi, kuumkoht"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"WiFi, kuumkoht"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Ühendatud seadmed"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, sidumine"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, sõidurežiim, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, sõidurežiim"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, sõidurežiim, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, sõidurežiim"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Pole saadaval, kuna NFC on väljas"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Kasutamiseks installige esmalt makserakendus"</string>
    <string name="app_and_notification_dashboard_title" msgid="2861781687031832943">"Rakendused ja märguanded"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Hiljutised rakendused, vaikerakendused"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Tööprofiilil pole märguannete juurdepääs rakenduste puhul saadaval."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Paroolid ja kontod"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Salvestatud paroolid, automaattäide ja sünkroonitud kontod"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Vaikerakendused"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Keeled, liigutused, kellaaeg, varundamine"</string>
    <string name="search_results_title" msgid="3360639917793022533">"Seaded"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, võrguühendus, internet, juhtmeta, andmed, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"WiFi märguanne, wifi märguanne"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"andmekasutus"</string>
    <string name="keywords_vibrate_on_touch" msgid="8379369786860641429">"Vibreerimise peatamine, puudutus, klaviatuur"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Kasuta 24-tunni vormingut"</string>
    <string name="keywords_storage_files" msgid="4509695858659705198">"Allalaadimine"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Ava rakendusega"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Rakendused"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"ajavöönd"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Vestlusmull, süsteem, teatis, aken, dialoog, kuvamine, muude rakenduste peal, joonistamine"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Taskulamp, valgus, lamp"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, WiFi, lüliti, juhtimine"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobiilne, mobiil, mobiilioperaator, juhtmeta, andmed, 4g,3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, kõne, helistamine"</string>
    <string name="keywords_display" msgid="874738809280751745">"ekraan, puuteekraan"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"ekraani hämardamine, puuteekraan, aku, ere"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"ekraani hämardamine, öö, toon, öörežiim, eredus, ekraanikuva värv, värv"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"taust, isikupärastamine, ekraani kohandamine"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"teksti suurus"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projekt, ülekandmine, ekraani peegeldamine, ekraani jagamine, peegeldamine, kuva jagamine, ekraani ülekandmine"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"ruum, ketas, kõvaketas, seadme kasutus"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"energiakasutus, laadimine"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"akukasutuse vaatamine, akukasutus, toitekasutus"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"akusäästja, toitesäästja, säästja"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"kohanduvad eelistused, kohanduv akuhaldur"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"õigekiri, sõnastik, õigekirjakontroll, automaatne korrigeerimine"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"tuvastaja, sisend, kõne, rääkima, keel, käed vabad, vabakäe, tuvastamine, solvav, sõna, heli, ajalugu, bluetoothi peakomplekt"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"hinda, keel, vaikimisi, kõnele, kõnelemine, TTS, juurdepääsetavus, ekraanilugeja, pime"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"24-tunnine kell"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"lähtesta, taasta, tehaseseaded"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"pühkimine, kustutamine, taastamine, tühjendamine, eemaldamine, tehaseseadetele lähtestamine"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printer"</string>
    <string name="keywords_sounds" msgid="1850691834585575875">"kõlari piiks, kõlar, helitugevus, vaigistamine, vaikus, heli, muusika"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"mitte segada, katkesta, katkestus, paus"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"läheduses, asukoht, ajalugu, aruandlus, GPS"</string>
    <string name="keywords_accounts" msgid="3482052586502133909">"konto, konto lisamine, tööprofiil, lisa konto"</string>
    <string name="keywords_users" msgid="3497517660077620843">"piirang, piira, piiratud"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"tekstiparandus, paranda, heli, vibreeri, automaatne, keel, liigutus, soovita, soovitus, teema, solvav, sõna, tüüp, emotikon, rahvusvaheline"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"lähtestamine, eelistused, vaikeseade"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"rakendused, allalaadimine, rakendused, süsteem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"rakendused, load, turvalisus"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"rakendused, vaikimisi"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"optimeerimiste ignoreerimine, Doze, rakenduse ooterežiim"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"ere, RGB, SRGB, värv, loomulik, tavaline"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"värvitemperatuur, D65, D73, valge, kollane, sinine, soe, külm"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"libista avamiseks, parool, muster, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"ekraanikuva kinnitamine"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"töö väljakutse, töö, profiil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"tööprofiil, hallatud profiil, ühenda, ühendamine, töö, profiil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"liigutused"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"rahakott"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"maksa, puuduta, maksed"</string>
    <string name="keywords_backup" msgid="707735920706667685">"varukoopia, varundamine"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"liigutus"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"nägu, avamine, autentimine, sisselogimine"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"nägu, avamine, autentimine, sisselogimine, sõrmejälg, biomeetria"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl-i versioon, imei sv"</string>
    <string name="keywords_sim_status" msgid="8784456547742075508">"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="4723665865709965044">"seerianumber, riistvaraversioon"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"androidi turvapaiga tase, põhiribaversioon, tuuma versioon"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"teema, hele, tume, režiim, valgustundlikkus, fotofoobia, tumedamaks muutmine, tumendamine, tume režiim, migreen"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tume teema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"viga"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Säästlik ekraan, lukustuskuva ekraan"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"lukustuskuva märguanne, märguanded"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"nägu"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"sõrmejälg, sõrmejälje lisamine"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"nägu, sõrmejälg, sõrmejälje lisamine"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"ekraani hämardamine, puuteekraan, aku, nutikas heledus, dünaamiline heledus, automaatne heledus"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"nutikas, ekraani hämardamine, unerežiim, aku, ajalõpp, tuvastus, ekraan, ekraanikuva, tegevusetus"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kaamera, nutikas, automaatne pööramine, pöörama, vahetamine, pööramine, vertikaalpaigutus, horisontaalpaigutus, suund, vertikaalne, horisontaalne"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"versiooniuuendus, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, ajakava, märguanded, blokeerimine, vaikus, vibreerimine, unerežiim, töö, keskendumine, heli, vaigistamine, päev, tööpäev, nädalalõpp, öö nädala sees, sündmus"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"kuva, lukustusaeg, ajalõpp, lukustuskuva"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"mälu, vahemälu, andmed, kustutamine, tühjendamine, vaba, ruum"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"ühendatud, seade, kõrvaklapid, peakomplekt, kõlar, juhtmeta, sidumine, nööpkõrvaklapid, muusika, meedia"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"taust, teema, ruudustik, kohandamine, isikupärastamine"</string>
    <string name="keywords_styles" msgid="5291614313348476068">"ikoon, aktsent, värv"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"vaikimisi, assistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"makse, vaikeseade"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"sissetulev märguanne"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb jagamine, bluetoothi jagamine, wifi-pääsupunkt"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"puutepõhine, vibreerimine, kuva, tundlikkus"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"puutepõhine, vibreerimine, telefon, kõne, tundlikkus, helin"</string>
    <string name="keywords_notification_vibration" msgid="9162262178415439951">"puutepõhine, vibreerimine, tundlikkus"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"akusäästja, kinnitatav, pidev, aku säästmine, aku"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutiin, ajakava, akusäästja, toite säästmine, aku, automaatne, protsent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, täiustatud helistamine, 4g-kõned"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"lisa keel, keele lisamine"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"teksti suurus, suur tekst, suur font, halb nähtavus, teksti suuremaks muutmine, fondi suurendaja, fondi suurendamine"</string>
    <string name="default_sound" msgid="6604374495015245195">"Vaikeheli"</string>
    <string name="sound_settings_summary" msgid="944761906531715109">"Helina ja märguannete helitugevus on <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Helitugevus, vibreerimine, režiim Mitte segada"</string>
    <string name="sound_settings_summary_vibrate" msgid="7192223433295988890">"Telefonihelin on seatud vibreerima"</string>
    <string name="sound_settings_summary_silent" msgid="746662794579344761">"Telefonihelin on seatud hääletuks"</string>
    <string name="sound_settings_example_summary" msgid="8125110691864707925">"Helina ja märguannete helitugevus on 80%"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Meedia helitugevus"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Ülekantava sisu helitugevus"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Kõne helitugevus"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Äratuse helitugevus"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Helina ja märguannete helitugevus"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Märguande helitugevus"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Telefoni helin"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Märguande vaikeheli"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Rakenduse esitatud heli"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Märguande vaikeheli"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Äratuse vaikeheli"</string>
    <string name="vibrate_when_ringing_title" msgid="3436203665622843196">"Vibreerimine kõnede puhul"</string>
    <string name="keywords_vibrate_for_calls" msgid="1019870409730074899">"Vibreerimine"</string>
    <string name="vibrate_when_ringing_option_never_vibrate" msgid="6518980907289156517">"Ära kunagi vibreeri"</string>
    <string name="vibrate_when_ringing_option_always_vibrate" msgid="968652667232075466">"Vibreeri alati"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibreeri ja siis helise valjenedes"</string>
    <string name="other_sound_settings" msgid="5468360269346162072">"Muud helid"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Valimisklahvistiku toonid"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Ekraanikuva lukustamise heli"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Laadimishelid ja vibreerimine"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Dokkimise helid"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Puutehelid"</string>
    <string name="vibrate_on_touch_title" msgid="9105544449810547716">"Puudutusel vibreerimine"</string>
    <string name="vibrate_on_touch_summary" msgid="664831333409399440">"Värintagasiside puudutuse, klaviatuuri ja muu kohta"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Kõlari dokkimise heli"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Kogu heli"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Ainult meedia heli"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Vaikus"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Toonid"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibratsioonid"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Sisselülitamise helid"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Reaalajas subtiitrid"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Meediasisu automaatsed subtiitrid"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Puudub}=1{1 ajakava on määratud}other{# ajakava on määratud}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Mitte segada"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Ainult oluliste inimeste ja rakendustega seotud märguanded"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Katkestuste piiramine"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Valiku Mitte segada sisselülitamine"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Äratused ja meediahelid saavad katkestada"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Ajakavad"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Ajakavade kustutamine"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Kustuta"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Muuda"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Ajakavad"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Ajakava"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Ajastamine"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Telefoni vaigistamine teatud ajal"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Režiimi Mitte segada reeglite määramine"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Ajastamine"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Kasuta ajakava"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Helimärguandega katkestuste lubamine"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Visuaalsete häirimiste blok."</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Luba visuaalsed signaalid"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Peidetud märguannete kuvamisvalikud"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kui funktsioon Mitte segada on sisse lülitatud"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Hääletud märguanded"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Näete ekraanil märguandeid"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Teie telefon ei helise ega vibreeri märguannete saabumisel."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Te ei kuule ega näe märguandeid"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="4314772315731485747">"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="5469078057954463796">"Kohandatud"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Kohandatud seade lubamine"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Kohandatud seade eemaldamine"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Hääletud märguanded"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Osaliselt peidetud"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Kohandatud piirangud"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Kui ekraan on sees"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kui ekraan on väljas"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Vaigista heli ja vibreerimine"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Ära lülita ekraani sisse"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Ära vilguta tuld"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Ära kuva märguandeid ekraanil"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Peida ülaosas olekuriba ikoonid"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Peida märguandetäpid ikoonidel"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ära ärata märguannete puhul"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Peida allatõmmatavas menüüs"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Mitte kunagi"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kui ekraan on väljas"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kui ekraan on sees"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Heli ja vibreerimine"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Märguannete heli, vibreerimine ja mõned visuaalsed märgid"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Märguannete heli, vibreerimine ja visuaalsed märgid"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="1115914818435434668">"Märguandeid, mis on vajalikud telefoni põhitoiminguteks ja oleku kuvamiseks, ei peideta kunagi."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Puudub"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"muud valikud"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Lisa"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Lülita sisse"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Lülita kohe sisse"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Lülita kohe välja"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Funktsioon Mitte segada on sees kuni <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Funktsioon Mitte segada on sees seni, kuni selle välja lülitate"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Ajakava (<xliff:g id="RULE_NAME">%s</xliff:g>) lülitas funktsiooni Mitte segada automaatselt sisse"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Rakendus (<xliff:g id="APP_NAME">%s</xliff:g>) lülitas funktsiooni Mitte segada automaatselt sisse"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Funktsioon Mitte segada on reeglite <xliff:g id="RULE_NAMES">%s</xliff:g> puhul sisse lülitatud koos kohandatud seadetega."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Kuva kohandatud seaded"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Ainult prioriteetsed"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Sees / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Sees"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Küsi iga kord"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Kuni välja lülitate"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 tund}other{# tundi}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minut}other{# minutit}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Väljas}=1{Väljas / 1 ajakava saab automaatselt sisse lülitada}other{Väljas / # ajakava saavad automaatselt sisse lülitada}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Mis saavad režiimi Mitte segada katkestada?"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Inimesed"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Rakendused"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmid ja muud katkestused"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Ajakavad"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Kiirseadete kestus"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Üldine"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Kui funktsioon Mitte segada on sisse lülitatud, vaigistatakse heli ja vibreerimine (v.a ülal lubatud üksuste puhul)."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Kohandatud seaded"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Vaadake ajakava üle"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Selge"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Märguanded"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Kestus"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Sõnumid, sündmused ja meeldetuletused"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Kui funktsioon Mitte segada on sisse lülitatud, vaigistatakse sõnumid, meeldetuletused ja sündmused, välja arvatud teie ülal lubatud üksuste puhul. Võite sõnumite seadeid kohandada, et lubada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Valmis"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Seaded"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Hääletud ja ekraanilt peidetud märguanded"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Hääletud märguanded"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Te ei kuule ega näe märguandeid. Tärniga tähistatud kontaktidelt ja korduvatelt helistajatelt pärit kõned on lubatud."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(praegune seade)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Kas soovite režiimi Mitte segada märguandeseadeid muuta?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Tööprofiili helid"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Kasuta isikliku profiili helisid"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Kasutage samu helisid, mida kasutate oma isikliku profiiliga"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Töötelefoni helin"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Töömärguande vaikeheli"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Tööalarmi vaikeheli"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Sama mis isiklikul profiilil"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Kas kasutada isikliku profiili helisid?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Kinnita"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Teie tööprofiil kasutab teie isikliku profiiliga samu helisid"</string>
    <string name="ringtones_install_custom_sound_title" msgid="3885712267015760638">"Kas soovite lisada kohandatud heli?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="5844996763705884979">"Fail kopeeritakse kausta <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="26680768777533727">"Helinad"</string>
    <string name="other_sound_category_preference_title" msgid="8182757473602586634">"Muud helid ja värinad"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Märguanded"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Märguannete ajalugu, vestlused"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Vestlus"</string>
    <string name="recent_notifications" msgid="1105631022180160436">"Hiljuti saadetud"</string>
    <string name="recent_notifications_see_all_title" msgid="3087299996651692987">"Kuva kõik viimase 7 päeva kohta"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Haldamine"</string>
    <string name="app_notification_field" msgid="3858667320444612716">"Rakenduse seaded"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Individuaalsete rakenduste märguannete haldamine"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Üldine"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Töö märguanded"</string>
    <string name="smart_notifications_title" msgid="8995288376897952015">"Kohanduvad märguanded"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Kohanduvate märguannete prioriteet"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Madalama prioriteediga märguanded määratakse automaatselt leebeteks märguanneteks"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Märguannete kohanduv järjestamine"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Järjesta märguanded automaatselt asjakohasuse järgi"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Kohanduvate märguannete tagasiside"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Näitab, kuidas on märguandeid kohandatud. Samuti näitab valikut süsteemile tagasiside andmiseks."</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Märguande olulisuse lähtestamine"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Kasutaja muudetud olulisuse seadete lähtestamine ja märguannete assistendil prioriseerimise lubamine"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Soovitatud toimingud ja vastused"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Kuva soovitatud toimingud ja vastused automaatselt"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Kuva hiljutisi ja edasilükatud märguandeid"</string>
    <string name="notification_history" msgid="8663811361243456201">"Märguannete ajalugu"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Kasuta märguannete ajalugu"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Märguannete ajalugu on välja lülitatud"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Hiljutiste ja edasilükatud märguannete nägemiseks lülitage märguannete ajalugu sisse"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Hiljutisi märguandeid ei ole"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Teie hiljutised ja edasilükatud märguanded kuvatakse siin"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"kuva märguandeseaded"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"ava märguanne"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Luba märguandeid edasi lükata"</string>
    <string name="hide_silent_icons_title" msgid="5951392023601167577">"Leebete märguannete ikoonide peitmine"</string>
    <string name="hide_silent_icons_summary" msgid="623763437631637232">"Leebete märguannete ikoone ei kuvata olekuribal"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Märguandetäpp rakenduse ikoonil"</string>
    <string name="notification_people_strip_title" msgid="1185857822541001139">"Kuva hiljutiste vestluste riba"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Mullid"</string>
    <string name="bubbles_feature_education" msgid="4088275802688887634">"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="5319021259954576150">"Mullid"</string>
    <string name="bubbles_conversation_app_link" msgid="5468779786387915337">"Kõik mullide seaded"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Kuva see vestlus mullis"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Kuva rakenduste peal hõljuv ikoon"</string>
    <string name="bubbles_app_toggle_summary" msgid="1574515698567947948">"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="1794193899792284007">"Kas lülitada mullid seadmes sisse?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Kui lülitate mullid selle rakenduse puhul sisse, lülitatakse mullid sisse ka teie seadmes.\n\nSee mõjutab teisi rakendusi või vestlusi, millel on luba mullis kuvamiseks."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Lülita sisse"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Tühista"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Sees / vestlused kuvatakse hõljuvate ikoonidena"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Luba rakendustel mulle kuvada"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Mõned vestlused kuvatakse hõljuvate ikoonidena teiste rakenduste peal"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Kõik vestlused saab mullina kuvada"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Valitud vestlused saab mullina kuvada"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Mitte midagi ei saa mullina kuvada"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Vestlused"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Kõik vestlused saab kuvada mullis, v.a"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Lülitage mullid selle vestluse puhul välja"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Lülitage mullid selle vestluse puhul sisse"</string>
    <string name="swipe_direction_title" msgid="4260320464727178413">"Pühkimistoimingud"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Loobumiseks pühkige paremale, menüü kuvamiseks vasakule"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Loobumiseks pühkige vasakule, menüü kuvamiseks paremale"</string>
    <string name="gentle_notifications_title" msgid="2793492905132530991">"Leebed märguanded"</string>
    <string name="gentle_notifications_also_display" msgid="8617545395880297691">"Kuva ka järgmises kohas:"</string>
    <string name="gentle_notifications_display_status" msgid="7410244447768694856">"Olekuriba"</string>
    <string name="gentle_notifications_display_lock" msgid="1914245082527924144">"Lukustuskuva"</string>
    <string name="gentle_notifications_education" msgid="5957509621826384362">"Leebed märguanded on alati vaiksed ja kuvatakse alati allatõmmatavas menüüs"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="7616926954719310445">"Kuva ainult allatõmmatavas menüüs"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="3936088046873705625">"Kuva allatõmmatavas menüüs ja lukustuskuval"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="3363137853729359907">"Kuva allatõmmatavas menüüs ja olekuribal"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="2068738866725616212">"Kuva allatõmmatavas menüüs, olekuribal ja lukustuskuval"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Peida vaiksed märguanded olekuribal"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Vilkuv tuli"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privaatsus"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Lukustuskuva vahelejätmine"</string>
    <string name="lockscreen_bypass_summary" msgid="464277506200346748">"Pärast avamist avaneb viimati vaadatud kuva"</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Lukustuskuva, lukustuskuva, vahelejätmine, mittekasutamine"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kui tööprofiil on lukustatud"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Märguanded lukustuskuval"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Kuva vestluse, vaike- ja vaiksed märguanded"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Peida hääletud vestlused ja märguanded"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ära kuva märguandeid"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Tundlikud märguanded"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Kuva lukustatuna tundlik sisu"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Tööprofiili tundlikud märguanded"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Kuva lukustatuna tööprofiili tundlik sisu"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Kuva kogu märguande sisu"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Kuva tundlik sisu ainult avatuna"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Ära kuva märguandeid üldse"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Kuidas soovite lukustuskuva kuvada?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Lukustuskuva"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Kuva töökoha märguannete kogu sisu"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Peida tundlik töösisu"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kuidas tuleks profiili märguanded kuvada siis, kui seade on lukus?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profiili märguanded"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Märguanded"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Rakenduste märguanded"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Märguannete kategooria"</string>
    <string name="notification_group_title" msgid="7525666535695631538">"Märguande kategooria grupp"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Käitumine"</string>
    <string name="notification_importance_unspecified" msgid="1543165530748339700">"Heli lubamine"</string>
    <string name="notification_importance_blocked" msgid="4933285639639899394">"Ära kunagi kuva märguandeid"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Vestlused"</string>
    <string name="conversation_category_title" msgid="6777135786004214149">"Vestlus"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Vestluste jaotis"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Rakendusel lubatakse kasutada vestluste jaotist"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Pole vestlus"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Eemalda vestluste jaotisest"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"See on vestlus"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Lisa vestluste jaotisse"</string>
    <string name="manage_conversations" msgid="4440289604887824337">"Vestluste haldamine"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Prioriteetseid vestlusi pole"</string>
    <plurals name="priority_conversation_count" formatted="false" msgid="4229447176780862649">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> prioriteetset vestlust</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> prioriteetne vestlus</item>
    </plurals>
    <string name="important_conversations" msgid="1233893707189659401">"Prioriteetsed vestlused"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Kuvatakse vestluste jaotise kohal hõljuvate mullidena"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Kuva vestluste jaotise kohal"</string>
    <string name="other_conversations" msgid="551178916855139870">"Vähemtähtsad vestlused"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Vestlused, milles olete muudatusi teinud"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Hiljutised vestlused"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Kustuta hiljutised vestlused"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Hiljutine vestlus eemaldati"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Vestlus eemaldati"</string>
    <string name="clear" msgid="5092178335409471100">"Kustuta"</string>
    <string name="important_bubble" msgid="7911698275408390846">"Kuva prioriteetsed vestlused mullis"</string>
    <string name="important_conversation_behavior_summary" msgid="1845064084071107732">"Prioriteetsed vestlused kuvatakse allatõmmatava ala ülaosas. Saate lasta need kuvada ka mullis ja katkestada funktsiooni Mitte segada."</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Prioriteetsed ja muudetud vestlused kuvatakse siin"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Kui märgite vestluse prioriteetseks või teete vestluses teisi muudatusi, kuvatakse need siin. \n\nVestluse seadete muutmine: \npühkige ekraani ülaosast alla, et avada allatõmmatav ala. Seejärel puudutage pikalt vestlust."</string>
    <string name="notification_importance_min" msgid="4609688642942787774">"Kuva vaikselt ja minimeeri"</string>
    <string name="notification_importance_low" msgid="7562535765919565273">"Kuva hääletult"</string>
    <string name="notification_importance_default" msgid="7483906490369073043">"Esita heli"</string>
    <string name="notification_importance_high" msgid="8453789143477210550">"Esita heli ja tõsta märguanne esile"</string>
    <string name="notification_importance_high_silent" msgid="8977232884004607985">"Tõsta märguanne esile"</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimeeri"</string>
    <string name="notification_importance_low_title" msgid="658158049378796947">"Keskmine"</string>
    <string name="notification_importance_default_title" msgid="8875198696330289686">"Kõrge"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Tõsta märguanne esile"</string>
    <string name="notification_block_title" msgid="7392909527700971673">"Blokeeri"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Hääletu"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Vaikeseade"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Katkestuste lubamine"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Rakendusel lubatakse heli esitada, vibreerida ja/või ekraanil hüpikmärguandeid kuvada"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioriteetne"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Kuvatakse vestluste jaotise ülaosas hõljuva mullina ja lukustuskuval kuvatakse profiilipilt"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> ei toeta enamikku vestlusfunktsioone. Te ei saa vestluse prioriteeti määrata ja vestluseid ei kuvata hõljuvate mullidena."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Allatõmmatavas loendis ahendatakse märguanded ühele reale"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Ilma heli ja vibreerimiseta"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Ilma heli ja vibreerimiseta, kuvatakse vestluste jaotises allpool"</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Võib telefoni seadete põhjal heliseda või vibreerida"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kui seade on avatud, kuvatakse märguanded bännerina ekraanikuva ülaosas"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Kõik tüüpi „<xliff:g id="APP_NAME">%1$s</xliff:g>” märguanded"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Kõik rakenduse <xliff:g id="APP_NAME">%1$s</xliff:g> märguanded"</string>
    <string name="default_notification_assistant" msgid="243718059890346442">"Kohanduvad märguanded"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="1479283620504341566">
      <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="4913443431857170519">
      <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="9081278709126812062">"Mitte kunagi"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Seadmete ja rakenduste märguanded"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Hallake, millised rakendused ja seadmed saavad märguandeid lugeda"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Juurdepääs tööprofiili märguannetele on blokeeritud"</string>
    <string name="manage_notification_access_summary_zero" msgid="7528633634628627431">"Rakendused ei suuda märguandeid lugeda"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="3703008881487586312">
      <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="5889201903272393099">"Täiustatud märguanded"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Hankige soovitatud toiminguid, vastuseid ja muud"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Puudub"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Ükski installitud rakendus pole taotlenud juurdepääsu märguannetele."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Luba juurdepääs märguannetele"</string>
    <string name="notification_assistant_security_warning_title" msgid="2972346436050925276">"Kas <xliff:g id="SERVICE">%1$s</xliff:g> pääseb märguannetele juurde?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Androidi versioonis 12 asendasid täiustatud märguanded Androidi kohanduvad märguanded. See funktsioon näitab soovitatud toiminguid ja vastuseid ning korrastab teie märguandeid. \n\nTäiustatud märguanded pääsevad juurde märguande sisule, sh isiklikule teabele, nagu kontaktide nimed ja sõnumid. Samuti saab selle funktsiooni abil märguannetest loobuda või neile vastata (nt vastata telefonikõnedele ja juhtida funktsiooni Mitte segada)."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Kas <xliff:g id="SERVICE">%1$s</xliff:g> pääseb märguannetele juurde?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1658213659262173405">"<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. Rakendus saab ka märguandeid eemaldada või aktiveerida märguannetes olevaid toimingunuppe, sealhulgas vastata telefonikõnedele. \n\nSee võimaldab rakendusel ka lülitada sisse või välja funktsiooni Mitte segada ja muuta sellega seotud seadeid."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Kui lülitate teenuse <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> jaoks juurdepääsu märguannetele välja, võidakse välja lülitada ka juurdepääs funktsioonile Mitte segada."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Lülita välja"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Tühista"</string>
    <string name="notification_listener_type_title" msgid="2791552789364336733">"Lubatud märguannete tüübid"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Reaalajas"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Käimasolev suhtlus kasutatavatest rakendustest, navigeerimine, telefonikõned ja muu"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Vestlused"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS-id, tekstsõnumid ja muud suhtlusviisid"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Märguanded"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Võib seadete põhjal heliseda või vibreerida"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Hääletu"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Märguanded, mis ei tee kunagi häält ega vibreeri"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Lubatud"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Pole lubatud"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Kuva kõik rakendused"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Muutke seadeid iga rakenduse jaoks, mis saadab märguandeid"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Seadmes kuvatud rakendused"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"See rakendus ei toeta täiustatud seadeid"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"VR-abilise teenused"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Ükski installitud rakendus pole taotlenud VR-abilise teenusena käitamist."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Kas lubada VR-teenuse juurdepääs teenusele <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"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="4850474436291113569">"Kui seade on VR-režiimis"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Vähenda hägusust (soovitatav)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Vähenda värelemist"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Pilt pildis"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Ükski installitud rakendus ei toeta funktsiooni Pilt pildis"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip pildis"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Pilt pildis"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Luba režiim Pilt pildis"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Lubage rakendusel luua pilt pildis aken ajal, mil rakendus on avatud, või pärast sellest väljumist (näiteks video vaatamise jätkamiseks). Aken kuvatakse muude kasutatavate rakenduste peal."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Ühendatud töö- ja isiklikud rakendused"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Ühendatud"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Ühendamata"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Ühtegi rakendust pole ühendatud"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"profiiliülene ühendatud rakendus rakendused töö ja isiklik"</string>
    <string name="interact_across_profiles_app_detail_title" msgid="7776184211173575648">"Ühendatud töö- ja isiklikud rakendused"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Ühendatud"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Ühenda need rakendused"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Ühendatud rakendused kasutavad ühiseid lube ja neil on juurdepääs teineteise andmetele."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Ühendage rakendused ainult siis, kui olete kindel, et need ei jaga teie isiklikke andmeid IT-administraatoriga."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Rakenduste ühenduse saate seadme privaatsusseadetes igal ajal katkestada."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Kas usaldate töörakendust <xliff:g id="NAME">%1$s</xliff:g> ja lubate sellel oma isiklikele andmetele juurde pääseda?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Ühendage rakendused ainult siis, kui olete kindel, et need ei jaga teie isiklikke andmeid IT-administraatoriga."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Rakenduse andmed"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Rakendusel on juurdepääs teie isikliku rakenduse <xliff:g id="NAME">%1$s</xliff:g> andmetele."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Load"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"See rakendus võib kasutada teie isikliku rakenduse <xliff:g id="NAME">%1$s</xliff:g> lube, nagu juurdepääs asukohale, salvestusruumile või kontaktidele."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Ühtegi rakendust pole ühendatud"</string>
    <plurals name="interact_across_profiles_number_of_connected_apps" formatted="false" msgid="6991750455661974772">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> rakendust on ühendatud</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> rakendus on ühendatud</item>
    </plurals>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Nende rakenduste ühendamiseks installige <xliff:g id="NAME">%1$s</xliff:g> oma tööprofiilile"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Nende rakenduste ühendamiseks installige <xliff:g id="NAME">%1$s</xliff:g> oma isiklikule profiilile"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Puudutage rakenduse hankimiseks"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Mitte segada juurdepääs"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Luba funktsioon Mitte segada"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Ükski installitud rakendus pole palunud juurdepääsu funktsioonile Mitte segada"</string>
    <string name="loading_notification_apps" msgid="5139471829295287945">"Rakenduste laadimine …"</string>
    <string name="app_notifications_off_desc" msgid="6691342160980435901">"Teie taotluse kohaselt blokeerib Android selle rakenduse märguannete kuvamise selles seadmes"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Teie taotluse kohaselt blokeerib Android selle märguandekategooria kuvamise selles seadmes"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Teie taotluse kohaselt blokeerib Android selle märguandegrupi kuvamise selles seadmes"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategooriad"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Muu"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="483490958130993160">
      <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="4716199078612071915">"See rakendus pole postitanud ühtegi märguannet"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Lisaseaded rakenduses"</string>
    <string name="notification_screen_summary" msgid="5984915275134654822">"Märguannete ajalugu, mullid, hiljuti saadetud"</string>
    <string name="app_notification_listing_summary_zero" msgid="2988400013221120744">"Sisse lülitatud kõigi rakenduste jaoks"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="1506127395400503717">
      <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="5963473421547029532">
      <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="1624283327379059003">"Sees"</string>
    <string name="notification_toggle_off" msgid="3295373308338024844">"Väljas"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokeeri kõik"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Ära kunagi näita neid märguandeid"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Kuva märguanded"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Ära kuva märguandeid kunagi märguandealal ega välisseadmetes"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Luba märguandetäpp"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Kuva märguandetäpp"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Funktsiooni Mitte segada alistamine"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Nendel märguannetel lubatakse teid jätkuvalt katkestada, kui funktsioon Mitte segada on sisse lülitatud"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Lukustuskuva"</string>
    <string name="app_notification_row_banned" msgid="4513523107019706924">"Blokeeritud"</string>
    <string name="app_notification_row_priority" msgid="8100777138078316446">"Prioriteetne"</string>
    <string name="app_notification_row_sensitive" msgid="7374688948587174964">"Tundlik"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Valmis"</string>
    <string name="app_notification_importance_title" msgid="8293193440040799998">"Tähtsus"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Vilkuv tuli"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibreerimine"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Heli"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioriteetne"</string>
    <string name="notification_conversation_add_to_home" msgid="8136269431130231389">"Avalehele lisamine"</string>
    <string name="zen_mode_rule_delete_button" msgid="7642063606919058862">"Kustuta"</string>
    <string name="zen_mode_rule_rename_button" msgid="4158377587795511144">"Nimeta ümber"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Ajakava nimi"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Sisestage ajakava nimi"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Ajakava nimi on juba kasutuses"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Lisa veel"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Sündmuse ajakava lisamine"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Ajakava lisamine"</string>
    <string name="zen_mode_delete_rule" msgid="5419296431989891130">"Kustuta ajakava"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Valige ajakava tüüp"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Kas kustutada reegel „<xliff:g id="RULE">%1$s</xliff:g>”?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Kustuta"</string>
    <string name="zen_mode_rule_type_unknown" msgid="7819162569994282316">"Teadmata"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Neid seadeid ei saa praegu muuta. Rakendus (<xliff:g id="APP_NAME">%1$s</xliff:g>) on funktsiooni Mitte segada koos kohandatud käitumisega automaatselt sisse lülitanud."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Neid seadeid ei saa praegu muuta. Rakendus on funktsiooni Mitte segada koos kohandatud käitumisega automaatselt sisse lülitanud."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Neid seadeid ei saa praegu muuta. Funktsioon Mitte segada koos kohandatud käitumisega lülitati käsitsi sisse."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Aeg"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="6534402316741678208">"Automaatne reegel on teatud kellaaegade puhul määratud sisse lülitama funktsiooni Mitte segada"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Sündmus"</string>
    <string name="zen_event_rule_enabled_toast" msgid="4943723266121388395">"Automaatne reegel on teatud sündmuste puhul määratud sisse lülitama funktsiooni Mitte segada"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Sündmuste ajal:"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="3065013489987409864">"Sündmuste ajal kalendris <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="8395450413356855311">"mis tahes kalender"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="7786137431469077008">"Kus vastus on <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Mis tahes kalender"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Kui vastus on:"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Jah, Võib-olla või Pole vastanud"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Jah või Võib-olla"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Jah"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Reeglit ei leitud."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Sees / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Päevad"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Puudub"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="1583884351893245169">"Iga päev"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Äratus alistab lõppaja"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Ajakava lülitub äratuse kõlamisel välja"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Funktsiooni Mitte segada käitumine"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Kasuta vaikeseadeid"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Sellele ajakavale kohandatud seadete määramine"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” jaoks"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> – <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="6022314482293187463">"<xliff:g id="START">%1$s</xliff:g> kuni <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Vestlused"</string>
    <string name="zen_mode_conversations_section_title" msgid="666809483050936026">"Vestlused, mis saavad katkestada"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Kõik vestlused"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioriteetsed vestlused"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Mitte ükski"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Puudub}=1{1 vestlus}other{# vestlust}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kes saavad katkestada?"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Kõned"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Kõned"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"kõned"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Kõned, mis saavad katkestada"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Selleks et telefon lubatud kõnede puhul heliseks, kontrollige, kas helinarežiim on aktiveeritud."</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” puhul on sissetulevad kõned blokeeritud. Võite seadeid kohandada, et võimaldada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Tärniga kontaktid"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Puudub}=1{{contact_1}}=2{{contact_1} ja {contact_2}}=3{{contact_1}, {contact_2} ja {contact_3}}other{{contact_1}, {contact_2} ja veel #}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Nimi puudub)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Sõnumid"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"sõnumid"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Sõnumid"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Sõnumid, mis saavad katkestada"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Selleks et telefon lubatud sõnumite puhul heliseks, kontrollige, kas helinarežiim on aktiveeritud."</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Ajakava „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” puhul on sissetulevad sõnumid blokeeritud Võite seadeid kohandada, et võimaldada sõpradel, pereliikmetel või muudel kontaktidel teiega ühendust võtta."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Kõik sõnumid jõuavad teieni"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Kõik kõned jõuavad teieni"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Puudub}=1{1 kontakt}other{# kontakti}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Kõik"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontaktid"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Tärniga kontaktid"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="8078759939219244001">"Tärniga tähistatud kontaktidelt ja korduvatelt helistajatelt"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="2276432091940405376">"Kontaktidelt ja korduvatelt helistajatelt"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7748352153193832632">"Ainult korduvatelt helistajatelt"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Mitte ükski"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Mitte ükski"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmid"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Taimeritelt, äratustelt, turvasüsteemidelt ja muudelt rakendustelt"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"äratused"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Äratused"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Meediahelid"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Videote, mängude ja muu meediasisu heli"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"meedia"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Meedia"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Puutehelid"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Klaviatuuri ja muude nuppude helid"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"puutehelid"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Puutehelid"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Meeldetuletused"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Ülesannetelt ja meeldetuletustelt"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"meeldetuletused"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Meeldetuletused"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Kalendrisündmused"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Tulevastelt kalendrisündmustelt"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"sündmused"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Sündmused"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Luba rakendustel alistada"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Rakendused, mis saavad katkestada"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Valige rohkem rakendusi"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Rakendusi pole valitud"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Mitte ükski rakendus ei saa katkestada"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Rakenduste lisamine"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Kõik märguanded"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Mõned märguanded"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Valitud inimesed saavad teiega ühendust võtta, isegi kui te ei luba rakendustel end segada"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Mitte ükski rakendus ei saa katkestada}=1{{app_1} saab katkestada}=2{{app_1} ja {app_2} saavad katkestada}=3{{app_1}, {app_2} ja {app_3} saavad katkestada}other{{app_1}, {app_2} ja veel # saavad katkestada}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Rakendused"</string>
    <string name="zen_mode_bypassing_apps_all_summary" msgid="5197566190120503132">"Kõik märguanded"</string>
    <string name="zen_mode_bypassing_apps_some_summary" msgid="1514572070650411509">"Mõnd märguanded"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Märguanded, mis saavad katkestada"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Luba kõik märguanded"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Mitte miski ei saa katkestada}=1{{sound_category_1} saab katkestada}=2{{sound_category_1} ja {sound_category_2} saavad katkestada}=3{{sound_category_1}, {sound_category_2} ja {sound_category_3} saavad katkestada}other{{sound_category_1}, {sound_category_2} ja veel # saavad katkestada}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Mitte miski ei saa katkestada"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Mitte keegi ei saa katkestada"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Mõned inimesed saavad katkestada"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Kõik inimesed saavad katkestada"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Korduvad helistajad"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Luba korduvad helistajad"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"igaüks"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontaktid"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"tärniga kontaktid"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"korduvad helistajad"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> ja <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Kui sama inimene helistab teile <xliff:g id="MINUTES">%d</xliff:g> minuti jooksul teist korda"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="3126805555852783860">"Kohandatud"</string>
    <string name="zen_mode_when" msgid="5710214762051824755">"Autom. sisselülitus"</string>
    <string name="zen_mode_when_never" msgid="2537537280091840672">"Mitte kunagi"</string>
    <string name="zen_mode_when_every_night" msgid="9018738747936038166">"Igal õhtul"</string>
    <string name="zen_mode_when_weeknights" msgid="531342225633264368">"Argiõhtuti"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Algusaeg"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Lõppaeg"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> järgmisel päeval"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Muudetakse määramata ajaks valikule Ainult alarmid"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="1900512966361163390">
      <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="955991428001659124">
      <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="8140619669703968810">"Muudetakse valikule Ainult alarmid kuni kella <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Muudetakse valikule Katkesta alati"</string>
    <string name="zen_mode_screen_on" msgid="7312758100468915319">"Kui ekraan on sees"</string>
    <string name="zen_mode_screen_on_summary" msgid="510055058460316698">"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="7069798697669366075">"Kui ekraan on väljas"</string>
    <string name="zen_mode_screen_off_summary" msgid="4698018253505406152">"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="1958271859408992636">"Luba märguannetel, mille funktsioon Mitte segada on vaigistanud, ekraan sisse lülitada"</string>
    <string name="notification_app_settings_button" msgid="4692549882609342128">"Märguandeseaded"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Hoiatus"</string>
    <string name="suggestion_button_text" msgid="4370673818678692873">"OK"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Sule"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Seadme kohta tagasiside saatmine"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Sisestage administraatori PIN-kood"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Sees"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Väljas"</string>
    <!-- no translation found for nfc_setting_on (7701896496026725772) -->
    <skip />
    <!-- no translation found for nfc_setting_off (7142103438532732309) -->
    <skip />
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Sees"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Väljas"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Rakenduse kinnitamine"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Rakenduse kinnitamine võimaldab teil praeguse rakenduse kuval hoida seni, kuni selle vabastate. Seda funktsiooni saab kasutada näiteks selleks, et lubada usaldusväärsel sõbral teatud mängu mängida."</string>
    <string name="screen_pinning_description" msgid="7289730998890213708">"Kui rakendus on kinnitatud, saab kinnitatud rakendus avada teisi rakendusi ja isiklikud andmed võivad olla juurdepääsetavad. \n\nRakenduse kinnitamise kasutamiseks toimige järgmiselt. 	\n1.	Lülitage rakenduse kinnitamine sisse. 	\n2.	Avage leht Ülevaade. 	\n3.	Puudutage ekraanikuva ülaosas rakenduse ikooni ja siis käsku Kinnita."</string>
    <string name="screen_pinning_guest_user_description" msgid="5826264265872938958">"Kui rakendus on kinnitatud, saab kinnitatud rakendus avada teisi rakendusi ja isiklikud andmed võivad olla juurdepääsetavad. \n\nKui soovite oma seadet kellegagi turvaliselt jagada, proovige selle asemel kasutada külaliskasutajat. \n\nRakenduse kinnitamise kasutamiseks toimige järgmiselt. 	\n1.	Lülitage rakenduse kinnitamine sisse. 	\n2.	Avage leht Ülevaade. 	\n3.	Puudutage ekraanikuva ülaosas rakenduse ikooni ja siis käsku Kinnita."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kui rakendus on kinnitatud: \n\n•		võivad isiklikud andmed (nt kontaktid\nja meilide sisu) olla juurdepääsetavad; \n•		kinnitatud rakendus võib avada teisi rakendusi. \n\nKasutage rakenduse kinnitamist ainult usaldusväärsete inimestega."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Enne vabastamist küsi avamismustrit"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Enne vabastamist küsi PIN-koodi"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Enne vabastamist küsi parooli"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Vabastamise korral lukusta seade"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"SIM-i kustutamise kinnitamine"</string>
    <string name="confirm_sim_deletion_description" msgid="8937609409607338516">"Enne allalaaditud SIM-i tühjendamist kinnitage oma isik"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Seda tööprofiili hallatakse rakendusega"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Haldab <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="869354050717870055">"(Katseline)"</string>
    <string name="encryption_interstitial_header" msgid="4418014339568737685">"Turvaline käivitamine"</string>
    <string name="encryption_continue_button" msgid="3591796237625134622">"Jätka"</string>
    <string name="encryption_interstitial_message_pin" msgid="1413575143234269985">"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="726550613252236854">"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="6051054565294909975">"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="7152770518093102916">"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="6257856552043740490">"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="7710804822643612867">"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="8577135499926738241">"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="5851725964283239644">"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="3553329272456428461">"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_message_pin_for_biometrics" msgid="4590004045791674901">"Lisaks sellele, et võite seadme avamiseks kasutada oma biomeetriat, 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_biometrics" msgid="2697768285995352576">"Lisaks sellele, et võite seadme avamiseks kasutada oma biomeetriat, 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_biometrics" msgid="1895561539964730123">"Lisaks sellele, et võite seadme avamiseks kasutada oma biomeetriat, 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="1948016725089728181">"Jah"</string>
    <string name="encryption_interstitial_no" msgid="3352331535473118487">"Ei"</string>
    <string name="restricted_true_label" msgid="612852292488747564">"Piiratud"</string>
    <string name="restricted_false_label" msgid="2837053797913490628">"Rakendus saab taustal akut kasutada"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8974156384205924887">"Kas nõuda PIN-koodi?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1587587568721873184">"Kas nõuda mustrit?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="2701793623210531836">"Kas nõuda parooli?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="4482887117824444481">"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="5156321541636018756">"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="1917287751192953034">"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="5766006106305996844">"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="8703564992893669514">"IMEI teave"</string>
    <string name="imei_information_summary" msgid="4763358372990258786">"IMEI suhteline teave"</string>
    <string name="slot_number" msgid="2663789411468530397">"(<xliff:g id="SLOT_NUM">%1$d</xliff:g>. pesa)"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Vaikimisi avamine"</string>
    <string name="app_launch_domain_links_title" msgid="6702041169676128550">"Linkide avamine"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Toetatud linkide avamine"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Luba selles rakenduses avada veebilinke"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Rakenduses avatavad lingid"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="3609156836041234957">"Avamine ilma küsimata"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Toetatud lingid"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Muud vaike-eelistused"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Lingi lisamine"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Rakendus saab lingid kinnitada, et need rakenduses automaatselt avada."</string>
    <plurals name="app_launch_verified_links_title" formatted="false" msgid="3945301449178587783">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kinnitatud linki</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kinnitatud link</item>
    </plurals>
    <plurals name="app_launch_verified_links_message" formatted="false" msgid="1209292155940482111">
      <item quantity="other">Need lingid on kinnitatud ja avanevad rakenduses automaatselt.</item>
      <item quantity="one">See link on kinnitatud ja avaneb rakenduses automaatselt.</item>
    </plurals>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Kuva kinnitatud linkide loend"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Muude toetatud linkide otsimine …"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Loobu"</string>
    <plurals name="app_launch_supported_links_title" formatted="false" msgid="8579323750839397568">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> toetatud linki</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> toetatud link</item>
    </plurals>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Lisa"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Avaneb rakenduses <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> kasutusel (<xliff:g id="STORAGE_TYPE">%2$s</xliff:g>)"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"sisemine salvestusruum"</string>
    <string name="storage_type_external" msgid="125078274000280821">"väline salvestusruum"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> kasut. alates <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Kasutatud salvestusruum"</string>
    <string name="change" msgid="273206077375322595">"Muuda"</string>
    <string name="change_storage" msgid="8773820275624113401">"Salvestusruumi muutmine"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Märguanded"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Sees"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Väljas"</string>
    <string name="notifications_partly_blocked" msgid="5738239705473445725">"<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="2673798575466545098">"Vaigistatud"</string>
    <string name="notifications_redacted" msgid="8820993927920208612">"Lukustuskuval ei näidata tundlikku sisu"</string>
    <string name="notifications_hidden" msgid="2415415452913806859">"Pole lukustuskuval"</string>
    <string name="notifications_priority" msgid="9068574646650663837">"Režiim Mitte segada alistati"</string>
    <string name="notifications_summary_divider" msgid="6877149909390030983">" / "</string>
    <string name="notification_summary_level" msgid="4074326972839105652">"%d. tase"</string>
    <string name="notification_summary_channel" msgid="8459033623057872803">"<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="1385401442703692986">
      <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="5015472550875144481">
      <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="2091022049141391855">
      <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="5888624648943937645">
      <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="7456745929035665029">"Lube pole antud"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Lube pole taotletud"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Rakenduste puhul andmetele juurdepääsu haldamine"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Privaatsuse juhtpaneel"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Näita, millised rakendused hiljuti lube kasutasid"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Kasutamata rakendused"</string>
    <plurals name="unused_apps_summary" formatted="false" msgid="3827583582750975783">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kasutamata rakendust</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> kasutamata rakendus</item>
    </plurals>
    <string name="unused_apps_switch" msgid="419282628373205038">"Eemalda load ja vabasta ruumi"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Kõik rakendused"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Installitud rakendused"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Installimata avat. rakendused"</string>
    <string name="filter_notif_all_apps" msgid="2764590815789208306">"Rakendused: kõik"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Välja lülitatud"</string>
    <string name="filter_notif_urgent_channels" msgid="875381675739324318">"Kategooriad: kiireloomuline"</string>
    <string name="filter_notif_low_channels" msgid="2163005243095264537">"Kategooriad: vähetähtis"</string>
    <string name="filter_notif_blocked_channels" msgid="1131444963543380495">"Kategooriad: välja lülitatud"</string>
    <string name="filter_notif_dnd_channels" msgid="13445325087914932">"Kategooriad: alist. Mitte seg."</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Täpsemad"</string>
    <string name="configure_apps" msgid="5468359087126598115">"Rakenduste seadistamine"</string>
    <string name="unknown_app" msgid="2027248925719898714">"Tundmatu rakendus"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Lubade haldur"</string>
    <string name="app_permissions_summary" msgid="2709819220672938860">"Rakendused, mis kasutavad: <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="app_permissions_summary_more" msgid="6247952473615352350">"Teenuseid <xliff:g id="APPS">%1$s</xliff:g> jm kasutavad rakendused"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Puudutusega äratamine"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Seadme äratamiseks topeltpuudutage ekraani"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Linkide avamine"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Toetatud linke ei avata"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Domeeni <xliff:g id="DOMAIN">%s</xliff:g> avamine"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Ava domeen <xliff:g id="DOMAIN">%s</xliff:g> ja muud URL-id"</string>
    <string name="domain_urls_apps_summary_off" msgid="2534980824850890416">"Ükski rakendus ei ava toetatud linke"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="7864816862441985323">
      <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="9167065494930657503">"Luba rakendusel avada toetatud lingid"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Küsi iga kord"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Ära luba rakendusel avada toetatud linke"</string>
    <plurals name="app_link_open_always_summary" formatted="false" msgid="1816161439007251694">
      <item quantity="other">Rakendus käsitleb väidetavalt <xliff:g id="COUNT_1">%d</xliff:g> linki</item>
      <item quantity="one">Rakendus käsitleb väidetavalt <xliff:g id="COUNT_0">%d</xliff:g> linki</item>
    </plurals>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Rakendus käsitleb väidetavalt järgmisi linke:"</string>
    <string name="default_apps_title" msgid="6943471331817718664">"Vaikeseade"</string>
    <string name="default_for_work" msgid="537558180548617528">"Vaikimisi töö jaoks"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Abirakendus ja häälsisend"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digitaalse assistendi rakendus"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Digitaalse assistendi vaikerakendus"</string>
    <string name="assistant_security_warning_title" msgid="6444187332360938730">"Kas soovite rakenduse <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> muuta abirakenduseks?"</string>
    <string name="assistant_security_warning" msgid="5623237187748811070">"Assistent 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="9013334158753473359">"Nõustu"</string>
    <string name="assistant_security_warning_disagree" msgid="1539182108068356410">"Ei nõustu"</string>
    <string name="choose_voice_input_title" msgid="4855506199101586943">"Häälsisendi valimine"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Brauserirakendus"</string>
    <string name="default_browser_title_none" msgid="4691907418284764833">"Vaikebrauserit pole"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Telefonirakendus"</string>
    <string name="default_app" msgid="445053777504688596">"(Vaikeseade)"</string>
    <string name="system_app" msgid="1863291702508355041">"(Süsteem)"</string>
    <string name="system_default_app" msgid="2647834628622214931">"(Süsteemi vaikeseade)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Rakenduste salvestusruum"</string>
    <string name="usage_access" msgid="5487993885373893282">"Juurdepääs kasutusele"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Luba juurdepääs kasutusele"</string>
    <string name="app_usage_preference" msgid="7062447555623339120">"Rakenduse kasutuse eelistused"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Ekraaniaeg"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Juurdepääs kasutusele võimaldab rakendusel jälgida, milliseid teisi rakendusi (ja kui sageli), operaatorit ja keeleseadeid te kasutate, ning vaadata teisi üksikasju."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Mälu"</string>
    <string name="memory_details_title" msgid="3048107441540417799">"Mälu üksikasjad"</string>
    <string name="always_running" msgid="9012705720688200252">"Töötab alati (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Töötab vahel (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Töötab harva (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="8721866158069974846">"Maksimaalne"</string>
    <string name="memory_avg_use" msgid="4620476409349875703">"Keskmine"</string>
    <string name="memory_max_desc" msgid="6966923521720393526">"Maksimaalselt <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="2632995851138152303">"Keskmiselt <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g> / <xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="4239069158701023623">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Aku optimeerimine"</string>
    <string name="additional_battery_info" msgid="3104208543623068714">"Teated kasutuse kohta"</string>
    <string name="show_all_apps" msgid="4490719452453223082">"Kuva seadme kogu kasutusteave"</string>
    <string name="hide_extra_apps" msgid="7313907836289865123">"Kuva rakenduste kasutusteave"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="573433136005336970">
      <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="8013115866788425817">
      <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="447849271630431531">"Pole optimeeritud"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Pole optimeeritud"</string>
    <string name="high_power_off" msgid="317000444619279018">"Akukasutuse optimeerimine"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Aku optimeerimine pole saadaval"</string>
    <string name="high_power_desc" msgid="2753076899835765338">"Aku optimeerimist ei rakendata. Aku võib kiiremini tühjeneda."</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Kas soovite lubada rakendusel pidevalt taustal töötada?"</string>
    <string name="high_power_prompt_body" msgid="6460557929559616041">"Kui lubate rakendusel <xliff:g id="APP_NAME">%1$s</xliff:g> pidevalt taustal töötada, võib see lühendada aku tööiga.\n\nSaate seda hiljem muuta jaotises Seaded &gt; Rakendused ja märguanded."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Kasutus alates viimasest täislaadimisest on <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> kasutust viimase 24 tunni jooksul"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Akut pole pärast viimast täislaadimist kasutatud"</string>
    <string name="no_battery_summary_24hr" msgid="6280079526797873842">"Viimase 24 tunni jooksul pole akut kasutatud"</string>
    <string name="app_notification_preferences" msgid="2004680717999108725">"Rakenduse seaded"</string>
    <string name="system_ui_settings" msgid="936169564323330967">"Kuva SystemUI tuuner"</string>
    <string name="additional_permissions" msgid="4656871347558988462">"Täiendavad load"</string>
    <string name="additional_permissions_more" msgid="8188145515437525307">"Veel <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Kas jagada veaaruannet?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"IT-administraator taotles veaaruannet, mis aitaks seadmes vigu otsida. Rakendusi ja andmeid võidakse jagada."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"IT-administraator taotles veaaruannet, mis aitaks seadmes vigu otsida. Rakendusi ja andmeid võidakse jagada ning see võib ajutiselt teie seadet aeglustada."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Seda veaaruannet jagatakse IT-administraatoriga. Lisateabe saamiseks võtke temaga ühendust."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Jaga"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Keeldu"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Andmeedastus puudub"</string>
    <string name="usb_use_charging_only_desc" msgid="1234421230461847336">"Selle seadme laadimine"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Ühendatud seadme laadimine"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Failiedastus"</string>
    <string name="usb_use_file_transfers_desc" msgid="1020257823387107336">"Failide edastamine teise seadmesse"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konvertige videod AVC-vormingusse"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videoid saab esitada rohkemates meediapleierites, kuid kvaliteet võib olla halvem"</string>
    <string name="usb_use_photo_transfers_desc" msgid="7490250033610745765">"Fotode või failide edastamine, kui MTP-d ei toetata (PTP)"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB kaudu jagamine"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="6464135515868405143">"Kasutage seda seadet MIDI-na"</string>
    <string name="usb_use" msgid="6783183432648438528">"USB kasutusviis"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"USB-vaikeseadistus"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Kui teine seade on ühendatud ja teie telefon avatakse, rakendatakse need seaded. Looge ühendus ainult usaldusväärsete seadmetega."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Toitevalikud"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Failiedastuse valikud"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB eelistused"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB-liidest juhib"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Ühendatud seade"</string>
    <string name="usb_control_device" msgid="527916783743021577">"See seade"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Vahetamine …"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Ei õnnestunud vahetada"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Selle seadme laadimine"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Ühendatud seadme laadimine"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Failiedastus"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB kaudu jagamine"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Failiedastus ja toide"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB kaudu jagamine ja toide"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP ja toide"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI ja toide"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Taustakontroll"</string>
    <string name="background_check_title" msgid="225170874283229686">"Täielik juurdepääs taustale"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Ekraanil oleva teksti kasutamine"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Abirakendusele lubatakse ekraani sisule juurdepääs tekstina"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Ekraanipildi kasutamine"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Abirakendusele lubatakse juurdepääs ekraanipildile"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Ekraani vilkumine"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Kui abirakendus pääseb ekraanil olevale tekstile või ekraanipildile juurde, vilguvad ekraani servad"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Abirakendused saavad aidata teid kuvatud ekraaniteabe alusel. Mõned rakendused toetavad integreeritud abi pakkumisel nii käivitusprogrammi kui ka häälsisendi teenuseid."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Keskmine mälukasutus"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimaalne mälukasutus"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Mälukasutus"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Rakenduse kasutamine"</string>
    <string name="memory_details" msgid="6133226869214421347">"Üksikasjad"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Viimase 3 tunni jooksul kasutati mälu keskmiselt <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Viimase 3 tunni jooksul mälu ei kasutatud"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sordi keskmise kasutuse järgi"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sordi maksimaalse kasutuse järgi"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Jõudlus"</string>
    <string name="total_memory" msgid="5244174393008910567">"Kogu mälumaht"</string>
    <string name="average_used" msgid="690235917394070169">"Keskmine kasutus (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Vaba"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Rakenduste kasutatav mälu"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="1355637088533572208">
      <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="7260225121706316639">"Sagedus"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimaalne kasutus"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Andmesidet pole kasutatud"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Rakenduse <xliff:g id="APP">%1$s</xliff:g> juurdepääs funktsioonile Mitte segada"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Rakendus saab funktsiooni Mitte segada sisse/välja lülitada ja muuta sellega seotud seadeid."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Peab jääma sisselülitatud asendisse, kuna juurdepääs märguannetele on sisse lülitatud"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Kas tühistada rakenduse <xliff:g id="APP">%1$s</xliff:g> juurdepääs režiimile Mitte segada?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Kõik selle rakenduse loodud režiimi Mitte segada reeglid eemaldatakse."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ära optimeeri"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimeeri"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Aku võib kiiremini tühjeneda. Rakendusel on nüüd lubatud taustal akut kasutada."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Soovitatav aku kasutusaja pikendamiseks"</string>
    <string name="ignore_optimizations_title" msgid="3464172726254542889">"Kas lubada rakendusel <xliff:g id="APP">%s</xliff:g> eirata aku optimeerimisi?"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Puudub"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Selle rakenduse puhul ei takista kasutuse juurdepääsu väljalülitamine administraatoril jälgida teie tööprofiilil olevate rakenduste andmekasutust."</string>
    <string name="accessibility_lock_screen_progress" msgid="4597298121698665401">"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="7902083260500573027">"Muude rakenduste peal kuvamine"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Muude rakenduste peal kuvamine"</string>
    <string name="system_alert_window_apps_title" msgid="1537949185175079866">"Rakendused"</string>
    <string name="system_alert_window_access_title" msgid="3074573819155116817">"Muude rakenduste peal kuvamine"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Luba muude rakenduste peal kuvamine"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Lubage seda rakendust kuvada muude kasutatavate rakenduste peal. See rakendus näeb, kus puudutate, või saab muuta seda, mis ekraanil kuvatakse."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Juurdepääs kõikidele failidele"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Luba juurdepääs kõikide failide haldamisele"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Sellel rakendusel lubatakse lugeda, muuta ja kustutada kõiki selles seadmes ning ühendatud andmekandjatel olevaid faile. Loa andmisel võib rakendus failidele juurde pääseda ilma teie teadmata."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Pääseb failidele juurde"</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Meedia haldamise rakendused"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Rakendusele meedia haldamise lubamine"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Kui lubate, saab see rakendus ilma teilt luba küsimata muuta või kustutada muude rakendustega loodud meediafaile. Rakendusel peab olema failidele ja meediale juurdepääsu luba."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"meedia, fail, haldus, haldur, haldamine, muutmine, redaktor, rakendus, programm"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"VR virtuaalreaalne kuulaja stereo abiline teenus"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Muude rakenduste peal kuvamine"</string>
    <string name="system_alert_window_summary" msgid="1435856750594492891">"<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="2483998217116789206">"Loaga rakendused"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Lubatud"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Pole lubatud"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"rakenduste installimine tundmatutest allikatest"</string>
    <string name="write_settings" msgid="6864794401614425894">"Süsteemiseadete muutmine"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"kirjuta muuda süsteemiseaded"</string>
    <string name="write_settings_summary" msgid="2085800775513476479">"<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="6930762738519588431">"Saab installida teisi rakendusi"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Saab muuta süsteemiseadeid"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Saab muuta süsteemiseadeid"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Süsteemiseadete muutmine"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Luba süsteemiseadete muutmine"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Luba võimaldab rakendusel muuta süsteemiseadeid."</string>
    <string name="write_settings_on" msgid="8533286548451191112">"Jah"</string>
    <string name="write_settings_off" msgid="1781103034490679144">"Ei"</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Luba sellest allikast"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Pöörake kaks korda kaamera avamiseks"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Avage kaamerarakendus, pöörates rannet kaks korda"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="8264757967127716261">"Kaamera avam. vajut. 2 korda toitenuppu"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="1539147023700755155">"Kaamera avatakse kiirelt ekraani avamata"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Kuvamissuurus"</string>
    <string name="screen_zoom_short_summary" msgid="2458636490408833800">"Ekraanil kuvatud üksuste suuremaks või väiksemaks muutmine"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"ekraani tihedus, ekraani suum, skaala, skaleerimine"</string>
    <string name="screen_zoom_summary" msgid="1362984939045594989">"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="5288355628444562735">"Eelvaade"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Vähendamine"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Suurendamine"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="2896036059049355968">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="4873109337506890558">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="2641317981482545659">"Tere, Pete!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6528272610590915790">"Kas soovid täna kokku saada ja kohvi juua?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="6930848361702066106">"Kõlab hästi. Tean üht head lähedalasuvat kohta."</string>
    <string name="screen_zoom_conversation_message_4" msgid="2501043894465807210">"Suurepärane!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="512353741016062507">"Teisipäev, 18:00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="472183807915497199">"Teisipäev, 18:01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="1659313906250856104">"Teisipäev, 18:02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2046797647382623313">"Teisipäev, 18:03"</string>
    <string name="disconnected" msgid="3469373726996129247">"Pole ühendatud"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Ühendus puudub"</string>
    <string name="data_usage_summary_format" msgid="6844301859713164522">"Kasutatud andmemaht on <xliff:g id="AMOUNT">%1$s</xliff:g>"</string>
    <string name="data_usage_wifi_format" msgid="7644390582649568117">"WiFi kaudu on kasutatud <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <plurals name="notification_summary" formatted="false" msgid="7638388920823212470">
      <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="9179312319023988089">"Sisse lülitatud kõigi rakenduste jaoks"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Installitud on <xliff:g id="COUNT">%1$d</xliff:g> rakendust"</string>
    <string name="apps_summary_example" msgid="6034002063446955592">"24 installitud rakendust"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> on kasutatud – <xliff:g id="FREE_SPACE">%2$s</xliff:g> on vaba"</string>
    <string name="storage_summary_with_sdcard" msgid="2063780050580228868">"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="5526061030874717172">"Pärast <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> tegevusetut olekut lülitatakse unerežiimi"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tume teema, fondi suurus, eredus"</string>
    <string name="display_summary_example" msgid="4275121979039344438">"Lülita unerežiimi pärast 10-minutilist tegevuseta olekut"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Keskmiselt on kasutusel <xliff:g id="USED_MEMORY">%1$s</xliff:g> mälu <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>-st"</string>
    <string name="users_summary" msgid="8473589474976307510">"Sisse logitud kasutajana <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="5513009140568552693">"Rakendus <xliff:g id="APP_NAME">%1$s</xliff:g> on vaikevalik"</string>
    <string name="backup_disabled" msgid="4503062265560959320">"Varundamine on keelatud"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Android värskendati versioonile <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Värskendus on saadaval"</string>
    <string name="disabled_by_policy_title" msgid="3635622338687810583">"Blokeeris teie IT-administraator"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Helitugevust ei saa muuta"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Ei saa helistada"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"SMS-e ei saa saata"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Kaamerat ei saa kasutada"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Ekraanipilte ei saa jäädvustada"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Seda rakendust ei saa avada"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokeeris teie krediidipakkuja"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Vaja on vanema abi"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Anna telefon vanemale, et ta saaks selle seadistamist alustada"</string>
    <string name="default_admin_support_msg" msgid="8338570262037182531">"Küsimuste korral võtke ühendust IT-administraatoriga"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Rohkem üksikasju"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Teie administraator saab jälgida ja hallata teie tööprofiiliga seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Teie administraator saab jälgida ja hallata selle kasutajaga seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Teie administraator saab jälgida ja hallata selle seadmega seotud rakendusi ning andmeid, sh seadeid, lube, ettevõtte juurdepääsu, võrgutegevusi ja seadme asukohateavet."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Teie seadme administraator võib pääseda juurde selle seadmega seostatud andmetele, hallata rakendusi ja muuta selle seadme seadeid."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Lülita välja"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Lülita sisse"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Kuva"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Peida"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Kuumkoht on aktiivne"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Lennurežiim on sees"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Võrgud pole saadaval"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Režiim Mitte segada on sees"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefon on vaigistatud"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Eranditega"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Akusäästja on sisse lülitatud"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funktsioonid on piiratud"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobiilne andmeside on väljas"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet on saadaval ainult WiFi kaudu"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Andmemahu säästja"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funktsioonid on piiratud"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Tööprofiil on välja lülitatud"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Rakenduste ja märguannete puhul"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Lülita heli sisse"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Telefonihelin on vaigistatud"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Kõnede ja märguannete puhul"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Ainult vibreerimine"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Kõnede ja märguannete puhul"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Öövalguse ajakava määramine"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Ekraani toon muutub igal õhtul automaatselt"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Öövalgus on sees"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Kollase tooniga ekraanikuva"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Halltoonid"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Ainult halli värviga kuvamine"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Ahenda"</string>
    <string name="suggestions_title_v2" msgid="421003737901460147">"Teile soovitatud"</string>
    <string name="suggestions_title" msgid="61841299295602686">"Soovitused"</string>
    <string name="suggestions_summary" msgid="1709710458908440469">"+ <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="240124526378997009">"Ja veel <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="5023679825210836444">
      <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="3789011332018516832">
      <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="6753986344585367776">"Eemalda"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Külm värvitemperatuur"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Kasutatakse külmemaid ekraanivärve"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Värvi muutmise rakendamiseks lülitage ekraan välja"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Kaamera laserandur"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automaatsed süsteemivärskendused"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Rakenda värskendused seadme taaskäivitamisel"</string>
    <string name="usage" msgid="287782903846013936">"Kasutus"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Mobiilse andmeside kasutus"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Rakenduste andmekasutus"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"WiFi-andmekasutus"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Operaatoriväline andmekasutus"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Etherneti andmekasutus"</string>
    <string name="wifi" msgid="2932584495223243842">"WiFi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobiilset andmesidet"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> WiFi-andmeid"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> Etherneti-andmeid"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Andmekasutuse hoiatus ja piirang"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Mobiilse andmeside kasutustsükkel"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu hoiatus"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu piirang"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"<xliff:g id="ID_1">^1</xliff:g> – andmemahu hoiatus / <xliff:g id="ID_2">^2</xliff:g> – andmemahu piirang"</string>
    <string name="billing_cycle_fragment_summary" msgid="6346655500491631357">"Iga kuu <xliff:g id="ID_1">%1$s</xliff:g>. päeval"</string>
    <string name="network_restrictions" msgid="8385824604048229846">"Võrgupiirangud"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="3875128958788008975">
      <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="5672761970087591211">"Operaatori andmemahuarvestus võib erineda seadme andmemahuarvestusest"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Ei sisalda operaatorite võrkude kasutatavat andmemahtu"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> on kasutatud"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Andmekasutuse hoiatuse määramine"</string>
    <string name="data_warning" msgid="2925054658166062884">"Andmemahu hoiatus"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Andmemahu hoiatuse ja piirangu mõõdikut jälgib teie seade. See võib erineda teie operaatori andmetest."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Andmemahupiirangu määramine"</string>
    <string name="data_limit" msgid="8731731657513652363">"Andmemahu piirang"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"Vahemikus <xliff:g id="ID_2">%2$s</xliff:g> on kasutatud <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Seadistamine"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Muud kasutusandmetesse kaasatud rakendused"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="3316296488378947221">
      <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="4039024073687469094">"Peamine andmeside"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"WiFi-andmeside"</string>
    <string name="data_used" msgid="7770571947591789895">"<xliff:g id="ID_1">^1</xliff:g> on kasutatud"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Kasutatud on <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> üle"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Jäänud on <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graafikus on kuvatud andmekasutus kuupäevavahemikus <xliff:g id="START_DATE">%1$s</xliff:g> kuni <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Selle kuupäevavahemiku kohta pole andmeid"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="661792524671718753">
      <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="1694844019159277504">"Rohkem aega pole jäänud"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Jäänud on vähem kui üks päev"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Operaator <xliff:g id="ID_1">^1</xliff:g> värskendas <xliff:g id="ID_2">^2</xliff:g> tagasi"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Värskendati <xliff:g id="ID_1">^2</xliff:g> tagasi"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Operaator <xliff:g id="ID_1">^1</xliff:g> värskendas äsja"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Värskendati äsja"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Kuva pakett"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Kuva üksikasjad"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Andmemahu säästja"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Piiramata andmeside"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Taustaandmed on välja lülitatud"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Sees"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Väljas"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Andmemahu säästja kasutamine"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Piiranguteta andmekasutus"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Luba piiranguteta juurdepääs andmesidele, kui andmemahu säästja on sisse lülitatud"</string>
    <string name="home_app" msgid="6056850504746902747">"Avakuva rakendus"</string>
    <string name="no_default_home" msgid="3588073707316139318">"Vaike-avakuva puudub"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="4098653943835666086">"Turvaline käivitamine"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="311325321794497404">"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="1881271630312222251">"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="8651761245246411947">"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="4726777300101156208">"Lisage veel üks sõrmejälg"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Teise sõrmega avamine"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Sees"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Lülitub sisse <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> juures"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Väljas"</string>
    <string name="battery_saver_button_turn_on" msgid="2206239048232352476">"Lülita kohe sisse"</string>
    <string name="battery_saver_button_turn_off" msgid="6371072408072481484">"Lülita kohe välja"</string>
    <string name="not_battery_optimizing" msgid="8361294470943376258">"Aku optimeerimist ei kasutata"</string>
    <string name="lockscreen_remote_input" msgid="6030274311185811503">"Kui seade on lukus, keela märguannetes vastuste või muu teksti sisestamine"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Vaikeõigekirjakontroll"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Õigekirjakontrolli valimine"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Kasuta õigekirjakontrolli"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Pole valitud"</string>
    <string name="notification_log_no_title" msgid="2343315128609978203">"(puudub)"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"võti"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupp"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(kokkuvõte)"</string>
    <string name="notification_log_details_visibility" msgid="6811292866832243357">"nähtavus"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"avalik versioon"</string>
    <string name="notification_log_details_priority" msgid="4772047133062255513">"prioriteetne"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"tähtsus"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"selgitus"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"saab kuvada märgi"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"kavatsus"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"kustuta kavatsus"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"täisekraani kavatsus"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"toimingud"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"pealkiri"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"kaugsisestused"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"kohandatud vaade"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"lisad"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikoon"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"paki suurus"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"märguandest teavitati"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_none" msgid="1090852853755089991">"puudub"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Asetuse objekt puudub."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Asetuse objekt ei sisalda seda võtit."</string>
    <string name="theme_customization_device_default" msgid="7641813022590999286">"Seadme vaikeseade"</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Ekraani väljalõige"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"ekraani väljalõige, lõige"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Seadme vaikeseade"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Ülekatet ei õnnestunud rakendada"</string>
    <string name="special_access" msgid="1767980727423395147">"Rakenduse erijuurdepääs"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <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="132919514147475846">"Kuva rohkem"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="3783325656948378111">"Kas soovite tõesti kasutaja andmed kustutada ja teisendada failide krüpteerimisele?"</string>
    <string name="button_confirm_convert_fbe" msgid="339648921918438106">"Kustuta ja teisenda"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Teenuse ShortcutManager sageduse piiramise lähtestamine"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Teenuse ShortcutManager sageduse piiramine lähtestati"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrollige lukustuskuva teavet"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Märguande sisu kuvamine või peitmine"</string>
    <string name="page_tab_title_summary" msgid="7188875610123234454">"Kõik"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Nõuanded ja tugi"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Kõige väiksem laius"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Ükski installitud rakendus pole taotlenud juurdepääsu tasuliste SMS-ide saatmiseks"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Tasuliste SMS-ide saatmisel võidakse teilt nõuda tasu, mis lisatakse operaatori esitatud arvele. Kui annate rakendusele loa, saate selle rakendusega tasulisi SMS-e saata."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Juurdepääs tasuliste SMS-ide saatmiseks"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Väljas"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Ühendatud seadmega <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Ühendatud mitme seadmega"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Süsteemi kasutajaliidese demorežiim"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tume teema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Akusäästja tõttu ajutiselt suletud"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Akusäästja tõttu ajutiselt keelatud"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Lülita akusäästja välja"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Akusäästja tõttu ajutiselt sisse lülitatud"</string>
    <string name="dark_ui_settings_dark_summary" msgid="1214821092462388494">"Toetatud rakendused aktiveerivad samuti tumeda teema"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="250437497729953965">"Selge"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Proovige tumedat teemat"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Aitab pikendada aku tööiga"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Arendaja kiirseadete paanid"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Keela ADB volituse ajalõpp"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Keelake ADB volituste automaatne tühistamine süsteemides, mis ei loo uuesti ühendust vaikeaja (7 päeva) või kasutaja määratud aja (vähemalt 1 päev) jooksul."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Winscope Trace"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Andurid on väljas"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Tööprofiili seaded"</string>
    <!-- no translation found for managed_profile_contact_search_title (6562061740814513737) -->
    <skip />
    <!-- no translation found for managed_profile_contact_search_summary (4974727886709219105) -->
    <skip />
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Profiilideülene kalender"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Kuvab tööga seotud sündmused isiklikus kalendris"</string>
    <plurals name="hours" formatted="false" msgid="1853396353451635458">
      <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="6244503272924425418">
      <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="4237020272336995370">
      <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="519158151463974656">"Salvestusruumi haldamine"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Salvestusruumi vabastamiseks eemaldab salvestusruumi haldur varundatud fotod ja videod teie seadmest."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Fotode ja videote eemaldamine"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Salvestusruumi haldur"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Kasuta salvestusruumi haldurit"</string>
    <string name="deletion_helper_automatic_title" msgid="597196990024769472">"Automaatne"</string>
    <string name="deletion_helper_manual_title" msgid="1068812971600327101">"Käsitsi"</string>
    <string name="deletion_helper_preference_title" msgid="6364023246849161274">"Vabastage ruumi"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Liigutused"</string>
    <string name="gesture_preference_summary" product="default" msgid="7941981260703379398">"Kiirliigutused telefoni juhtimiseks"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4031666250963488007">"Kiirliigutused tahvelarvuti juhtimiseks"</string>
    <string name="gesture_preference_summary" product="device" msgid="3520072325356373349">"Kiirliigutused seadme juhtimiseks"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Kaamera kiire avamine"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Kaamera kiireks avamiseks vajutage toitenuppu kaks korda. See töötab igast kuvast."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="4299496243418753571">"Kaamera kiiresti avamine"</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Selfi tegemiseks kaamera pööramine"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="8178844037382604158">"Selfide kiiremini jäädvustamine"</string>
    <string name="system_navigation_title" msgid="1698862900901417194">"Süsteemis navigeerimine"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Kahe nupuga navigeerimine"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Rakenduste vahetamiseks pühkige avakuva nupul üles. Kõigi rakenduste nägemiseks pühkige uuesti üles. Tagasiliikumiseks puudutage nuppu Tagasi."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="5754081720589900007">"Proovige uut avakuva nuppu"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="8885866570559435110">"Rakenduste vahetamiseks lülitage sisse uus liigutus"</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Ohutus ja hädaolukorrad"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Hädaabikõne, meditsiiniline teave, hoiatused"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Liigutustega navigeerimine"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"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="7877402855994423727">"Kolme nupuga navigeerimine"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Liikuge tagasi või avakuvale ja vahetage rakendusi ekraani allosas olevate nuppude abil."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"süsteemis navigeerimine, kahe nupuga navigeerimine, kolme nupuga navigeerimine, liigutustega navigeerimine, pühkimine"</string>
    <string name="gesture_not_supported_dialog_message" msgid="5316512246119347889">"Teie avakuva vaikerakendus <xliff:g id="DEFAULT_HOME_APP">%s</xliff:g> ei toeta"</string>
    <string name="gesture_not_supported_positive_button" msgid="7909969459977021893">"Lülitu avakuva vaikerakendusele"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitaalne assistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Assistendi käivitamiseks pühkimine"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Pühkige ekraanikuva alanurgast üles, et digitaalse assistendi rakendus käivitada."</string>
    <string name="information_label" msgid="6939310810756569298">"Teave"</string>
    <string name="low_label" msgid="6525629096999711220">"Väike"</string>
    <string name="high_label" msgid="357503396626018487">"Suur"</string>
    <string name="left_edge" msgid="1513576842959071849">"Vasak serv"</string>
    <string name="right_edge" msgid="1505309103265829121">"Parem serv"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Suurem tundlikkus võib ekraani servades mõne rakenduse liigutusega vastuolus olla."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Tagasiliigutuse tundlikkus"</string>
    <string name="gesture_settings_activity_title" msgid="6047431928567911330">"Liigutuste seaded"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"liigutustega navigeerimine, tagasiliigutuse tundlikkus, tagasiliigutus"</string>
    <string name="ambient_display_title" product="default" msgid="5885136049497127396">"Telefoni kontrollimiseks topeltpuudutamine"</string>
    <string name="ambient_display_title" product="tablet" msgid="205744440641466921">"Topeltpuudutage tahvelarvuti kontrollimiseks"</string>
    <string name="ambient_display_title" product="device" msgid="4164103424628824786">"Topeltpuudutage seadme kontrollimiseks"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Ühekäerežiim"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Kasuta ühekäerežiimi"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"ühe käega kasutamine"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Pühkige alla, et teha järgmist"</string>
    <!-- no translation found for one_handed_mode_use_shortcut_category (1414714099339147711) -->
    <skip />
    <string name="one_handed_mode_intro_text" msgid="4313074112548160836">"Ühekäerežiimi kasutamiseks pühkige ekraanikuva alaservast alla. Selle funktsiooni kasutamiseks veenduge, et liigutustega navigeerimine oleks süsteemi navigeerimisseadetes sisse lülitatud."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Ekraanikuva tõmbamine ulatusse"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Ekraanikuva ülaosa teisaldatakse teie pöidla ulatusse."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Märguannete kuvamine"</string>
    <!-- no translation found for one_handed_action_show_notification_summary (8281689861222000436) -->
    <skip />
    <string name="ambient_display_summary" msgid="2650326740502690434">"Kellaaja, märguannete ja muu teabe vaatamiseks topeltpuudutage oma ekraani."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="4418310591912877548">"Telefoni kontrollimiseks tõstmine"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="8055486872070888377">"Tahvelarvuti kontrollimiseks tõstke seda"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="8980156994848721455">"Seadme kontrollimiseks tõstke seda"</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Ekraani äratamine"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="1087355013674109242">"Kellaaja, märguannete ja muu teabe vaatamiseks võtke telefon kätte."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="2589556997034530529">"Kellaaja, märguannete ja muu teabe vaatamiseks võtke tahvelarvuti kätte."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="1916011370011115627">"Kellaaja, märguannete ja muu teabe vaatamiseks võtke seade kätte."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="2811332293938467179">"Telefoni kontrollimiseks puudutamine"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="6461531447715370632">"Puudutamine tahvelarvuti kontrollimiseks"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="4423803387551153840">"Puudutamine seadme kontrollimiseks"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Kellaaja, märguannete ja muu teabe vaatamiseks puudutage ekraani."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Hädaabikõne"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Hädaabikõne kasutamine"</string>
    <string name="emergency_gesture_entrypoint_summary" msgid="4730874229911208834">"Haldab <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Vajutage toitenuppu kiiresti viis või enam korda, et käivitada alltoodud toimingud"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Loendusalarmi esitamine"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Esita hädaabikõne alustamisel vali heli"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Teavitamine abi saamiseks"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Helistamine abi saamiseks"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Number abi kutsumiseks"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Puudutage muutmiseks."</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Kui sisestate numbri, mis pole hädaabinumber:\n • Teie telefon peab hädaabikõne tegemiseks olema avatud.\n • Teie kõnele ei pruugita vastata."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Märguannete kuvamiseks sõrmejälje pühkimine"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Sõrmejälje pühkimine"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="286662791588779673">"Märguannete kontrollimiseks pühkige telefoni tagaküljel oleval sõrmejäljeanduril alla."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="8642092907817554454">"Märguannete kontrollimiseks pühkige tahvelarvuti tagaküljel oleval sõrmejäljeanduril alla."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="3888927017311372398">"Märguannete kontrollimiseks pühkige seadme tagaküljel oleval sõrmejäljeanduril alla."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Kiiresti märguannete vaatamine"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Sees"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Väljas"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Buudilaadur on juba avatud"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="8045017109714463041">"Looge esmalt Interneti-ühendus"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Looge Interneti-ühendus või võtke ühendust operaatoriga"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Ei ole operaatori lukustatud seadmetes saadaval"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Seadme kaitsefunktsiooni lubamiseks taaskäivitage seade."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Kokku vabastati <xliff:g id="SIZE">%1$s</xliff:g> ruumi\n\nViimati käitati kuupäeval <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Installimata avatavad rakendused"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Lingid avatakse rakendustes isegi siis, kui need pole installitud"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Installimata avatavad rakendused"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Installimata avatavate rakenduste eelistused"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Installitud rakendused"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Teie salvestusruumi haldab nüüd salvestusruumi haldur"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Kasutaja <xliff:g id="USER_NAME">%1$s</xliff:g> kontod"</string>
    <string name="configure_section_header" msgid="3126887329521705210">"Seadistamine"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Rakenduse andmete automaatne sünkroonimine"</string>
    <string name="auto_sync_personal_account_title" msgid="3544275021920818595">"Sünkrooni isiklikud andmed automaatselt"</string>
    <string name="auto_sync_work_account_title" msgid="6060310415978781885">"Sünkrooni tööandmed automaatselt"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Luba rakendustel andmeid automaatselt värskendada"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Konto sünkroonimine"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sünkroonimine on sisse lülitatud <xliff:g id="ID_1">%1$d</xliff:g> üksuse jaoks <xliff:g id="ID_2">%2$d</xliff:g>-st"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sünkroonimine on kõigi üksuste jaoks sisse lülitatud"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sünkroonimine on kõigi üksuste jaoks välja lülitatud"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Hallatava seadme teave"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Teie organisatsiooni hallatavad muudatused ja seaded"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Organisatsiooni <xliff:g id="ORGANIZATION_NAME">%s</xliff:g> hallatavad muudatused ja seaded"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Teie tööandmetele juurdepääsu andmiseks võib teie organisatsioon muuta seadeid ja installida seadmesse tarkvara. \n\nLisateabe saamiseks võtke ühendust organisatsiooni administraatoriga."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Teie organisatsiooni nähtava teabe tüübid"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Teie organisatsiooni administraatori tehtud muudatused"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Teie juurdepääs sellele seadmele"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Teie töökontoga seotud andmed, nt e-post ja kalender"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Teie seadmes olevate rakenduste loend"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Iga rakenduse kasutamise aeg ja kasutatud andmemaht"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Uusim võrguliikluse logi"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Kõige viimane veaaruanne"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Kõige viimane turvalogi"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Puudub"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Installitud rakendused"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Rakenduste arv on hinnanguline. See ei pruugi hõlmata muudest allikatest kui Play poest installitud rakendusi."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="5403847001419529018">
      <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="8023838718108456971">"Asukohale juurdepääsu load"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Mikrofoni load"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Kaamera load"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Vaikerakendused"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="8568544906431825430">
      <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="3278314982700662246">"Vaikeklaviatuur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Määratud valikule <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Alati sees VPN on sisse lülitatud"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Alati sees VPN on teie isiklikul profiilil sisse lülitatud"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Alati sees VPN on teie tööprofiilil sisse lülitatud"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Üldine HTTP-puhverserver on seadistatud"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Usaldusväärsed mandaadid"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Usaldusväärsed mandaadid teie isiklikul profiilil"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Usaldusväärsed mandaadid teie tööprofiilil"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="6459725295322004179">
      <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="464054894363899866">"Administraator saab seadme lukustada ja parooli lähtestada"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administraator saab kustutada kõik seadme andmed"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Parooli sisestamise ebaõnnestunud katsete arv enne seadmes olevate kõigi andmete kustutamist"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Parooli sisestamise ebaõnnestunud katsete arv enne tööprofiilil olevate andmete kustutamist"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="8811973918944217791">
      <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="3067459392402324538">"Seda seadet haldab teie organisatsioon."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Seda seadet haldab <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Lisateave"</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Järelmaksuga seadme teave"</string>
    <string name="financed_privacy_exposure_category" msgid="440169672717221900">"Mis tüüpi teavet teie seadme administraator näeb"</string>
    <string name="financed_privacy_data" msgid="6931909690419946400">"Teie kontoga seostatud andmed, nt e-posti aadress ja kalendriteave"</string>
    <string name="financed_privacy_exposure_changes_category" msgid="1556943765530226434">"Teie seadme administraatori tehtud muudatused"</string>
    <string name="financed_privacy_lock_device" msgid="8963934429658453147">"Seadme administraator saab seadme lukustada ja parooli lähtestada"</string>
    <string name="financed_privacy_wipe_device" msgid="5711746449385459844">"Seadme administraator saab kustutada kõik seadme andmed"</string>
    <string name="financed_privacy_failed_password_wipe_device" msgid="8777230427603977667">"Parooli sisestamise ebaõnnestunud katsete arv enne seadmes olevate andmete kustutamist"</string>
    <string name="financed_privacy_header" msgid="7215645340918406124">"Teie krediidipakkuja saab muuta seadeid ja installida seadmesse tarkvara.\n\nLisateabe saamiseks võtke ühendust krediidipakkujaga."</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="8112432929729136399">
      <item quantity="other">Kaamerarakendused</item>
      <item quantity="one">Kaamerarakendus</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalendrirakendus"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Rakendus Kontaktid"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="8338194872609410234">
      <item quantity="other">Meilikliendirakendused</item>
      <item quantity="one">Meilikliendirakendus</item>
    </plurals>
    <string name="default_map_app_title" msgid="7569231732944853320">"Kaardirakendus"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="4222188821845826493">
      <item quantity="other">Telefonirakendused</item>
      <item quantity="one">Telefonirakendus</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"See seade"</string>
    <string name="storage_photos_videos" msgid="6926197783745481869">"Fotod ja videod"</string>
    <string name="storage_music_audio" msgid="1185624135490182822">"Muusika ja heli"</string>
    <string name="storage_games" msgid="1176568610086802469">"Mängud"</string>
    <string name="storage_other_apps" msgid="5902520888043081176">"Muud rakendused"</string>
    <string name="storage_files" msgid="7968460921272772299">"Failid"</string>
    <string name="storage_images" msgid="2055893015567979387">"Pildid"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videod"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Heli"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Rakendused"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumendid ja muu"</string>
    <string name="storage_system" msgid="8472410119822911844">"Süsteem"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Prügikast"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Kas tühjendada prügikast?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Prügikastis on <xliff:g id="TOTAL">%1$s</xliff:g> faili. Kõik üksused kustutatakse jäädavalt ja te ei saa neid taastada."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Prügikast on tühi"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Tühjenda prügikast"</string>
    <string name="storage_size_large_alternate" msgid="7555149858858591495">"<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="7102720999351050601">"Kasutatud <xliff:g id="TOTAL">%1$s</xliff:g>-st"</string>
    <string name="storage_percent_full" msgid="7211888326013020857">"kasut."</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Kasutatud on <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Kokku <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Tühjenda rakendus"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Kas soovite selle installimata avatava rakenduse eemaldada?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Ava"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Mängud"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Kasutatav ruum"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(desinstall. kasutaja <xliff:g id="USER">%s</xliff:g> jaoks)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(keelatud kasutaja <xliff:g id="USER">%s</xliff:g> jaoks)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Automaattäite teenus"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Paroolid"</string>
    <plurals name="autofill_passwords_count" formatted="false" msgid="7715009165029452622">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> parooli</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> parool</item>
    </plurals>
    <string name="autofill_keywords" msgid="8598763328489346438">"automaatne, täitmine, automaattäide, parool"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Veenduge, et rakendus oleks usaldusväärne&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google\'i automaatne täitmine&gt;%1$s&lt;/xliff:g&gt; kasutab automaatse täitmise sisestuse määramiseks ekraanil kuvatut."</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automaattäide"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Logimistase"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Max taotluste arv seansi kohta"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Max nähtavate andmekomplektide arv"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Vaikeväärtustele lähtestamine"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Arendaja automaattäite valikud on lähtestatud"</string>
    <string name="location_category" msgid="3496759112306219062">"Asukoht"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Olekuriba asukohanäidik"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Kuva kõikide asukohtade puhul (sh võrk ja ühenduvus)"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Jõusta GNSS-i täielikud mõõtmistulemused"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Jälgi kõiki GNSS-i radu ja sagedusi ilma töötsüklita"</string>
    <string name="device_theme" msgid="5027604586494772471">"Seadme teema"</string>
    <string name="default_theme" msgid="4815428567082263639">"Vaikeseade"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Võrgu nimi"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Võrgu nimi kuvatakse olekuribal"</string>
    <string name="storage_manager_indicator" msgid="6187509172735927297">"Salvestusruumi haldur: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="2705959642617709265">"Väljas"</string>
    <string name="storage_manager_indicator_on" msgid="8380330763647785309">"Sees"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Installimata avatav rakendus"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Kas soovite salvestusruumi halduri välja lülitada?"</string>
    <string name="storage_movies_tv" msgid="7897612625450668593">"Filmi- ja TV-rakendused"</string>
    <string name="carrier_provisioning" msgid="7217868336140325816">"Operaatori ettevalmistamise teave"</string>
    <string name="trigger_carrier_provisioning" msgid="3288805742683538597">"Operaatori ettevalmistamise päästik"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Värskendage režiimi Mitte segada"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Keskendumiseks peatage märguanded"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funktsioon pole saadaval"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"See funktsioon on välja lülitatud, kuna see muudab teie telefoni aeglaseks"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Kuva alati kokkujooksmise dialoog"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Dialoog kuvatakse alati, kui rakendus kokku jookseb"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Valige rakendus, milles ANGLE on lubatud"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Seadistatud pole ühtegi rakendust, milles ANGLE on lubatud"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Rakendus, milles ANGLE on lubatud: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Graafikadraiveri eelistused"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Graafikadraiveri seadete muutmine"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kui graafikadraivereid on mitu, saate seadmesse installitud rakenduste puhul soovi korral kasutada värskendatud graafikadraiverit."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Luba kõigi rakenduste puhul"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Graafikadraiveri valimine"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Vaikeseade"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Mängudraiver"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Arendaja draiver"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Süsteemi graafikadraiver"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Rakenduste ühilduvuse muudatused"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Rakenduse ühilduvuse muudatuste lüliti"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Vaikimisi lubatud rakenduste muudatused"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Vaikimisi keelatud rakenduste muudatused"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Rakendusi pole"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Rakenduse ühilduvuse muudatusi saab muuta silutavate rakenduste puhul. Installige silutav rakendus ja proovige uuesti."</string>
    <string name="unsupported_setting_summary" product="default" msgid="1085229417771470172">"Seadet selles telefonis ei toetata"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="7402414129786489664">"Seadet selles tahvelarvutis ei toetata"</string>
    <string name="unsupported_setting_summary" product="device" msgid="3422953459122926833">"Seadet selles seadmes ei toetata"</string>
    <string name="disabled_for_user_setting_summary" msgid="9096036019081828639">"Praegune kasutaja ei saa seadet muuta"</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Oleneb teisest seadest"</string>
    <string name="unknown_unavailability_setting_summary" msgid="9060213910510360231">"Seade pole saadaval"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Konto"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Seadme nimi"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Põhiteave"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Seadused ja määrused"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Seadme üksikasjad"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Seadme identifikaatorid"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"WiFi-seadete juhtimine"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Luba rakendusel juhtida WiFi-t"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Lubage sellel rakendusel WiFi sisse või välja lülitada, otsida WiFi-võrke ja nendega ühendus luua, võrke lisada või eemaldada või luua kohalik kuumkoht"</string>
    <string name="media_output_title" msgid="8283629315159510680">"Meedia esitamise seade:"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Esita rakendust <xliff:g id="LABEL">%s</xliff:g> väljundis"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"See seade"</string>
    <string name="media_output_summary" product="default" msgid="4760338801715262899">"Telefon"</string>
    <string name="media_output_summary" product="tablet" msgid="5138101426462250247">"Tahvelarvuti"</string>
    <string name="media_output_summary" product="device" msgid="3598300438694764381">"Seade"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Pole kõnede ajal saadaval"</string>
    <string name="media_output_summary_unavailable" msgid="2695058965888813093">"Pole saadaval"</string>
    <string name="media_output_group_panel_title" msgid="3086245179062913037">"Lisa väljundid"</string>
    <string name="media_output_group" msgid="7918231774595274396">"Grupp"</string>
    <string name="media_output_group_panel_single_device_summary" msgid="5027884071572180516">"1 seade on valitud"</string>
    <string name="media_output_group_panel_multiple_devices_summary" msgid="4838305763151455248">"<xliff:g id="COUNT">%1$d</xliff:g> seadet on valitud"</string>
    <string name="media_output_switching" msgid="7488216595474868546">"Vahetamine …"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Vasta kõnele seadmes"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Seda APN-i ei saa muuta."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="1525940496459255289">"Parandage tahvelarvuti aku tööiga"</string>
    <string name="battery_suggestion_title" product="device" msgid="2280773774080720377">"Parandage seadme aku tööiga"</string>
    <string name="battery_suggestion_title" product="default" msgid="4811554469047272537">"Parandage telefoni aku tööiga"</string>
    <string name="battery_suggestion_summary" msgid="8186720080540016197"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Helisemise vältimine"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Korraga toitenupu ja helitugevuse suurendamise nupu vajutamine:"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Otsetee helisemise vältimiseks"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibreeri"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Vaigista"</string>
    <string name="prevent_ringing_option_none" msgid="7776676007180834163">"Ära tee midagi"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibreerimine"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Vaigistamine"</string>
    <!-- no translation found for prevent_ringing_option_unavailable_lpp_summary (3193459102328015340) -->
    <skip />
    <string name="pref_title_network_details" msgid="7329759534269363308">"Võrgu üksikasjad"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Teie seadme nimi on teie telefonis olevatele rakendustele nähtav. Bluetooth-seadmetega või WiFi-võrguga ühenduse loomisel või WiFi-kuumkoha seadistamisel võivad seda näha ka teised inimesed."</string>
    <string name="devices_title" msgid="649715719278562515">"Seadmed"</string>
    <string name="homepage_all_settings" msgid="1877827279189801035">"Kõik seaded"</string>
    <string name="homepage_personal_settings" msgid="8312279476519359656">"Soovitused"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Võrgu valimine"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Ühendus on katkestatud"</string>
    <string name="network_connected" msgid="7637745547242487795">"Ühendatud"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Ühendamine …"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Ühendust ei saanud luua"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Võrke ei leitud."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Võrke ei õnnestunud leida. Proovige uuesti."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(keelatud)"</string>
    <string name="no_sim_card" msgid="1497407489810953863">"SIM-kaarti pole"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM-kaart"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"SIM-i pole"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Pole"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Ühendamiseks on vaja SIM-kaarti"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Ühendamiseks on vaja operaatori <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> SIM-kaarti"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Eelistatud võrgurežiim: eelistatud WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Eelistatud võrgurežiim: ainult GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Eelistatud võrgurežiim: ainult WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Eelistatud võrgurežiim: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Eelistatud võrgurežiim: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Eelistatud võrgurežiim: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Eelistatud võrgurežiim: ainult CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Eelistatud võrgurežiim: ainult EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Eelistatud võrgurežiim: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Eelistatud võrgurežiim: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Eelistatud võrgurežiim: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Eelistatud võrgurežiim: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Eelistatud võrgurežiim: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Eelistatud võrgurežiim: üldine"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Eelistatud võrgurežiim: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Eelistatud võrgurežiim: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Eelistatud võrgurežiim: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Eelistatud võrgurežiim: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Eelistatud võrgurežiim: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Eelistatud võrgurežiim: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Eelistatud võrgurežiim: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Eelistatud võrgurežiim: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Eelistatud võrgurežiim: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Eelistatud võrgurežiim: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Eelistatud võrgurežiim: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Eelistatud võrgurežiim: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Eelistatud võrgurežiim: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Eelistatud võrgurežiim: ainult NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Eelistatud võrgurežiim: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Eelistatud võrgurežiim: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Eelistatud võrgurežiim: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Eelistatud võrgurežiim: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Eelistatud võrgurežiim: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Eelistatud võrgurežiim: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (soovitatav)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (soovitatav)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (soovitatav)"</string>
    <string name="label_available" msgid="5305726869955838606">"Saadaolevad võrgud"</string>
    <string name="load_networks_progress" msgid="4717874401621250401">"Otsimine …"</string>
    <string name="register_on_network" msgid="2169662800750709709">"Registreerimine võrgus <xliff:g id="NETWORK">%s</xliff:g> …"</string>
    <string name="not_allowed" msgid="5756935665192962915">"Teie SIM-kaart ei võimalda ühendust selle võrguga."</string>
    <string name="connect_later" msgid="2330538069949281352">"Võrguga ei saa praegu ühendust. Proovige hiljem uuesti."</string>
    <string name="registration_done" msgid="1750434215698850123">"Võrgus registreeritud."</string>
    <string name="select_automatically" msgid="2419752566747259155">"Vali võrk automaatselt"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Operaatori seaded"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Andmesideteenuse seadistamine"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobiilne andmeside"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Andmesideühendus mobiilsidevõrgu abil"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefon aktiveerib levialasse jõudmisel selle operaatori automaatselt"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="3309106501029928951">"Ühtegi SIM-i pole saadaval"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Kõnede eelistus"</string>
    <string name="sms_preference" msgid="7742964962568219351">"SMS-i eelistus"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Küsi iga kord"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Võrgu lisamine"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="5173633860800230925">
      <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="2788950217176988034">"Kõnede puhul vaikeseade"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"SMS-ide puhul vaikeseade"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Kõnede ja SMS-ide puhul vaikeseade"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Mobiilse andmeside puhul vaikeseade"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobiilne andmeside on aktiivne"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobiilne andmeside on väljas"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Saadaval"</string>
    <string name="mobile_network_in_range" msgid="3528320750936028369">"Levialas"</string>
    <string name="mobile_network_not_in_range" msgid="5680896182395366584">"Pole levialas"</string>
    <string name="mobile_network_list_add_more" msgid="4478586073355236604">"Lisa veel"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktiivne / SIM-kaart"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inaktiivne / SIM-kaart"</string>
    <string name="mobile_network_active_esim" msgid="4673190244386572318">"Aktiivne / allalaaditud SIM"</string>
    <string name="mobile_network_inactive_esim" msgid="2901035056727849007">"Inaktiivne / allalaaditud SIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"SIMi nimi ja värv"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Nimi"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Värv (kasutavad ühilduvad rakendused)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Salvesta"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Kasuta SIMi"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Väljas"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Selle SIM-i keelamiseks eemaldage SIM-kaart"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Puudutage operaatori <xliff:g id="CARRIER">%1$s</xliff:g> aktiveerimiseks"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="2762744961192218789">"Kas soovite aktiveerida operaatori <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="8168680839542031781">"Korraga saab aktiivne olla vaid üks allalaaditud SIM.\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="8695772737522378095">"Aktiveeri <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Kustuta SIM-kaart"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="6680959559589234726">"SIM-kaarti ei saa kustutada"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6401922869095572710">"Seda SIM-kaarti ei saa vea tõttu kustutada.\n\nTaaskäivitage seade ja proovige uuesti."</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Eelistatud võrgutüüp"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Võrgu töörežiimi muutmine"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Eelistatud võrgutüüp"</string>
    <string name="carrier_settings_euicc" msgid="1541279297111378907">"Operaator"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Operaatori seadete versioon"</string>
    <string name="call_category" msgid="641461844504128789">"Helistamine"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Operaatori videokõne"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Süsteemi valimine"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"CDMA-rändlusrežiimi muutmine"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Süsteemi valimine"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Võrk"</string>
    <string name="network_select_title" msgid="4532395144000206685">"Võrk"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA-tellimus"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"RUIM/SIM-i ja NV vahetamine"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"tellimus"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automaatne registreerimine …"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Kas lubada andmesiderändlus?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Hinnakirja küsige oma võrguteenuse pakkujalt."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Rakenduste andmekasutus"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Võrgu režiim <xliff:g id="NETWORKMODEID">%1$d</xliff:g> on sobimatu. Eirake seda."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Pääsupunktide nimed"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Pole saadaval, kui on ühendus on loodud operaatoriga <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Kuva rohkem"</string>
    <string name="see_less" msgid="2642392725363552793">"Kuva vähem"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Kas lülitada operaator <xliff:g id="CARRIER_NAME">%1$s</xliff:g> sisse?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Kas lülitada SIM-kaart sisse?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Kas soovite aktiveerida operaatori <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Kas aktiveerida SIM-kaardi kasutamine?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Korraga saab aktiivne olla vaid üks SIM.\n\nOperaatori <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> aktiveerimisel ei tühistata operaatori <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> teenust."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="1396320209544698027">"Korraga saab aktiivne olla vaid üks allalaaditud SIM.\n\nOperaatori <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> aktiveerimisel ei tühistata operaatori <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> teenust."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Korraga saab aktiivne olla vaid üks SIM.\n\nAktiveerimine ei tühista operaatori <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> teenust."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Aktiveeri operaator <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Võrguga ühendamine …"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="8341013572582875574">"Operaatori <xliff:g id="CARRIER_NAME">%1$s</xliff:g> aktiveerimine"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Operaatorit ei saa vahetada"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Operaatorit ei saa vea tõttu vahetada."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Kas lülitada <xliff:g id="CARRIER_NAME">%1$s</xliff:g> välja?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Kas lülitada SIM-kaart välja?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"SIM-kaardi väljalülitamine <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Operaatorit ei saa keelata"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Midagi läks valesti ja teie operaatorit ei saanud keelata."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Kas kasutada kahte SIMi?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Selles seadmes saavad korraga aktiivsed olla kaks SIMi. Korraga ühe SIMi kasutamise jätkamiseks puudutage valikut „Tänan, ei”."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Kas soovite seadme taaskäivitada?"</string>
    <string name="sim_action_restart_text" msgid="8019300474703571013">"Alustamiseks taaskäivitage oma seade. Seejärel lisage veel üks SIM-kaart."</string>
    <string name="sim_action_continue" msgid="1688813133152389943">"Jätka"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Jah"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Taaskäivita"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Tänan, ei"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Vaheta"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"SIM-kaarti ei saa aktiveerida"</string>
    <string name="dsds_activation_failure_body_msg1" msgid="6303921196869256391">"Eemaldage SIM-kaart ja sisestage uuesti. Kui probleem jätkub, taaskäivitage seade."</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Lülitage SIM-kaart uuesti sisse. Kui probleem jätkub, taaskäivitage seade."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Võrgu aktiveerimine"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Operaatori vahetamine"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> on aktiivne"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Puudutage SIM-kaardi seadete värskendamiseks"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Lülituti operaatorile <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Lülituti teisele operaatorile"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Teie mobiilsidevõrku on muudetud"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Teise SIM-kaardi seadistamine"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Valige aktiivne SIM-kaart või kasutage korraga kahte SIM-kaarti"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Kasutatava numbri valimine"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Selles seadmes on saadaval 1 number, kuid korraga saab kasutada vaid üht}=2{Selles seadmes on saadaval 2 numbrit, kuid korraga saab kasutada vaid üht}other{Selles seadmes on saadaval # numbrit, kuid korraga saab kasutada vaid üht}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Aktiveerimine <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Praegu ei saa aktiveerida"</string>
    <string name="choose_sim_item_summary_unknown" msgid="7854314795485227568">"Tundmatu number"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Kas kasutada operaatorit <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"Mobiilse andmeside, kõnede ja SMS-ide jaoks kasutatakse operaatorit <xliff:g id="CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Aktiivseid SIMe pole saadaval"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Avage oma võrguseaded, et hiljem mobiilset andmesidet, kõnefunktsioone ja SMS-e kasutada."</string>
    <string name="sim_card_label" msgid="5632157635124050923">"SIM-kaart"</string>
    <string name="erase_sim_dialog_title" msgid="881253002169177016">"Kas soovite allalaaditud SIMi kustutada?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"SIMi kustutamisel eemaldatakse seadmest operaatori <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> teenus.\n\nOperaatori <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> teenust ei tühistata."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Kustuta"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"SIM-kaardi kustutamine …"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"SIM-kaarti ei saa kustutada"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Seda SIM-kaarti ei saa vea tõttu kustutada.\n\nTaaskäivitage seade ja proovige uuesti."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Seadmega ühendamine"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Rakendus <xliff:g id="APPNAME">%1$s</xliff:g> soovib kasutada ajutist WiFi-võrku, et teie seadmega ühendus luua"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Seadmeid ei leitud. Veenduge, et seadmed oleksid sisse lülitatud ja ühendamiseks saadaval."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Proovi uuesti"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Midagi tuli vahele. Rakendus tühistas seadme valimise taotluse."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Ühendamine õnnestus"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Ühendamine ebaõnnestus"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Kuva kõik"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Seadme otsimine …"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Seadmega ühendamine …"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Vasak"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Parem"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Ümbris"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Seadete paneel"</string>
    <string name="internet_connectivity_panel_title" msgid="2044237561024730108">"Interneti ühenduvus"</string>
    <string name="volume_connectivity_panel_title" msgid="8772438444782726321">"Helitugevus"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="6067959496888990983">"Ei ole lennukirežiimis saadaval"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Töölauarežiimi jõustamine"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Katselise töölauarežiimi jõustamine teisestel ekraanidel"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Luba fikseeritud suurus mitmes aknas"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Lubab fikseeritud suurusega rakenduste kuvamise mitmes aknas"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Funktsiooni Sunnitud tume alistamine"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Alistab alaliselt sisselülitatud funktsiooni Sunnitud tume"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privaatsus"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Load, kontotegevused, isiklikud andmed"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Eemalda"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Säilita"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Kas eemaldada see soovitus?"</string>
    <string name="contextual_card_removed_message" msgid="5755438207494260867">"Soovitus on eemaldatud"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="5200381837316691406">"Võta tagasi"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Mäluruumi on vähe. <xliff:g id="PERCENTAGE">%1$s</xliff:g> kasutusel / <xliff:g id="FREE_SPACE">%2$s</xliff:g> vaba"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Saada tagasisidet"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Kas soovite selle soovituse kohta tagasisidet anda?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> on lõikelauale kopeeritud."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="permission_bar_chart_empty_text" msgid="4856719891991325077">"0 rakendust kasutasid lube"</string>
    <string name="permission_bar_chart_title" msgid="2493212904955611441">"Lubade kasutus viimase 24 tunni jooksul"</string>
    <string name="permission_bar_chart_details" msgid="5816698018592357088">"Kuva kõik juhtpaneelil"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="4853396794340896078">
      <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="9190967143518779145">"Juurdepääsetavuse kasutus"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="6910643986958263005">
      <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="media_output_panel_title" msgid="5920946795078065159">"Väljundi vahetamine"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="6998758947764222915">"Praegu seadmes <xliff:g id="DEVICE_NAME">%1$s</xliff:g> esitamisel"</string>
    <string name="media_output_disconnected_status" msgid="5567111639832431865">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> (pole ühendatud)"</string>
    <string name="media_output_switch_error_text" msgid="603563475910236831">"Ei saa lülitada. Puudutage, et uuesti proovida."</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Oluline teave"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"JÄTKA"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"EI, TÄNAN"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Asukoht"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="2799241640320172899">"Teenusepakkuja võib selle teenuse pakkumiseks koguda teie asukohateavet.\n\nVaadake oma teenusepakkuja privaatsuseeskirju."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Järelejäänud aeg või andmemaht võib kaotsi minna. Enne eemaldamist pidage nõu operaatoriga."</string>
    <string name="keywords_content_capture" msgid="7802155522681936956">"sisu jäädvustamine, rakenduse sisu"</string>
    <string name="content_capture" msgid="868372905432812238">"Rakenduse sisu"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Luba rakendustel Android-süsteemile sisu saata"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Süsteemi mälutõmmise jäädvustamine"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Süsteemi mälutõmmise jäädvustamine"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Süsteemi mälutõmmist ei saanud jäädvustada"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Jäädvusta süsteemi mälutõmmised automaatselt"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Jäädvusta mälutõmmis automaatselt, kui Androidi süsteem kasutab liiga palju mälu"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Katkesta ühendus"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Hädaabikõned"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Teie operaator ei toeta hädaabikõnesid WiFi-kõnede kaudu.\nSeade lülitub hädaabikõne tegemiseks automaatselt mobiilsidevõrgule.\nHädaabikõned on võimalikud ainult mobiilsidevõrgu levialas."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Kvaliteedi parandamiseks kasutage kõnede puhul WiFi-t"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Helistamise varuviis"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Kui <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> pole rändluseks saadaval, kasutage operaatori <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g> kõnede puhul mobiilse andmeside SIM-kaarti."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"helistamise varuviis"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Sissetulev MMS-sõnum"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"MMS-i ei saa saata"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Puudutage, et lubada MMS-sõnumside operaatori <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> võrgus, kui mobiilne andmeside on välja lülitatud"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS-sõnum"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Probleem SIM-kombinatsiooniga"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Operaatorite <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> kasutamine võib piirata funktsionaalsust. Puudutage lisateabe saamiseks."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM-kombinatsioon"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Teie tööeeskirjade teave"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Seadeid haldab teie IT-administraator"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Veaaruannete töötleja"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Määrab, milline rakendus kasutab teie seadmes veaaruannete otseteed."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Isiklik"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Töö"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Süsteemi vaikeseade"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"See valik ei kehti enam. Proovige uuesti."</string>
    <string name="quick_controls_lower" msgid="6675573610027367819">"seadmete juhikud"</string>
    <string name="cards_passes_sentence" msgid="1866311782387946944">"Kaardid ja pääsmed"</string>
    <string name="cards_passes_lower" msgid="2429722007109957877">"kaardid ja pääsmed"</string>
    <string name="power_menu_setting_name" msgid="7291642927216934159">"Vajutage pikalt toitenuppu"</string>
    <string name="power_menu_summary_long_press_for_assist_enabled" msgid="5322150755041458952">"Pikalt vajutamisega avatakse assistent"</string>
    <string name="power_menu_summary_long_press_for_assist_disabled_with_power_menu" msgid="5165714995895517816">"Pikalt vajutamisega kuvatakse menüü Toide"</string>
    <string name="power_menu_summary_long_press_for_assist_disabled_no_action" msgid="2831598484771657432">"Pikalt vajutamine on keelatud"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Kasutamiseks määrake kõigepealt ekraanilukk"</string>
    <string name="power_menu_long_press_for_assist" msgid="2016813721240777737">"Hoidmine assistendi avamiseks"</string>
    <string name="power_menu_long_press_for_assist_summary" msgid="8251928804984560312">"Assistent aktiveeritakse toitenupu allhoidmisel"</string>
    <string name="power_menu_power_volume_up_hint" msgid="1733051433583045623">"Menüüd Toide ja Hädaolukord:\nvajutage samal ajal toitenuppu ja helitugevuse suurendamise nuppu."</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="5786494894009727654">"Helisemise vältimine:\notsetee asub helitugevuse menüüs."</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Kuva rahakott"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="5388868513484652431">"Rahakotile juurdepääsu lubamine lukustuskuvalt ja kiirseadetest"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Kuva seadmete juhtimisvidinad"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="6952176547084269909">"Juurdepääs juhtimisvidinatele, kui seade on lukustatud"</string>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="media_output_panel_stop_casting_button" msgid="6094875883164119035">"Peata ülekandmine"</string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Kas lülitada VoLTE välja?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"See lülitab välja ka teie 5G-ühenduse.\nTe ei saa häälkõne ajal internetti kasutada ja mõni rakendus ei pruugi töötada."</string>
    <string name="no_5g_in_dsds_text" product="default" msgid="772747677303920132">"Kui kasutate kaht SIM-kaarti, saab see telefon kasutada ainult 4G-võrku. "<annotation id="url">"Lisateave"</annotation></string>
    <string name="no_5g_in_dsds_text" product="tablet" msgid="4757328474425714624">"Kui kasutate kaht SIM-kaarti, saab see tahvelarvuti kasutada ainult 4G-võrku. "<annotation id="url">"Lisateave"</annotation></string>
    <string name="no_5g_in_dsds_text" product="device" msgid="6983783505032683314">"Kui kasutate kaht SIM-kaarti, saab see seade kasutada ainult 4G-võrku. "<annotation id="url">"Lisateave"</annotation></string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Vahemälus olevate rakenduste täitmise peatamine"</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Luba Seadetes ekraani ülekatted"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Lubage rakendustel, mida tohib kuvada teiste rakenduste peal, katta Seadete ekraanikuvasid"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Meedia"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Meediapleieri kinnitamine"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Kiirelt taasesituse jätkamiseks jääb meediapleier kiirseadetes avatuks"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Kuva meediasoovitusi"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Teie tegevuse põhjal"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Peida pleier"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Kuva pleier"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"meedia"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth lülitub sisse"</string>
    <string name="bluetooth_setting_on" msgid="4808458394436224124">"Sees"</string>
    <string name="bluetooth_setting_off" msgid="4965493913199554789">"Väljas"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM-id"</string>
    <string name="wifi_switch_summary" msgid="3577154777754849024">"WiFi-võrkude otsimine ja nendega ühenduse loomine"</string>
    <string name="keywords_airplane_safe_networks" msgid="5902708537892978245">"lennuk, lennukikindel"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Kõned ja SMS-id"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"WiFi-kõned"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Helistamine WiFi kaudu"</string>
    <string name="calls_sms_footnote" msgid="1003530944232362815">"WiFi-kõnede puhul toimub helistamine operaatoriväliste WiFi-võrkude kaudu. "<annotation id="url">"Lisateave"</annotation></string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Kõned"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"eelistatud"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"eelistatud kõnede puhul"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"eelistatud SMS-ide puhul"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"pole saadaval"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Pole ajutiselt saadaval"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"SIM-i pole"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Võrgueelistused"</string>
    <string name="network_and_internet_preferences_summary" msgid="613207494152304537">"Ühenda avalike võrkudega"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"võrguühendus, internet, juhtmeta, andmeside, wifi, wi-fi, wi fi, mobiilside, mobiilsideoperaator, 4g, 3g, 2g, lte"</string>
    <string name="turn_on_wifi" msgid="4868116014727533668">"Lülita WiFi sisse"</string>
    <string name="turn_off_wifi" msgid="8861028501067400694">"Lülita WiFi välja"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Kas lähtestada internetiühendus?"</string>
    <string name="reset_internet_text" product="default" msgid="8797910368942544453">"See lõpetab teie telefonikõne"</string>
    <string name="reset_internet_text" product="tablet" msgid="8797910368942544453">"See lõpetab teie telefonikõne"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Internetiühenduse lähtestamine …"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Ühenduvuse parandamine"</string>
    <string name="networks_available" msgid="3299512933684383474">"Võrgud on saadaval"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Võrkude vahetamiseks katkestage Etherneti-ühendus"</string>
    <string name="wifi_is_off" msgid="8308136482502734453">"WiFi on välja lülitatud"</string>
    <string name="tap_a_network_to_connect" msgid="8044777400224037875">"Puudutage ühendamiseks võrku"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+ ühendused"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Luba Google Fil kasutada W+ võrke, et kiirust ja katvust parandada"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+ võrk"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM-kaart"</string>
    <string name="downloaded_sim_category_title" msgid="8611467223348446658">"ALLALAADITUD SIM-KAART"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Aktiivne"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Mitteaktiivne"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Vaikimisi üksuse <xliff:g id="ID_1">%1$s</xliff:g> puhul"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"kõned"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobiilne andmeside"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Ühendatud"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Ühendus puudub"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobiilset andmesideühendust ei looda automaatselt"</string>
    <string name="non_carrier_network_unavailable" msgid="9031567407964127997">"Ühtegi muud võrku pole saadaval"</string>
    <string name="all_network_unavailable" msgid="1163897808282057496">"Ühtegi võrku pole saadaval"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Kas lülitada mobiilne andmeside välja?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Pärast seda pole teil operaatori <xliff:g id="CARRIER">%s</xliff:g> kaudu juurdepääsu andmesidele ega internetile. Internet on saadaval ainult WiFi kaudu."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"teie operaator"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Pole saadaval, kuna uneaja režiim on sisse lülitatud"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Märguande olulisuse lähtestamine viidi lõpule."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Rakendused"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Seade soovib saada juurdepääsu teie sõnumitele. Puudutage üksikasjade nägemiseks."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Kas lubada juurdepääs sõnumitele?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Bluetooth-seade <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib saada juurdepääsu teie sõnumitele.\n\nTe pole seadmega <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> varem ühendust loonud."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Seade soovib juurdepääsu teie kontaktidele ja kõnelogile. Puudutage üksikasjade nägemiseks."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Kas lubada juurdepääs kontaktidele ja kõnelogile?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Bluetooth-seade <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib juurdepääsu teie kontaktidele ja kõnelogile. See hõlmab andmeid sissetulevate ja väljuvate kõnede kohta.\n\nTe pole seadmega <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> varem ühendust loonud."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Eredus"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Ekraanikuva lukustamine"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Ilme"</string>
    <string name="category_name_color" msgid="937514550918977151">"Värv"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Muud ekraanikuva juhtelemendid"</string>
    <string name="category_name_others" msgid="2366006298768550310">"Muud"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Üldine"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Tumeda teema kasutamine"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Bluetoothi kasutamine"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Helisemise vältimise kasutamine"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"WiFi-kuumkoha kasutamine"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Rakenduse kinnitamise kasutamine"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Arendaja valikute kasutamine"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Printimisteenuse kasutamine"</string>
    <string name="multiple_users_main_switch_title" msgid="2759849884417772712">"Mitme kasutaja kasutamine"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Juhtmevaba silumise kasutamine"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Graafikadraiveri eelistuste kasutamine"</string>
    <string name="battery_saver_main_switch_title" msgid="5072135547489779352">"Akusäästja kasutamine"</string>
    <string name="do_not_disturb_main_switch_title_on" msgid="6965566556539821313">"Lülita kohe välja"</string>
    <string name="do_not_disturb_main_switch_title_off" msgid="7088088515823752545">"Lülita kohe sisse"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Öövalguse kasutamine"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"NFC kasutamine"</string>
    <string name="adaptive_battery_main_switch_title" msgid="3127477920505485813">"Kohanduva akuhalduri kasutamine"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Kohanduva ereduse kasutamine"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"WiFi-kõnede kasutamine"</string>
    <string name="screen_saver_main_switch_title" msgid="256530705774121595">"Ekraanisäästja kasutamine"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Kuva kõik rakendused"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Nutikas suunamine"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Nutikas suunamine on lubatud"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Nutikas suunamine on keelatud"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Kõne seaded"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Seadete värskendamine …"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Kõneseadete viga"</string>
    <string name="smart_forwarding_failed_text" msgid="5370431503707373653">"Võrgu või SIM-kaardi viga."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM-kaart pole aktiveeritud."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Sisestage telefoninumbrid"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Sisestage telefoninumber"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Telefoninumber puudub."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Luba 2G"</string>
    <string name="enable_2g_summary" msgid="906487478332145407">"Kasutage mobiilset 2G-andmesidet. Hädaabikõnede jaoks on 2G alati sisse lülitatud."</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Kuva juurdepääs lõikelauale"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Kui rakendused pääsevad juurde kopeeritud tekstile, piltidele või muule sisule, kuvatakse teade"</string>
    <string name="all_apps" msgid="3054120149509114789">"Kõik rakendused"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Ära luba"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ülilairibaühendus"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Aitab tuvastada läheduses olevate ülilairibaühendust kasutavate seadmete suhtelist asukohta"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Ülilairibaühenduse kasutamiseks lülitage lennukirežiim välja."</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Juurdepääs kaamerale"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Juurdepääs mikrofonile"</string>
    <string name="sensor_toggle_description" msgid="8248823248606795411">"Kõikide rakenduste ja teenuste jaoks"</string>
    <string name="game_settings_title" msgid="1028178627743422090">"Mängude seaded"</string>
    <string name="game_settings_summary" msgid="2548056479103747555">"Mängu juhtpaneeli otsetee sisselülitamine jm"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="5217037846900908318">"SIM-kaardile juurdepääsu taotlus"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="6759306429895300286">"Seade soovib teie SIM-kaardile juurde pääseda. Puudutage üksikasjade nägemiseks."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="4486768729352090174">"Kas lubada juurdepääs SIM-kaardile?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="4153857191661567190">"Bluetooth-seade <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib teie SIM-kaardi andmetele juurde pääseda. Need andmed hõlmavad teie kontakte.\n\nKui seade <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> on ühendatud, saab sellega vastu võtta kõik kõned, mis tehakse numbrile <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Bluetooth-seade on saadaval"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Seade soovib ühendust luua. Puudutage üksikasjade nägemiseks."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Kas ühendada Bluetooth-seadmega?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> soovib selle telefoniga ühendust luua.\n\nTe pole seadmega <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> varem ühendust loonud."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Ära ühenda"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Ühenda"</string>
</resources>
