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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="4676390750360727396">"Da"</string>
    <string name="no" msgid="6731231425810196216">"Ne"</string>
    <string name="create" msgid="3578857613172647409">"Ustvari"</string>
    <string name="allow" msgid="3349662621170855910">"Dovoli"</string>
    <string name="deny" msgid="6947806159746484865">"Zavrni"</string>
    <string name="dlg_close" msgid="7471087791340790015">"Zapri"</string>
    <string name="dlg_switch" msgid="6243971420240639064">"Preklopi"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Neznano"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="one"><xliff:g id="STEP_COUNT_1">%1$d</xliff:g> korak vas loči od tega, da postanete razvijalec.</item>
      <item quantity="two"><xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraka vas ločita od tega, da postanete razvijalec.</item>
      <item quantity="few"><xliff:g id="STEP_COUNT_1">%1$d</xliff:g> koraki vas ločijo od tega, da postanete razvijalec.</item>
      <item quantity="other"><xliff:g id="STEP_COUNT_1">%1$d</xliff:g> korakov vas loči od tega, da postanete razvijalec.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"Zdaj ste razvijalec."</string>
    <string name="show_dev_already" msgid="2151632240145446227">"Ni treba, ker ste že razvijalec."</string>
    <string name="dev_settings_disabled_warning" msgid="4909448907673974370">"Najprej omogočite možnosti za razvijalce."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Brezžično in omrežja"</string>
    <string name="header_category_connections" msgid="6471513040815680662">"Povezave"</string>
    <string name="header_category_device" msgid="4544026001618307754">"Naprava"</string>
    <string name="header_category_personal" msgid="3310195187905720823">"Osebno"</string>
    <string name="header_category_access" msgid="7580499097416970962">"Dostop"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Sistem"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Omogočanje podatkovne povezave"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Onemogočanje podatkovne povezave"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"Pripravljeno za uporabo tehnologije VoLTE"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Videoklicanje je pripravljeno"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"Klicanje prek Wi-Fi-ja je pripravljeno"</string>
    <string name="eab_provisioned_switch_string" msgid="3482272907448592975">"EAB/prisotnost omogočena"</string>
    <string name="radio_info_radio_power" msgid="7187666084867419643">"Moč radia mobilne naprave"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"Prikaži imenik na kartici SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Prikaži številke za zaporo odhodnih klicev"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Prikaži številke za klicanje storitev"</string>
    <string name="radioInfo_menu_getIMS" msgid="185171476413967831">"Stanje storitve IMS"</string>
    <string name="radio_info_ims_reg_status_title" msgid="16971785902696970">"Stanje storitve IMS"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="5614116179751126247">"Registrirana"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="4438054067642750717">"Ni registrirana"</string>
    <string name="radio_info_ims_feature_status_available" msgid="3687807290327566879">"Na voljo"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="4606182208970114368">"Ni na voljo"</string>
    <string name="radio_info_ims_reg_status" msgid="7534612158445529715">"Registracija storitve IMS: <xliff:g id="STATUS">%1$s</xliff:g>\nGovor prek povezave LTE: <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nGovor prek povezave WiFi: <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nVideoklici: <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nVmesnik UT: <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"V uporabi"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Ne deluje"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Samo klici v sili"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Radio je izklopljen"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Gostovanje"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Ni gostovanja"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Nedejaven"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Zvonjenje"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Aktivni klic"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Prekinjena povezava"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Vzpostavljanje povezave"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Povezava je vzpostavljena"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Začasno ustavljeno"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"Neznano"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"pkts"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bajtov"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Izpni pomnilnik USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Izpni kartico SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Izbriši pomnilnik USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Izbriši kartico SD"</string>
    <string name="preview_pager_content_description" msgid="8926235999291761243">"Predogled"</string>
    <string name="preview_page_indicator_content_description" msgid="4821343428913401264">"Predogled, <xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. stran od <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="font_size_summary" msgid="1690992332887488183">"Pomanjšava ali povečava besedila na zaslonu"</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Pomanjšanje"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Povečanje"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Vzorčno besedilo"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"Čudoviti čarovnik iz Oza"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"11. poglavje: Čudovito Smaragdno mesto"</string>
    <string name="font_size_preview_text_body" msgid="2846183528684496723">"Četudi so jim oči varovala zelena očala, je Dorotejo in prijatelje sprva zaslepil sij čudovitega Smaragdnega mesta. Na ulicah so se vrstile prekrasne hiše iz zelenega marmorja, na vseh koncih podprte s sijočimi smaragdi. Hodili so po pločniku iz plošč iz enakega zelenega marmorja, katerih stike so krasile vrste tesno položenih in v soncu lesketajočih se smaragdov. Okenske šipe so bile iz zelenega stekla; celo nebo nad Smaragdnim mestom je bilo obarvano zelenkasto in sončni žarki so bili zelene barve. \n\nPo ulicah se je sprehajalo veliko ljudi, moški, ženske in otroci. Vsi so nosili zelena oblačila in imeli so zelenkasto polt. Dorotejo in njeno nenavadno spremstvo so gledali z začudenimi očmi – vsi otroci so stekli proč in se skrili za svoje mame, ko so zagledali Leva –, ampak spregovoril ni z njimi nihče niti besede. Na ulici so stale številne prodajalne in Doroteja je opazila, da je bilo v njih vse zeleno. Naprodaj so imele zelene sladkarije in zeleno pokovko, pa zelene čevlje, zelene klobuke in zelena oblačila vseh vrst prav tako. V eni od njih je možak prodajal zeleno limonado in Doroteja je videla, da so otroci plačevali zanjo z zelenimi novci. \n\nNi bilo videti konjev ali živali drugih vrst; ljudje so prenašali stvari naokrog v majhnih zelenih vozičkih, ki so jih potiskali pred seboj. Vsi so se zdeli veseli, zadovoljni in uspešni."</string>
    <string name="font_size_save" msgid="3450855718056759095">"V redu"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Pomnilnik USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Kartica SD"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"Vidno vsem napravam Bluetooth v bližini (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="2849387702249327748">"Vidno vsem napravam Bluetooth v bližini"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"Ni vidno drugim napravam Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Vidno samo seznanjenim napravam"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Časovna omejitev vidnosti"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Zakleni glasovno klicanje"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Prepreči uporabo telefona Bluetooth, kadar je zaslon zaklenjen"</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Naprave Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Ime naprave"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Nastavitve naprave"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Nastavitve profila"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"Ime ni nastavljeno, uporablja se ime računa"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Išči naprave"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Preimenuj to napravo"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Preimenuj"</string>
    <string name="bluetooth_disconnect_title" msgid="7830252930348734303">"Prekinitev povezave z napravo?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="8208712728668714199">"Povezava telefona z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo prekinjena."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="6611038575213485336">"Povezava tabličnega računalnika z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo prekinjena."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="3995834526315103965">"Povezava vaše naprave z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo prekinjena."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="3308586619539119106">"Prekini povezavo"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Nimate dovoljenja za spreminjanje nastavitev za Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="7429413067477968637">"Seznanitev nove naprave"</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je vidna napravam v bližini, ko so odprte nastavitve za Bluetooth."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="1109366350000220283">"Naslov Bluetooth telefona: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="6807634484499166486">"Naslov Bluetooth tabličnega računalnika: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="8413944740341742061">"Naslov Bluetooth naprave: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"Ali želite prekiniti povezavo z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Oddajanje"</string>
    <string name="bluetooth_disable_profile_title" msgid="5916643979709342557">"Želite onemogočiti profil?"</string>
    <string name="bluetooth_disable_profile_message" msgid="2895844842011809904">"S tem boste onemogočili:&lt;br&gt;&lt;b&gt;<xliff:g id="PROFILE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;From:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_unknown" msgid="644716244548801421"></string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Neimenovana naprava Bluetooth"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Iskanje"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"V bližini ni naprav Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Zahteva za seznanitev Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Zahteva za seznanitev"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Dotaknite se, če želite opraviti seznanitev z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="3144149432555230410">"Prejete datoteke"</string>
    <string name="device_picker" msgid="4978696506172252813">"Izberite napravo Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="3387222809404177525">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi vklopiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="5890386255790160573">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi izklopiti Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="1644353686104482763">"Aplikacija želi vklopiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="9218830122674868548">"Aplikacija želi izklopiti Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4791779658660357386">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi omogočiti, da bodo lahko druge naprave Bluetooth videle vaš tablični računalnik za toliko sekund: <xliff:g id="TIMEOUT">%2$d</xliff:g>."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="1308225382575535366">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi omogočiti, da bodo lahko druge naprave Bluetooth videle vaš telefon za toliko sekund: <xliff:g id="TIMEOUT">%2$d</xliff:g>."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="225715443477752935">"Aplikacija želi omogočiti, da bodo lahko druge naprave Bluetooth videle vaš tablični računalnik za toliko sekund: <xliff:g id="TIMEOUT">%1$d</xliff:g>."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="4949152735544109994">"Aplikacija želi omogočiti, da bodo lahko druge naprave Bluetooth videle vaš telefon za toliko sekund: <xliff:g id="TIMEOUT">%1$d</xliff:g>."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="8528329166577187961">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi omogočiti, da bodo lahko druge naprave Bluetooth videle vaš tablični računalnik. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="4398738575307583138">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi omogočiti, da bodo lahko druge naprave Bluetooth videle vaš telefon. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="1702590641426207062">"Aplikacija želi omogočiti, da bodo lahko druge naprave Bluetooth videle vaš tablični računalnik. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="8549952177383992238">"Aplikacija želi omogočiti, da bodo lahko druge naprave Bluetooth videle vaš telefon. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="1141843490422565755">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi vklopiti Bluetooth in omogočiti, da bodo lahko druge naprave Bluetooth videle vaš tablični računalnik za toliko sekund: <xliff:g id="TIMEOUT">%2$d</xliff:g>."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="5195836980079191473">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi vklopiti Bluetooth in omogočiti, da bodo lahko druge naprave Bluetooth videle vaš telefon za toliko sekund: <xliff:g id="TIMEOUT">%2$d</xliff:g>."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="7009338445281693765">"Aplikacija želi vklopiti Bluetooth in omogočiti, da bodo lahko druge naprave videle vaš tablični računalnik za toliko sekund: <xliff:g id="TIMEOUT">%1$d</xliff:g>."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="8386904242279878734">"Aplikacija želi vklopiti Bluetooth in omogočiti, da bodo lahko druge naprave videle vaš telefon za toliko sekund: <xliff:g id="TIMEOUT">%1$d</xliff:g>."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="2279471426575892686">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi vklopiti Bluetooth in omogočiti, da bodo lahko druge naprave videle vaš tablični računalnik. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="6961969825475461450">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi vklopiti Bluetooth in omogočiti, da bodo lahko druge naprave videle vaš telefon. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="692477613671555006">"Aplikacija želi vklopiti Bluetooth in omogočiti, da bodo lahko druge naprave videle vaš tablični računalnik. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="6374480121751597648">"Aplikacija želi vklopiti Bluetooth in omogočiti, da bodo lahko druge naprave videle vaš telefon. To lahko pozneje spremenite v nastavitvah za Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="4850574877288036646">"Vklop Bluetootha…"</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"Izklop Bluetootha…"</string>
    <string name="bluetooth_auto_connect" msgid="40711424456733571">"Samodejno poveži"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Zahteva za povezavo Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3603316575471431846">"Dotaknite se, če želite vzpostaviti povezavo z napravo »<xliff:g id="DEVICE_NAME">%1$s</xliff:g>«."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"Se želite povezati z napravo »<xliff:g id="DEVICE_NAME">%1$s</xliff:g>«?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Zahteva za dostop do telefonskega imenika"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="8930347091018455505">"Naprava <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi dostop do stikov in zgodovine klicev. Ali želite omogočiti dostop napravi <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>?"</string>
    <string name="bluetooth_remember_choice" msgid="6919682671787049800">"Ne vprašaj me več"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"Ne vprašaj me več"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Zahteva za dostop do sporočil"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s želi dostopati do vaših sporočil. Želite omogočiti dostop za %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Zahteva za dostop do kartice SIM"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi dostopati do vaše kartice SIM. Z omogočanjem dostopa do kartice SIM bodo v napravi za čas trajanja povezave onemogočene podatkovne povezave. Omogočite dostop za <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>"</string>
    <string name="bluetooth_device_name_summary" msgid="522235742194965734">"Drugim napravam vidno kot »<xliff:g id="DEVICE_NAME">^1</xliff:g>«"</string>
    <string name="bluetooth_off_footer" msgid="8406865700572772936">"Za povezavo z drugimi napravami vklopite Bluetooth."</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Vaše naprave"</string>
    <string name="bluetooth_pairing_page_title" msgid="7712127387361962608">"Seznanitev nove naprave"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3520035819421024105">"Omogočite tabličnemu računalniku, da komunicira z napravami Bluetooth v bližini"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2205100629387332862">"Omogočite napravi, da komunicira z napravami Bluetooth v bližini"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="782032074675157079">"Omogočite telefonu, da komunicira z napravami Bluetooth v bližini"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="4936610906348223810">"Onemogoči prelaganje s strojne opreme za A2DP za Bluetooth"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="4340101417209145308">"Vnovični zagon?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8827019472003234568">"Če želite spremeniti to nastavitev, znova zaženite napravo."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="2053793518537051975">"Nov zagon"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="2382443064737856652">"Prekliči"</string>
    <string name="connected_device_available_media_title" msgid="2560067541413280645">"Razpoložljive naprave za predvajanje predstavnosti"</string>
    <string name="connected_device_available_call_title" msgid="697154660967595684">"Razpoložljive naprave za klice"</string>
    <string name="connected_device_connected_title" msgid="5871712271201945606">"Trenutno povezano"</string>
    <string name="connected_device_saved_title" msgid="688364359746674536">"Shranjene naprave"</string>
    <string name="connected_device_add_device_title" msgid="7803521577708810621">"Dodajanje naprave"</string>
    <string name="connected_device_add_device_summary" msgid="4041865900298680338">"Bluetooth bo vklopljen, da bo omogočeno seznanjanje"</string>
    <string name="connected_device_connections_title" msgid="5988939345181466770">"Nastavitve povezave"</string>
    <string name="connected_device_previously_connected_title" msgid="491765792822244604">"Predhodno povezane naprave"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Datum in ura"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Izberite časovni pas"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Pošlji <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Začni <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Račun:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Strežnik proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Počisti"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Vrata strežnika proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Obidi strežnik proxy za"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Ponastavi na privzeto"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Končano"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Gostiteljsko ime strežnika proxy"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Pozor"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"V redu"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"Ime gostitelja, ki ste ga vtipkali, ni veljavno."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"Seznam izključitev, ki ste ga vnesli, ni pravilno oblikovan. Domene na seznamu morajo biti ločene z vejico."</string>
    <string name="proxy_error_empty_port" msgid="5539106187558215246">"Izpolniti morate polje vrat."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"Če je polje za gostitelja prazno, mora biti prazno tudi polje za vrata."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"Vtipkana številka vrat je neveljavna."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"Proxy HTTP lahko uporablja brskalnik, druge aplikacije pa ne."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL datoteke PAC: "</string>
    <string name="radio_info_subid" msgid="204582608052503412">"Trenutni ID naročnine:"</string>
    <string name="radio_info_dds" msgid="5471937791273237508">"ID naročnine privzete kartice SIM za prenos podatkov:"</string>
    <string name="radio_info_dl_kbps" msgid="6894556071523815984">"Pasovna širina za prenos (kbps):"</string>
    <string name="radio_info_ul_kbps" msgid="946464073571185678">"Pasovna širina za nalaganje (kbps):"</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Podatki o lokaciji celice (zastarelo):"</string>
    <string name="radio_info_phy_chan_config" msgid="7133247058801474028">"Konfiguracija fizičnega kanala LTE:"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="7062777594049622128">"Frekvenca osveževanja podatkov o celici:"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Vsi podatki o meritvah celice:"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Podatkovna storitev:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Gostovanje:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="2743797189722106231">"Preusmeritev klica:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3587319503902576102">"Število ponastavitev PPP od zagona:"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Trenutno omrežje:"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Prejeti podatki:"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Glasovna storitev:"</string>
    <string name="radio_info_signal_strength_label" msgid="5155734002519307416">"Moč signala:"</string>
    <string name="radio_info_call_status_label" msgid="2611065018172747413">"Stanje glasovnega klica:"</string>
    <string name="radio_info_ppp_sent_label" msgid="7748668735880404586">"Poslani podatki:"</string>
    <string name="radio_info_message_waiting_label" msgid="1037302619943328273">"Čakajoče sporočilo:"</string>
    <string name="radio_info_phone_number_label" msgid="7942153178953255231">"Telefonska številka:"</string>
    <string name="radio_info_band_mode_label" msgid="8730871744887454509">"Izbira radijskega območja"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Vrsta glasovnega omrežja:"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Vrsta podatkovnega omrežja:"</string>
    <string name="phone_index_label" msgid="1934407597576454430">"Izberite indeks telefona"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Nastavitev vrste prednostnega omrežja:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Preverjanje imena gostitelja (www.google.com) za IPv4:"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Preverjanje imena gostitelja (www.google.com) za IPv6:"</string>
    <string name="radio_info_http_client_test" msgid="2382286093023138339">"Preskus odjemalca HTTP:"</string>
    <string name="ping_test_label" msgid="579228584343892613">"Izvedba preskusa ping"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Posodobi"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Osveži"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="6625185764803245075">"Preklop preverjanja DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Informacije/nastavitve za OEM"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Nastavljanje načina radijskega območja"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Nalaganje seznama frekvenčnih pasov ..."</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Nastavi"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Ni uspelo"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Uspelo"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Spremembe začnejo veljati ob vnovičnem priklopu kabla USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Omogoči masovni pomnilnik USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Skupno število bajtov:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Pomnilnik USB ni vpet."</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Ni kartice SD."</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Število razpoložljivih bajtov:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB kot naprav. za množ. shr."</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"Kartica SD se uporablja kot naprava za množično shranjevanje."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Zdaj lahko varno odstranite pomnilnik USB."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Zdaj lahko varno odstranite kartico SD."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"Pomnilnik USB je bil odstranjen, ko je bil še v uporabi."</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"Kartico SD ste odstranili, ko je bila še v uporabi."</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Zasedeni bajti:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Iskanje predstavnostnih datotek na pomnilniku USB ..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Iskanje predstavnostih datotek na kartici SD ..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"Pomnilnik USB je vpet samo za branje."</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"Vpeta kartica SD je samo za branje."</string>
    <string name="skip_label" msgid="47510779345218297">"Preskoči"</string>
    <string name="next_label" msgid="4693520878012668114">"Naprej"</string>
    <string name="language_picker_title" msgid="3596315202551687690">"Jeziki"</string>
    <string name="pref_title_lang_selection" msgid="2014920136978776034">"Jezikovne nastavitve"</string>
    <string name="locale_remove_menu" msgid="7651301406723638854">"Odstrani"</string>
    <string name="add_a_language" msgid="2330538812283783022">"Dodaj jezik"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="one">Želite odstraniti izbrane jezike?</item>
      <item quantity="two">Želite odstraniti izbrane jezike?</item>
      <item quantity="few">Želite odstraniti izbrane jezike?</item>
      <item quantity="other">Želite odstraniti izbrane jezike?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Besedilo bo prikazano v drugem jeziku."</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"Vseh jezikov ni mogoče odstraniti"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Ohranite vsaj en želeni jezik"</string>
    <string name="locale_not_translated" msgid="516862628177166755">"Morda ni na voljo v nekaterih aplikacijah"</string>
    <string name="action_drag_label_move_up" msgid="9052210023727612540">"Premakni navzgor"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Premakni navzdol"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Premakni na vrh"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Premakni na dno"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Odstrani jezik"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Izberite dejavnost"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Informacije o napravi"</string>
    <string name="display_label" msgid="8074070940506840792">"Zaslon"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Podatki o tabličnem računalniku"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Informacije o telefonu"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Pomnilnik USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Kartica SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Nastavitve strežnika proxy"</string>
    <string name="cancel" msgid="6859253417269739139">"Prekliči"</string>
    <string name="okay" msgid="1997666393121016642">"V redu"</string>
    <string name="forget" msgid="1400428660472591263">"Pozabi"</string>
    <string name="save" msgid="879993180139353333">"Shrani"</string>
    <string name="done" msgid="6942539184162713160">"Končano"</string>
    <string name="apply" msgid="1577045208487259229">"Uporabi"</string>
    <string name="settings_label" msgid="1626402585530130914">"Nastavitve"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Nastavitve"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Bližnjica do nastavitev"</string>
    <string name="activity_list_empty" msgid="6428823323471264836">"Ni ustreznih dejavnosti."</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Način za letalo"</string>
    <string name="radio_controls_title" msgid="3447085191369779032">"Več"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Brezžično in omrežja"</string>
    <string name="radio_controls_summary" msgid="1838624369870907268">"Upravljajte Wi‑Fi, Bluetooth, način za letalo, mobilna omrežja in omrežja VPN"</string>
    <string name="cellular_data_title" msgid="6835451574385496662">"Prenos podatkov v mob. omrežju"</string>
    <string name="calls_title" msgid="3544471959217176768">"Klici"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Sporočila SMS"</string>
    <string name="cellular_data_summary" msgid="4660351864416939504">"Dovoli prenos podatkov v mobil. omrežju"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Dovoli prenos podat. med gost."</string>
    <string name="roaming" msgid="3596055926335478572">"Podatkovno gostovanje"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Med gostovanjem vzpostavi povezavo s podatkovnimi storitvami"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Med gostovanjem vzpostavi povezavo s podatkovnimi storitvami"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"Podatkovna povezava ni mogoča, ker ste zapustili domače omrežje, podatkovno gostovanje pa je izklopljeno."</string>
    <string name="roaming_turn_it_on_button" msgid="4387601818162120589">"Vklopi"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"Stroški utegnejo biti veliki."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Če omogočite podatkovno gostovanje, si lahko naprtite velike stroške!\n\nNastavitev vpliva na vse uporabnike v tem tabličnem računalniku."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Če omogočite podatkovno gostovanje, si lahko naprtite velike stroške!\n\nNastavitev vpliva na vse uporabnike v tem telefonu."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"Želite dovoliti podatkovno gostovanje?"</string>
    <string name="networks" msgid="6333316876545927039">"Izbira operaterja"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Izbira omrežnega operaterja"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Datum in ura"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Nastavitev datuma in ure"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Nastavi datum, uro, časovni pas in oblike"</string>
    <string name="date_time_auto" msgid="7076906458515908345">"Samodejna datum in ura"</string>
    <string name="date_time_auto_summaryOn" msgid="4609619490075140381">"Uporabi uro omrežja"</string>
    <string name="date_time_auto_summaryOff" msgid="8698762649061882791">"Uporabi uro omrežja"</string>
    <string name="zone_auto" msgid="334783869352026648">"Samodejni časovni pas"</string>
    <string name="zone_auto_summaryOn" msgid="6142830927278458314">"Uporabi časovni pas omrežja"</string>
    <string name="zone_auto_summaryOff" msgid="2597745783162041390">"Uporabi časovni pas omrežja"</string>
    <string name="date_time_24hour_auto" msgid="2117383168985653422">"Samodejna 24-urna oblika"</string>
    <string name="date_time_24hour_auto_summary" msgid="6351812925651480277">"Uporabi privzete območne nastavitve"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"24-urna oblika"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Uporabljaj 24-urno obliko"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Ura"</string>
    <string name="date_time_set_time" msgid="5716856602742530696">"Nastavi uro"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Časovni pas"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Izberite časovni pas"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Datum"</string>
    <string name="date_time_set_date" msgid="7021491668550232105">"Nastavi datum"</string>
    <string name="date_time_search_region" msgid="2478334699004021972">"Poiščite regijo"</string>
    <string name="date_time_select_region" msgid="5434001881313168586">"Regija"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="6084375085203448645">"Izbira zamika glede na čas UTC"</string>
    <string name="zone_change_to_from_dst" msgid="118656001224045590">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> se začne dne <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="1359698475641349336">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="164876167707284017">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="4192803402331390389">"Uporabljen bo časovni pas <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Čas <xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> začne veljati <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8652423870143056964">"Uporabljen bo časovni pas <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Brez preklapljanja med zimskim in poletnim časom."</string>
    <string name="zone_time_type_dst" msgid="8850494578766845276">"Poletni čas"</string>
    <string name="zone_time_type_standard" msgid="3462424485380376522">"Standardni čas"</string>
    <string name="zone_menu_by_region" msgid="8370437123807764346">"Izberi po regiji"</string>
    <string name="zone_menu_by_offset" msgid="7161573994228041794">"Izberi po zamiku glede na UTC"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Datum"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Ura"</string>
    <string name="lock_after_timeout" msgid="4590337686681194648">"Samodejno zaklepanje"</string>
    <string name="lock_after_timeout_summary" msgid="6128431871360905631">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po stanju pripravljenosti"</string>
    <string name="lock_immediately_summary_with_exception" msgid="9119632173886172690">"Takoj po stanju pripravljenosti, razen ko <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> poskrbi, da ostane odklenjen"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="5579064842797188409">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po stanju pripravljenosti, razen ko <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> poskrbi, da ostane odklenjen"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="5074906168357568434">"Prikaži lastnikove podatke na zaklenjenem zaslonu"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Spor. na zakl. zasl."</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Omogoči pripomočke"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="6392489775303464905">"Onemogočil skrbnik"</string>
    <string name="lockdown_settings_title" msgid="7393790212603280213">"Prikaz možnosti za zaklep"</string>
    <string name="lockdown_settings_summary" msgid="429230431748285997">"Prikaz možnosti gumba za vklop, s katero izklopite funkcijo Smart Lock, odklepanje s prstnimi odtisi in obvestila na zaklenjenem zaslonu"</string>
    <string name="owner_info_settings_summary" msgid="7472393443779227052">"Brez"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<xliff:g id="COUNT_0">%1$d</xliff:g>/<xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="7591869574491036360">"Npr. Janezov Android"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Podatki o uporabniku"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Pokaži podatke o profilu na zaklenjenem zaslonu"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Podatki za profil"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Računi"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Lokacija"</string>
    <string name="location_settings_master_switch_title" msgid="3560242980335542411">"Uporaba lokacije"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Računi"</string>
    <string name="security_settings_title" msgid="4918904614964215087">"Varnost in lokacija"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Šifriranje in poverilnice"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Telefon je šifriran"</string>
    <string name="decryption_settings_summary" product="default" msgid="5671817824042639849">"Telefon ni šifriran"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Naprava je šifrirana"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="5794135636155570977">"Naprava ni šifrirana"</string>
    <string name="lockscreen_settings_title" msgid="3922976395527087455">"Nastavitve zaklenjenega zaslona"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"Nastavi Mojo lokacijo, odklepanje zaslona, zaklepanje kartice SIM, zaklepanje shrambe poverilnic"</string>
    <string name="cdma_security_settings_summary" msgid="6068799952798901542">"Nastavitev Moje lokacije, odklepanja zaslona, zaklepanja shrambe poverilnic"</string>
    <string name="security_passwords_title" msgid="2881269890053568809">"Zasebnost"</string>
    <string name="disabled_by_administrator_summary" msgid="1601828700318996341">"Onemogočil skrbnik"</string>
    <string name="security_status_title" msgid="5848766673665944640">"Stanje varnosti"</string>
    <string name="security_dashboard_summary" msgid="6757421634477554939">"Zaklepanje zaslona, prstni odtis"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="8129641548372335540">"Zaklepanje zaslona"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Prstni odtis"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Upravlj. prst. odtisov"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"Upor. prst. odtisa za"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Dodaj prstni odtis"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"zaklepanje zaslona"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <item quantity="one"><xliff:g id="COUNT_1">%1$d</xliff:g> prstni odtis je nastavljen</item>
      <item quantity="two"><xliff:g id="COUNT_1">%1$d</xliff:g> prstna odtisa sta nastavljena</item>
      <item quantity="few"><xliff:g id="COUNT_1">%1$d</xliff:g> prstni odtisi so nastavljeni</item>
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> prstnih odtisov je nastavljenih</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1507739327565151923"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Odklepanje s prstnim odtisom"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="7066417934622827305">"Uporaba prstnega odtisa"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Dotaknite se tipala prstnih odtisov, če želite odkleniti telefon, odobriti nakupe ali se prijaviti v aplikacije. Pazite, čigave prstne odtise boste dodali. Ta dejanja bo mogoče izvesti že z enim dodanim prstnim odtisom.\n\nOpomba: prstni odtis bo morda manj varen kot zapleten vzorec ali koda PIN."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="1550756694054944874">"S prstnim odtisom odklenite telefon ali odobrite nakupe.\n\nOpomba: prstnega odtisa ne morete uporabiti za odklepanje te naprave. Za več informacij se obrnite na skrbnika v organizaciji."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="6817326798834882531">"S prstnim odtisom odklenite telefon ali odobrite nakupe.\n\nOpomba: prstni odtis bo morda manj varen kot zapleten vzorec ali koda PIN."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="3199351118385606526">"Prekliči"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Naprej"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="5021369420474432665">"Preskoči"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="1961957425135180242">"Naprej"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="362050541117362034">"Preskok nast. prstnega odtisa?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="958990414356204763">"Nastavitev prstnega odtisa vam bo vzela le minuto ali dve. Če nastavitev preskočite, lahko prstni odtis dodate pozneje v nastavitvah."</string>
    <string name="lock_screen_intro_skip_title" msgid="4988210105913705679">"Preskok zaklepanja zaslona?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1581834104051243425">"Funkcije za zaščito naprave ne bodo vklopljene. Če tablični računalnik izgubite, vam ga ukradejo ali ponastavijo na tovarniške nastavitve, drugim osebam ne boste mogli preprečiti njegove uporabe."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4629503416877189572">"Funkcije za zaščito naprave ne bodo vklopljene. Če napravo izgubite, vam jo ukradejo ali ponastavijo na tovarniške nastavitve, drugim osebam ne boste mogli preprečiti njene uporabe."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2423428240245737909">"Funkcije za zaščito naprave ne bodo vklopljene. Če telefon izgubite, vam ga ukradejo ali ponastavijo na tovarniške nastavitve, drugim osebam ne boste mogli preprečiti njegove uporabe."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="5219287483885558525">"Funkcije za zaščito naprave ne bodo vklopljene. Če tablični računalnik izgubite ali vam ga ukradejo, drugim osebam ne boste mogli preprečiti njegove uporabe."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="1466238255429527112">"Funkcije za zaščito naprave ne bodo vklopljene. Če napravo izgubite ali vam jo ukradejo, drugim osebam ne boste mogli preprečiti njene uporabe."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3008526710555416125">"Funkcije za zaščito naprave ne bodo vklopljene. Če telefon izgubite ali vam ga ukradejo, drugim osebam ne boste mogli preprečiti njegove uporabe."</string>
    <string name="skip_anyway_button_label" msgid="2323522873558834513">"Vseeno preskoči"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Nazaj"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="3051496861358227199">"Dotaknite se tipala"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="8793966374365960368">"Je na hrbtni strani telefona. Uporabite kazalec."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Ilustracija z napravo in lokacijo tipala prstnih odtisov"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Ime"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"V redu"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Izbriši"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="2068961812439460133">"Dotaknite se tipala"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Položite prst na tipalo in ga dvignite, ko začutite vibriranje"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="2819679722403209778">"Dvignite in se spet dotaknite"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="6158989350522518586">"Še naprej privzdigujte prst, da dodate različne dele prstnega odtisa"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="7567276170287972230">"Prstni odtis dodan"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8970048776120548976">"Ko je prikazana ta ikona, uporabite prstni odtis za identifikacijo ali odobritev nakupov"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3710211704052369752">"Pozneje"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="6808422329107426923">"Želite preskočiti nast. prstnega odtisa?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="274849306857859783">"Za odklepanja telefona ste izbrali možnost prstnega odtisa. Če zdaj preskočite, boste to morali nastaviti pozneje. Nastavitev traja samo približno eno minuto."</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Nastavi zaklepanje zaslona"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"Končano"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Ups, to ni tipalo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="2989019978041986175">"S kazalcem se dotaknite tipala na hrbtni strani telefona."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="3618021988442639280">"Včlanitev ni bila dokončana."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="2942551158278899627">"Dosežena časovna omejitev za včlanitev prstnega odtisa. Poskusite znova."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="3624760637222239293">"Včlanitev prstnega odtisa ni uspela. Poskusite znova ali uporabite drug prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Dodaj še enega"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Naprej"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"Prstni odtis lahko uporabljate za odklepanje zaslona ter potrjevanje nakupov in dostop do aplikacij. "<annotation id="url">"Več o tem"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="7846871823167357942">" Možnost zaklepanja zaslona je onemogočena. Če želite izvedeti več, se obrnite na skrbnika organizacije. "<annotation id="admin_details">"Več podrobnosti"</annotation>\n\n"Prstni odtis lahko še naprej uporabljate za potrjevanje nakupov in dostop do aplikacij. "<annotation id="url">"Več o tem"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="1888772560642539718">"Dvignite prst in se znova dotaknite tipala"</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Dodate lahko do toliko prstnih odtisov: <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="fingerprint_intro_error_max" msgid="6864066984678078441">"Dodali ste največje dovoljeno število prstnih odtisov"</string>
    <string name="fingerprint_intro_error_unknown" msgid="1905692132326523040">"Prstnih odtisov ni več mogoče dodati"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"Odstranitev vseh prstnih odtisov?"</string>
    <string name="fingerprint_delete_title" msgid="1368196182612202898">"Odstrani »<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>«"</string>
    <string name="fingerprint_delete_message" msgid="8597787803567398131">"Ali želite izbrisati ta prstni odtis?"</string>
    <string name="fingerprint_last_delete_message" msgid="7852321001254275878">"Za odklepanje telefona, odobritev nakupov ali prijavo v aplikacije ne boste mogli uporabljati prstnih odtisov."</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="6521520787746771912">"Za odklepanje delovnega profila, odobritev nakupov ali prijavo v delovne aplikacije, ne boste mogli uporabljati prstnih odtisov."</string>
    <string name="fingerprint_last_delete_confirm" msgid="2634726361059274289">"Da, odstrani"</string>
    <string name="confirm_fingerprint_icon_content_description" msgid="5255544532157079096">"Uporabite prstni odtis, če želite nadaljevati."</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Šifriranje"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Šifriraj tablični računalnik"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Šifriranje telefona"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Šifrirano"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"Šifrirate lahko račune, nastavitve, prenesene aplikacije in njihove podatke, predstavnosti in druge datoteke. Če ste nastavili zaklepanje zaslona (z vzorcem, številsko kodo PIN ali geslom), boste morali po šifriranju tabličnega računalnika ob vsakem vklopu odkleniti zaslon, če boste želeli tablični računalnik dešifrirati. Edini drugi način dešifriranja tabličnega računalnika je, da ga ponastavite na tovarniške nastavitve, s čemer izbrišete vse podatke.\n\nŠifriranje traja najmanj eno uro. Ko začnete šifriranje, naj bo akumulator napolnjen, tablični računalnik pa naj bo med celotnim postopkom priklopljen na električno omrežje. Če postopek prekinete, boste izgubili nekatere ali vse podatke."</string>
    <string name="crypt_keeper_desc" product="default" msgid="2579929266645543631">"Šifrirate lahko račune, nastavitve, prenesene aplikacije in njihove podatke, predstavnosti in druge datoteke. Če ste nastavili zaklepanje zaslona (z vzorcem, številsko kodo PIN ali geslom), boste morali po šifriranju telefona ob vsakem vklopu odkleniti zaslon, če boste želeli telefon dešifrirati. Edini drugi način dešifriranja je, da telefon ponastavite na tovarniške nastavitve, s čemer izbrišete vse podatke.\n\nŠifriranje traja najmanj eno uro. Ko začnete šifriranje, naj bo akumulator napolnjen, telefon pa naj bo med celotnim postopkom priklopljen na električno omrežje. Če postopek prekinete, boste izgubili nekatere ali vse podatke."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="1189623490604750854">"Šifriraj tablični računalnik"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Šifriraj telefon"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Napolnite akumulator in poskusite znova."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Priključite polnilnik in poskusite znova."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Ni kode PIN ali gesla za zaklepanje zaslona"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"Preden lahko začnete s šifriranjem, morate nastaviti kodo PIN ali geslo za zaklepanje zaslona."</string>
    <string name="crypt_keeper_confirm_title" msgid="5100339496381875522">"Želite šifrirati?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"Šifriranja ne morete razveljaviti ali prekiniti, ker lahko izgubite podatke. Šifriranje traja eno uro ali več in v tem času se bo tablični računalnik večkrat znova zagnal."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="287503113671320916">"Šifriranja ne morete razveljaviti ali prekiniti, ker lahko izgubite podatke. Šifriranje traja eno uro ali več in v tem času se bo telefon večkrat znova zagnal."</string>
    <string name="crypt_keeper_setup_title" msgid="1783951453124244969">"Šifriranje"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Počakajte, tablični računalnik se šifrira. Dokončano: <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"Počakajte, telefon se šifrira. Dokončano: <xliff:g id="PERCENT">^1</xliff:g>%."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="1655047311546745695">"Počakajte, poteka šifriranje tabličnega računalnika. Preostane še: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="1862964662304683072">"Počakajte, poteka šifriranje telefona. Preostane še: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="556504311511212648">"Če želite odkleniti tablični računalnik, ga izklopite in nato vklopite."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Če želite odkleniti telefon, ga izklopite in nato vklopite."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"Opozorilo: Podatki v napravi bodo izbrisani po še toliko neuspešnih poskusih odklepanja: <xliff:g id="COUNT">^1</xliff:g>."</string>
    <string name="crypt_keeper_enter_password" msgid="2223340178473871064">"Vnesite geslo"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Šifriranje ni uspelo"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"Šifriranje je bilo prekinjeno in ga ni mogoče končati, zato podatki v tabličnem računalniku niso več dostopni. \n\nČe želite tablični računalnik spet uporabljati, ga morate ponastaviti na tovarniške nastavitve. Ko ga po ponastavitvi spet nastavite, boste lahko obnovili vse podatke, ki so bili varnostno kopirani v Google Račun."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="3270131542549577953">"Šifriranje je bilo prekinjeno in ga ni mogoče končati, zato podatki v telefonu niso več dostopni. \n\nČe želite telefon ponovno uporabljati, ga morate ponastaviti na tovarniške nastavitve. Ko ga po ponastavitvi ponovno nastavite, boste lahko obnovili vse podatke, ki so bili varnostno kopirani v Google Račun."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="8759119849089795751">"Dešifriranje ni uspelo"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"Vnesli ste pravilno geslo, vendar so podatki poškodovani. \n\nČe želite še naprej uporabljati tablični računalnik, ga morate ponastaviti na tovarniške nastavitve. Ko boste po ponastavitvi nastavljali tablični računalnik, boste lahko obnovili morebitne podatke, ki so bili varnostno kopirani v Google Račun."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="8843311420059663824">"Vnesli ste pravilno geslo, vendar so podatki poškodovani. \n\nČe želite še naprej uporabljati telefon, ga morate ponastaviti na tovarniške nastavitve. Ko boste po ponastavitvi nastavljali telefon, boste lahko obnovili morebitne podatke, ki so bili varnostno kopirani v Google Račun."</string>
    <string name="crypt_keeper_switch_input_method" msgid="4168332125223483198">"Preklopite način vnosa"</string>
    <string name="suggested_lock_settings_title" msgid="8498743819223200961">"Zaščitite telefon"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="2296800316150748710">"Nastavite zaklepanje zaslona, da zaščitite tablico"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="7562847814806365373">"Nastavite zaklepanje zaslona, da zaščitite napravo"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="1526355348444658181">"Nastavite zaklepanje zaslona, da zaščitite telefon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="2174553391551398081">"Dodajanje prstnega odtisa za odklepanje"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="5738274583658668124"></string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Izberite zaklepanje zaslona"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Izbira zakl. del. p."</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="90329443364067215">"Zaščita tablič. račun."</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="2399952075134938929">"Zaščita naprave"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="1572244299605153324">"Zaščita telefona"</string>
    <string name="lock_settings_picker_fingerprint_added_security_message" msgid="5008939545428518367">"Zaradi večje varnosti nastavite nadomestno zaklepanje zaslona"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"Vklopite zaščitne funkcije naprave, da drugim preprečite uporabo tega tabličnega računalnika brez vašega dovoljenja. Izberite zaklepanje zaslona, ki ga želite uporabljati."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="3787276514406353777">"Vklopite zaščitne funkcije naprave, da drugim preprečite njeno uporabo brez vašega dovoljenja. Izberite zaklepanje zaslona, ki ga želite uporabljati."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="3692856437543730446">"Vklopite zaščitne funkcije naprave, da drugim preprečite uporabo tega telefona brez vašega dovoljenja. Izberite zaklepanje zaslona, ki ga želite uporabljati."</string>
    <string name="lock_settings_picker_fingerprint_message" msgid="4755230324778371292">"Izberite nadomestni način zaklepanja zaslona"</string>
    <string name="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Možnosti zaklepanja zaslona"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="5058207955455973917">"Možnosti zaklepanja zaslona"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Zaklepanje zaslona"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5967714169972542586">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / Takoj po stanju pripravljenosti"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4696710373399258413">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> po stanju pripravljenosti"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="124176557311393483">"Zaklep. del. profila"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Sprememba zakl. zasl."</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Spremeni ali onemogoči vzorec, kodo PIN ali varnost gesla"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Izberite način zaklepanja zaslona"</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Brez"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Vlečenje"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Brez varnosti"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Vzorec"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Srednja varnost"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"Koda PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Srednja do visoka varnost"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Geslo"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Visoka varnost"</string>
    <string name="unlock_set_do_later_title" msgid="4894767558414979243">"Ne zdaj"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Trenutno zaklepanje zaslona"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4939057588092120368">"Prstni odtis in vzorec"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="8010746824051056986">"Prstni odtis in PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="7351131075806338634">"Prstni odtis in geslo"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="1441077909803666681">"Nadaljevanje brez prstnega odtisa"</string>
    <string name="fingerprint_unlock_title" msgid="2826226740306003991">"Telefon lahko odklenete s prstnim odtisom. Zaradi varnosti ta možnost zahteva uporabo nadomestnega zaklepanja telefona."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="2051593894736282302">"Onemogočil skrbnik, pravilnik za šifriranje ali shramba poverilnic"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Brez"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Vlečenje"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Vzorec"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"Koda PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Geslo"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"Ko nastavite zaklepanje zaslona, lahko tudi nastavite prstni odtis v »Nastavitve &gt; Varnost«."</string>
    <string name="unlock_disable_lock_title" msgid="1427036227416979120">"Izklopi zaklepanje zaslona"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"Želite odstraniti zaščito naprave?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="5507136301904313583">"Želite odstraniti zaščito profila?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="8869767290771023461">"Funkcije za zaščito naprave ne bodo delovale brez vzorca."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2986105377420905314">"Funkcije za zaščito naprave ne bodo delovale brez vzorca.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz naprave bodo prav tako odstranjeni shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti telefona, odobriti nakupov ali se prijaviti v aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="586996206210265131">"Funkcije za zaščito naprave ne bodo delovale brez kode PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="3370462835533123695">"Funkcije za zaščito naprave ne bodo delovale brez kode PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz naprave bodo prav tako odstranjeni shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti telefona, odobriti nakupov ali se prijaviti v aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="5420612686852555537">"Funkcije za zaščito naprave ne bodo delovale brez gesla."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="3595476296430536798">"Funkcije za zaščito naprave ne bodo delovale brez gesla.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz naprave bodo prav tako odstranjeni shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti telefona, odobriti nakupov ali se prijaviti v aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="1550718040483548220">"Funkcije za zaščito naprave ne bodo delovale brez zaklepanja zaslona."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="3679351662094349506">"Funkcije za zaščito naprave ne bodo delovale brez zaklepanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz naprave bodo prav tako odstranjeni shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti telefona, odobriti nakupov ali se prijaviti v aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="8682200103576359918">"Funkcije za zaščito profila ne bodo delovale brez vzorca."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="6718155854303231675">"Funkcije za zaščito profila ne bodo delovale brez vzorca.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz profila bodo prav tako odstranjeni shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti profila, odobriti nakupov ali se prijaviti v aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="7790688070593867767">"Funkcije za zaščito profila ne bodo delovale brez kode PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="4209564603132870532">"Funkcije za zaščito profila ne bodo delovale brez kode PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz profila bodo prav tako odstranjeni shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti profila, odobriti nakupov ali se prijaviti v aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="7569285520567674461">"Funkcije za zaščito profila ne bodo delovale brez gesla."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="2994300676764706047">"Funkcije za zaščito profila ne bodo delovale brez gesla.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz profila bodo prav tako odstranjeni shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti profila, odobriti nakupov ali se prijaviti v aplikacije."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6984215718701688202">"Funkcije za zaščito profila ne bodo delovale brez zaklepanja zaslona."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="4994062501123299418">"Funkcije za zaščito profila ne bodo delovale brez zaklepanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz profila bodo prav tako odstranjeni shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti profila, odobriti nakupov ali se prijaviti v aplikacije."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="7075138677177748705">"Da, odstrani"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Spremeni vzorec za odklepanje"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Spremeni kodo PIN za odklepanje"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Spremeni geslo za odklepanje"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="2219711062197089783">"Poskusite znova. Poskus <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> od <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="4277765862798876826">"Vaši podatki bodo izbrisani"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="1688030823464420974">"Če pri naslednjem poskusu vnesete napačen vzorec, bodo podatki v napravi izbrisani."</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="5350785938296254352">"Če pri naslednjem poskusu vnesete napačno kodo PIN, bodo podatki v napravi izbrisani."</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="6208035114731421034">"Če pri naslednjem poskusu vnesete napačno geslo, bodo podatki v napravi izbrisani."</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="7851504071368235547">"Če pri naslednjem poskusu vnesete napačen vzorec, bo uporabnik izbrisan"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="4049024921333961715">"Če pri naslednjem poskusu vnesete napačno kodo PIN, bo uporabnik izbrisan"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="4660886542496781672">"Če pri naslednjem poskusu vnesete napačno geslo, bo uporabnik izbrisan"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2437716252059050291">"Če pri naslednjem poskusu vnesete napačen vzorec, bodo delovni profil in podatki v njem izbrisani"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="5799931839127476913">"Če pri naslednjem poskusu vnesete napačno kodo PIN, bodo delovni profil in podatki v njem izbrisani"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="6786586046975042158">"Če pri naslednjem poskusu vnesete napačno geslo, bodo delovni profil in podatki v njem izbrisani"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="5047439819181833824">"Preveč napačnih poskusov. Podatki v napravi bodo izbrisani."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="6188180643494518001">"Preveč napačnih poskusov. Uporabnik bo izbrisan."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="1745475043685915442">"Preveč napačnih poskusov. Delovni profil in podatki v njem bodo izbrisani."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="8246716090548717312">"Opusti"</string>
    <string name="lockpassword_password_too_short" msgid="2726090378672764986">"Geslo mora biti dolgo vsaj toliko znakov: <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="lockpassword_pin_too_short" msgid="3638188874397727648">"Koda PIN mora biti vsaj <xliff:g id="COUNT">%d</xliff:g>-mestna"</string>
    <string name="lockpassword_continue_label" msgid="4602203784934526940">"Naprej"</string>
    <string name="lockpassword_password_too_long" msgid="4591720174765403476">"Vsebovati mora manj kot toliko znakov: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockpassword_pin_too_long" msgid="2079396149560490458">"Vsebovati mora manj kot toliko števk: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockpassword_pin_contains_non_digits" msgid="7284664023164191198">"Vsebovati sme samo števke od 0 do 9."</string>
    <string name="lockpassword_pin_recently_used" msgid="1401569207976460727">"Skrbnik naprave ne dovoli uporabe nedavne kode PIN."</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="8563366383328811472">"Skrbnik za IT je blokiral pogoste kode PIN. Poskusite z drugo kodo PIN."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"Ne sme vsebovati neveljavnih znakov."</string>
    <string name="lockpassword_password_requires_alpha" msgid="3036589522150097731">"Vsebovati mora vsaj eno črko."</string>
    <string name="lockpassword_password_requires_digit" msgid="5140062925787058765">"Vsebovati mora vsaj eno števko."</string>
    <string name="lockpassword_password_requires_symbol" msgid="5944350865681510893">"Vsebovati mora vsaj en simbol."</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="9013132344745898400">
      <item quantity="one">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> črko</item>
      <item quantity="two">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> črki</item>
      <item quantity="few">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> črke</item>
      <item quantity="other">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> črk</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2626327674921055486">
      <item quantity="one">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> malo črko</item>
      <item quantity="two">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> mali črki</item>
      <item quantity="few">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> male črke</item>
      <item quantity="other">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> malih črk</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="7860796359913920356">
      <item quantity="one">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> veliko črko</item>
      <item quantity="two">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> veliki črki</item>
      <item quantity="few">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> velike črke</item>
      <item quantity="other">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> velikih črk</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="1967587658356336828">
      <item quantity="one">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> števko</item>
      <item quantity="two">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> števki</item>
      <item quantity="few">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> števke</item>
      <item quantity="other">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> števk</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="6751305770863640574">
      <item quantity="one">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> posebni znak</item>
      <item quantity="two">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> posebna znaka</item>
      <item quantity="few">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> posebne znake</item>
      <item quantity="other">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> posebnih znakov</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="4440596998172043055">
      <item quantity="one">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> znak, ki ni črka</item>
      <item quantity="two">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> znaka, ki nista črka</item>
      <item quantity="few">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> znake, ki niso črka</item>
      <item quantity="other">Vsebovati mora vsaj <xliff:g id="COUNT">%d</xliff:g> znakov, ki niso črka</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="942665351220525547">"Skrbnik naprave ne dovoli uporabe nedavnega gesla."</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="9105101266246197027">"Skrbnik za IT je blokiral pogosta gesla. Poskusite z drugim geslom."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"Naraščajoč, padajoč ali ponavljajoč se niz števk je prepovedan."</string>
    <string name="lockpassword_confirm_label" msgid="8176726201389902380">"Potrdi"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Prekliči"</string>
    <string name="lockpassword_clear_label" msgid="5724429464960458155">"Izbriši"</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Prekliči"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Naprej"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Namestitev je končana."</string>
    <string name="manage_device_admin" msgid="537804979483211453">"Skrbniške aplikacije naprave"</string>
    <string name="number_of_device_admins_none" msgid="7185056721919496069">"Ni aktivnih aplikacij"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="3361891840111523393">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> aktivna aplikacija</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g> aktivni aplikaciji</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aktivne aplikacije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aktivnih aplikacij</item>
    </plurals>
    <string name="manage_trust_agents" msgid="4629279457536987768">"Posredniki zaupanja"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Če želite uporabljati, najprej nastavite zaklepanje zaslona"</string>
    <string name="manage_trust_agents_summary" msgid="1475819820389620546">"Brez"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="3935182396726101824">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aktiven posrednik zaupanja</item>
      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> aktivna posrednika zaupanja</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aktivni posredniki zaupanja</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aktivnih posrednikov zaupanja</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Vklopi Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Upravljanje povezav, nastavitev imena naprave in vidnosti"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"Seznanitev z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Koda Bluetooth za seznanitev"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Vnesite kodo za seznanjanje in nato pritisnite Return ali Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"PIN vsebuje črke ali simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Običajno 0000 ali 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Biti mora 16-mestno število"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Ta PIN boste morda morali vnesti tudi v drugi napravi."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Geslo boste morda morali vnesti tudi v drugi napravi."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Če želite seznaniti z napravo:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Prikazano mora biti to geslo:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1615930853859551491">"Od:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;Ali se želite povezati s to napravo?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="2796550001376088433">"Če želite vzpostaviti povezavo z napravo:<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>V njej vnesite:<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> in pritisnite Return ali Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="9082518313285787097">"Dovoli dostop do stikov in zgodovine klicev"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"Povezave z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ni bilo mogoče vzpostaviti."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Išči naprave"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Osveži"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Iskanje ..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Nastavitve naprave"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Seznanjena naprava"</string>
    <string name="bluetooth_preference_paired_dialog_name_label" msgid="8111146086595617285">"Ime"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Internetna povezava"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Tipkovnica"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Stiki in zgodovina klicev"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"Želite opraviti seznanitev s to napravo?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"Želite dati telef. imenik v skupno rabo?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> želi dostopati do vaših stikov in zgodovine klicev."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="8451248193517851958">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> se želi seznaniti prek Bluetootha. Ko bo povezana, bo imela dostop do vaših stikov in zgodovine klicev."</string>
    <string name="bluetooth_preference_paired_devices" msgid="1970524193086791964">"Seznanjene naprave"</string>
    <string name="bluetooth_preference_found_media_devices" msgid="1617401232446299411">"Razpoložljive naprave"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"Nobena naprava ni na voljo"</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Vzpostavi povezavo"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Prekini povezavo"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Seznanitev in povezava"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Prekliči seznanitev"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Prekini povezavo in prekliči seznanitev"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Možnosti …"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Dodatno"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Dodatne nast. za Bluetooth"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Ko je Bluetooth vklopljen, lahko vaša naprava komunicira z drugimi napravami Bluetooth v bližini."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="824285504325592644">"Ko je Bluetooth vklopljen, lahko vaša naprava komunicira z drugimi napravami Bluetooth v bližini.\n\nZa izboljšano izkušnjo pri uporabi naprave lahko aplikacije in storitve še vedno kadar koli iščejo naprave v bližini, tudi ko je Bluetooth izklopljen. To se na primer uporablja za izboljšanje funkcij in storitve, ki pri delovanju uporabljajo lokacijo. Izbiro lahko spremenite v "<annotation id="link">"nastavitvah iskanja"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1295915006005700650">"Zaradi večje natančnosti ugotavljanja lokacije lahko sistemske aplikacije in storitve še vedno zaznajo naprave Bluetooth. To lahko spremenite v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavitvah iskanja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="4500234659813241053">"Povezave ni bilo mogoče vzpostaviti. Poskusite znova."</string>
    <string name="device_details_title" msgid="6576953269221085300">"Podrobnosti o napravi"</string>
    <string name="bluetooth_device_mac_address" msgid="2513724313558236181">"Naslov Bluetooth naprave: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="38467834196432400">"Želite, da vaša naprava pozabi seznanjeno napravo?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="9087609557757135712">"Telefon ne bo več seznanjen z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="7785695793007576501">"Tablični računalnik ne bo več seznanjen z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="251257782642157557">"Vaša naprava ne bo več seznanjena z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="3829370108973879006">"Pozabi napravo"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Vzpostavi povezavo z ..."</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"Povezava med napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> in zvokom nosilca podatkov bo prekinjena."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"Povezava med napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> in prostoročnim zvokom bo prekinjena."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"Povezava med napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> in vnosno napravo bo prekinjena."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"Internetni dostop prek naprave <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo prekinjen."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="8355910926439312604">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo izključena iz skupne rabe internetne povezave tega tabličnega računalnika."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="6251611115860359886">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo izključena iz skupne rabe internetne povezave tega telefona."</string>
    <string name="bluetooth_device_advanced_title" msgid="6066342531927499308">"Seznanjena naprava Bluetooth"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Vzpostavi povezavo"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Vzpostavi povezavo z napravo Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Uporaba za"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Preimenuj"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Dovoli dohodne prenose datotek"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="6436258151814414028">"Povezava z napravo za internetni dostop"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1322694224800769308">"Skupna raba lok. internetne povezave z napravo"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Nastavitve stojala"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Uporabi stojalo za zvok"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Kot zvočnik"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Za glasbo in predstavnost"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Zapomni si nastavitve"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="6752690395207847881">"Največje dovoljeno število povezanih zvočnih naprav Bluetooth"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="5936561749790095473">"Izberite največje dovoljeno število povezanih zvočnih naprav Bluetooth"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Predvajanje"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Omogočanje brezžičnega zaslona"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"V bližini ni naprav."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Povezovanje"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Povezane"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"V uporabi"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"Ni na voljo"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Nastavitve naprave"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Možnosti prikaza brezžičnih naprav"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Pozabi"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Končano"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Ime"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8404345621836792112">"Prijava"</string>
    <string name="wifi_tap_to_sign_in" msgid="6990161842394669054">"Dotaknite se tukaj, da se prijavite v omrežje"</string>
    <string name="link_speed" msgid="8896664974117585555">"%1$d Mb/s"</string>
    <string name="wifi_ask_enable" msgid="2795469717302060104">"Aplikacija <xliff:g id="REQUESTER">%s</xliff:g> želi vklopiti Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="728366570145493573">"Aplikacija <xliff:g id="REQUESTER">%s</xliff:g> želi izklopiti Wi-Fi"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Dovoli izmenjavo podatkov, ko se tablični računalnik dotakne druge naprave"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Dovoli izmenjavo podatkov, ko se telefon dotakne druge naprave"</string>
    <string name="nfc_disclaimer_title" msgid="4364003873202264039">"Vklop NFC-ja"</string>
    <string name="nfc_disclaimer_content" msgid="5566907911915158075">"NFC izmenjuje podatke med napravo in drugimi bližnjimi napravami ali cilji, na primer plačilnimi terminali, bralniki za dostop ter interaktivnimi oglasi ali oznakami."</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Pripravljen za prenos vsebine aplikacije prek NFC"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Izklopljeno"</string>
    <string name="android_beam_disabled_summary" msgid="1737782116894793393">"Ni na voljo, ker je NFC izklopljen"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="1810540319385192758">"Ko je ta funkcija vklopljena, lahko vsebino iz aplikacije prenesete v drugo napravo, ki podpira NFC, tako, da napravi približate. Prenesete lahko na primer spletne strani, videoposnetke v YouTubu, stike in drugo.\n\nPreprosto približajte napravi (običajno s hrbtno stranjo) in se dotaknite zaslona. Vsebino prenosa določi aplikacija."</string>
    <string name="wifi_quick_toggle_title" msgid="8850161330437693895">"Wi‑Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Vklopi Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi‑Fi"</string>
    <string name="wifi_settings_master_switch_title" msgid="4746267967669683259">"Uporabi Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Nastavitve za Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi‑Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Nastavi in upravljaj brezžične dostopne točke"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Izberi Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Vklapljanje povezave Wi‑Fi …"</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Izklapljanje povezave Wi‑Fi …"</string>
    <string name="wifi_error" msgid="3207971103917128179">"Napaka"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"5-GHz pas ni na voljo v tej državi"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"V načinu za letalo"</string>
    <string name="wifi_notify_open_networks" msgid="76298880708051981">"Obveščanje o odprtih omrežjih"</string>
    <string name="wifi_notify_open_networks_summary" msgid="2761326999921366960">"Obvesti me, ko je na voljo zanesljivo javno omrežje"</string>
    <string name="wifi_wakeup" msgid="8815640989361538036">"Samodejno vklopi Wi‑Fi"</string>
    <string name="wifi_wakeup_summary" msgid="2530814331062997163">"Wi‑Fi se bo samodejno znova vklopil v bližini zanesljivih shranjenih omrežij, na primer vašega domačega omrežja"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="7494539594649967699">"Ni na voljo, ker je lokacija izklopljena. Vklopite "<annotation id="link">"lokacijo"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="7247227922074840445">"Ni na voljo, ker je iskanje omrežij Wi‑Fi izklopljeno"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="108339002136866897">"Za uporabo te funkcije morate izbrati ponudnika ocenjevanja omrežij"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Izogni se slabim povezavam"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7016103106105907127">"Omrežje Wi-Fi uporabi samo, če ima dobro internetno povezavo"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="1644292503152790501">"Uporaba samo omrežij z dobro internetno povezavo"</string>
    <string name="use_open_wifi_automatically_title" msgid="6851951242903078588">"Povezovanje z odprtimi omrežji"</string>
    <string name="use_open_wifi_automatically_summary" msgid="2982091714252931713">"Samodejno povezovanje z zanesljivimi javnimi omrežji"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="593964217679325831">"Za uporabo te funkcije morate izbrati ponudnika ocenjevanja omrežij"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="8472122600853650258">"Za uporabo te funkcije morate izbrati združljivega ponudnika ocenjevanja omrežij"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Namestitev potrdil"</string>
    <string name="wifi_scan_notify_text" msgid="5544778734762998889">"Za večjo natančnost določanja lokacije lahko aplikacije in storitve še vedno kadar koli iščejo omrežja Wi-Fi, tudi ko je Wi-Fi izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo. To lahko kadar koli spremenite v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavitvah iskanja<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="3426075479272242098">"Če želite izboljšati natančnost ugotavljanja lokacije, v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavitvah iskanja<xliff:g id="LINK_END_1">LINK_END</xliff:g> vklopite iskanje omrežij Wi-Fi."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="7104867814641144485">"Tega ne kaži več"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Ohrani povezavo Wi-Fi med spanjem"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi-Fi vklop. v stanju priprav."</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Težava pri spreminjanju nastavitve"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Izboljšanje učinkovitosti"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimizacija Wi-Fi-ja"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Zmanjšanje porabe energije akumulatorja, ko je vklopljen Wi-Fi"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Omejitev porabe akum. za Wi‑Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="8593144541347373394">"Preklopi na prenos podatkov v mobilnih omrežjih, če omrežje Wi‑Fi nima več dostopa do interneta."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8753386877755616476">"Samodejno preklopi na prenos podatkov v mobilnih omrežjih"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="1403505355490119307">"Uporaba prenosa podatkov v mobilnih omrežjih, če omrežje Wi-Fi nima dostopa do interneta. Pri tem bodo morda nastali stroški prenosa podatkov v mobilnih omrežjih."</string>
    <string name="wifi_add_network" msgid="6234851776910938957">"Dodaj omrežje"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2913345003906899146">"Nastavitve za Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="646393113104367290">"Wi‑Fi se samodejno znova vklopi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="2782566279864356713">"Wi‑Fi se ne vklopi znova samodejno"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Omrežja Wi-Fi"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Več možnosti"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi‑Fi Direct"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Išči"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Dodatno"</string>
    <string name="wifi_menu_configure" msgid="6150926852602171938">"Konfiguriranje"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Vzpostavi povezavo z omrežjem"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Zapomni si omrežje"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Pozabi omrežje"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Spremeni omrežje"</string>
    <string name="wifi_menu_write_to_nfc" msgid="7692881642188240324">"Zapisovanje na oznako NFC"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Za prikaz razpoložljivih omrežij vklopite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Iskanje omrežij Wi-Fi …"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"Nimate dovoljenja za spreminjanje omrežja Wi‑Fi."</string>
    <string name="wifi_more" msgid="3195296805089107950">"Več"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Samodej. nastavitev (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="3815269816331500375">"Želite vklopiti iskanje omrežij Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="6352918945128328916">"Če želite samodejno vklopiti Wi-Fi, morate najprej vklopiti iskanje omrežij Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="3155631874578023647">"Iskanje omrežij Wi-Fi aplikacijam in storitvam omogoči, da kadar koli iščejo omrežja Wi-Fi v bližini, tudi ko je Wi-Fi izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1364287182804820646">"Vklopi"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="5527653791584018157">"Iskanje omrežij Wi‑Fi je vklopljeno"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Dodatne možnosti"</string>
    <string name="wifi_advanced_toggle_description_expanded" msgid="2380600578544493084">"Spustni seznam Dodatne možnosti. Dvakrat se dotaknite, da ga strnete."</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="1463812308429197263">"Spustni seznam Dodatne možnosti. Dvakrat se dotaknite, da ga razširite."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Ime omrežja"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Vnesite SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Varnost"</string>
    <string name="wifi_hidden_network" msgid="973162091800925000">"Skrito omrežje"</string>
    <string name="wifi_hidden_network_warning" msgid="6674068093531603452">"Če vaš usmerjevalnik ne oddaja omrežnega ID-ja, vendar se želite povezati z njim v prihodnosti, lahko omrežje nastavite kot skrito.\n\nTo lahko povzroči varnostno tveganje, ker bo telefon redno oddajal svoj signal, da najde omrežje.\n\nČe omrežje nastavite kot skrito, to ne bo spremenilo nastavitev usmerjevalnika."</string>
    <string name="wifi_signal" msgid="5514120261628065287">"Moč signala"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Stanje"</string>
    <string name="wifi_speed" msgid="3526198708812322037">"Hitrost povezave"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frekvenca"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Naslov IP"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"Shranjeno prek:"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"Poverilnice za <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Način EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Preverjanje pristnosti v fazi 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Overjeno potrdilo"</string>
    <string name="wifi_eap_domain" msgid="8471124344218082064">"Domena"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Uporabniško potrdilo"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identiteta"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Anonimna identiteta"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Geslo"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Pokaži geslo"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Izbira pasu dostopne točke"</string>
    <string name="wifi_ap_choose_auto" msgid="2677800651271769965">"Samodejno"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"2,4-GHz pas"</string>
    <string name="wifi_ap_choose_5G" msgid="8813128641914385634">"5,0-GHz pas"</string>
    <string name="wifi_ap_prefer_5G" msgid="2501070491623803139">"Prednostno 5,0-GHz pas"</string>
    <string name="wifi_ap_2G" msgid="8378132945192979364">"2,4 GHz"</string>
    <string name="wifi_ap_5G" msgid="4020713496716329468">"5,0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="3476254666116431650">"Izberite vsaj en pas za dostopno točko Wi‑Fi:"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Nastavitve naslova IP"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Skupna raba z drugimi uporabniki naprave"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(nespremenjeno)"</string>
    <string name="wifi_unspecified" msgid="4917316464723064807">"Izberite"</string>
    <string name="wifi_multiple_cert_added" msgid="3240743501460165224">"(Dodanih je bilo več potrdil)"</string>
    <string name="wifi_use_system_certs" msgid="5270879895056893783">"Uporabi sistemska potrdila"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"Ne posreduj"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"Ne potrdi"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"Ni navedenih potrdil. Povezava ne bo zasebna."</string>
    <string name="wifi_ssid_too_long" msgid="3474753269579895244">"Ime omrežja je predolgo."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Določiti morate domeno."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WPS je na voljo"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WPS je na voljo)"</string>
    <string name="wifi_wps_nfc_enter_password" msgid="2288214226916117159">"Vnesite geslo za omrežje"</string>
    <string name="wifi_carrier_connect" msgid="8174696557882299911">"Omrežje Wi‑Fi operaterja"</string>
    <string name="wifi_carrier_content" msgid="4634077285415851933">"Povezava prek omrežja <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"Za izboljšanje natančnosti lokacijskih podatkov in druge namene želi <xliff:g id="APP_NAME">%1$s</xliff:g> vklopiti iskanje omrežij, tudi ko je Wi-Fi izklopljen.\n\nŽelite to dovoliti vsem aplikacijam, ki želijo iskati omrežja?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="5538901671131941043">"Če želite to možnost izklopiti, v meniju z dodatnimi elementi odprite »Dodatno«."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Dovoli"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Zavrni"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"Ali se želite prijaviti, da se lahko povežete?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<xliff:g id="APP_NAME">%1$s</xliff:g> zahteva spletno prijavo pred povezavo v omrežje."</string>
    <string name="wifi_hotspot_connect" msgid="5065506390164939225">"POVEŽI"</string>
    <string name="no_internet_access_text" msgid="5926979351959279577">"To omrežje nima dostopa do interneta. Ali želite ostati povezani?"</string>
    <string name="partial_connectivity_text" msgid="1287030663891772340">"Nekatere aplik./storitve morda ne bodo delovale zaradi omej. povezljivosti. Želite vseeno uporabiti?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"Ne sprašuj več za to omrežje"</string>
    <string name="lost_internet_access_title" msgid="5779478650636392426">"Omrežje Wi-Fi ni povezano z internetom"</string>
    <string name="lost_internet_access_text" msgid="9029649339816197345">"Kadar je povezava Wi-Fi slaba, lahko preklopite na mobilno omrežje. Pri tem bodo morda nastali stroški prenosa podatkov v mobilnih omrežjih."</string>
    <string name="lost_internet_access_switch" msgid="2262459569601190039">"Preklopi na mobilno"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Ostani v omrežju Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"Tega ne prikaži nikoli več"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Vzpostavi povezavo"</string>
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"Vzpostavljanje povezave z omrežjem ni uspelo"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Pozabi"</string>
    <string name="wifi_modify" msgid="6100248070440710782">"Spremeni"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"Pozabljanje omrežja ni uspelo"</string>
    <string name="wifi_save" msgid="3331121567988522826">"Shrani"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"Shranjevanje omrežja ni uspelo"</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Prekliči"</string>
    <string name="wifi_forget_dialog_title" msgid="6224151903586192426">"Želite, da naprava pozabi omrežje?"</string>
    <string name="wifi_forget_dialog_message" msgid="2337060138532166680">"Vsa gesla za to omrežje bodo izbrisana"</string>
    <string name="wifi_saved_access_points_titlebar" msgid="2996149477240134064">"Shranjena omrežja"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="6094679048871529675">
      <item quantity="one">%d omrežje</item>
      <item quantity="two">%d omrežji</item>
      <item quantity="few">%d omrežja</item>
      <item quantity="other">%d omrežij</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Dodatne nast. za Wi‑Fi"</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Naslov MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Naslov IP"</string>
    <string name="wifi_details_title" msgid="8954667664081737098">"O omrežju"</string>
    <string name="wifi_details_subnet_mask" msgid="6720279144174924410">"Maska podomrežja"</string>
    <string name="wifi_details_dns" msgid="8648826607751830768">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="6734119149106422148">"Naslovi IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Shranjena omrežja"</string>
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Nastavitve nasl. IP"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"Dodatne nastavitve za Wi-Fi temu uporabniku niso na voljo"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Shrani"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Prekliči"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Vnesite veljaven naslov IP."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Vnesite veljaven naslov prehoda."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Vnesite veljaven naslov DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Vnesite predpono omrežja, dolgo med 0 in 32 znaki."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Prehod"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Dolžina predpone omrežja"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Podatki o napravi"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Zapomni si to povezavo"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Išči naprave"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Iskanje …"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Preimenuj napravo"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Enakovredne naprave"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Shranjene skupine"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"Povezava ni mogoča."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Naprave ni bilo mogoče preimenovati."</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"Želite prekiniti povezavo?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"Če prekinete, se prekine povezava z napravo <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="3283805371034883105">"Če prekinete povezavo, bo prekinjena povezava z napravo <xliff:g id="PEER_NAME">%1$s</xliff:g> in še toliko drugimi: <xliff:g id="PEER_COUNT">%2$s</xliff:g>."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="255267538099324413">"Želite preklicati povabilo?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"Ali želite preklicati povabilo za povezavo z napravo <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="834559380069647086">"Želite pozabiti to skupino?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Dostopna točka Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2199911382555864644">"Internetna povezava ali vsebina ni v skupni rabi z drugimi napravami"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5936710887156133458">"Skupna raba internetne povezave tega tabličnega računalnika prek dostopne točke"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5556202634866621632">"Skupna raba internetne povezave tega telefona prek dostopne točke"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="5017191966153008">"Aplikacija daje vsebino v skupno rabo. Če želite omogočiti skupno rabo internetne povezave, dostopno točko izklopite in znova vklopite."</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="353306131026431089">"Geslo ni nastavljeno"</string>
    <string name="wifi_hotspot_name_title" msgid="8237000746618636778">"Ime dostopne točke"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="3378299995508671967">"Vklapljanje dostopne točke <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>..."</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="3888672084861445362">"Druge naprave se lahko povežejo z dostopno točko <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="8676859981917573801">"Geslo za dostopno točko"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="1165801173359290681">"Pas dostopne točke"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="4789553667374849566">"Uporabite dostopno točko, da ustvarite omrežje Wi‑Fi za svoje druge naprave. Dostopna točka omogoča uporabo interneta prek mobilne podatkovne povezave, zato lahko nastanejo dodatni stroški prenosa podatkov v mobilnih omrežjih."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="857988412470694109">"Aplikacije lahko ustvarijo dostopno točko za skupno rabo vsebin z napravami v bližini."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="1590313508558948079">"Samodejni izklop dostopne točke"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="5858098059725925084">"Dostopna točka Wi‑Fi se bo izklopila, če ni povezana nobena naprava"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Vklop dostopne točke  ..."</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Izklop dostopne točke ..."</string>
    <string name="wifi_tether_enabled_subtext" msgid="7842111748046063857">"Povezava <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivna"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Napaka prenosne dostopne točke Wi-Fi"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Nastavitev dostopne točke Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Nastavitev dostopne toč. Wi‑Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"Dostopna točka AndroidAP WPA2 PSK"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="wifi_tether_disabled_by_airplane" msgid="414480185654767932">"Ni na voljo, ker je vklopljen način za letalo"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Klicanje prek Wi-Fi-ja"</string>
    <string name="wifi_calling_suggestion_title" msgid="5702964371483390024">"Razširite območje klicanja s povezavo Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="1331793267608673739">"Vklopite klicanje prek Wi‑Fi-ja, da povečate pokritost"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Nastavitev klicanja"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="7105195222267749226">"Nastavitev klicanja"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="1565039047187685115">"Prednostna izbira za gostovanje"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (8642014873060687717) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="7800926602662078576">"Prednostna izbira za gostovanje"</string>
  <string-array name="wifi_calling_mode_choices">
    <item msgid="772621647207148279">"@*android:string/wfc_mode_wifi_preferred_summary"</item>
    <item msgid="2226422868199612072">"@*android:string/wfc_mode_cellular_preferred_summary"</item>
    <item msgid="7041954411163832397">"@*android:string/wfc_mode_wifi_only_summary"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="742988808283756263">"Wi-Fi"</item>
    <item msgid="7715869266611010880">"Mobilno"</item>
    <item msgid="2838022395783120596">"Samo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values">
    <item msgid="4799585830102342375">"2"</item>
    <item msgid="1171822231056612021">"1"</item>
    <item msgid="3194458950573886239">"0"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_without_wifi_only">
    <item msgid="4430473354160964286">"@*android:string/wfc_mode_wifi_preferred_summary"</item>
    <item msgid="5965810717958113109">"@*android:string/wfc_mode_cellular_preferred_summary"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"Wi-Fi"</item>
    <item msgid="1118703915148755405">"Mobilno"</item>
  </string-array>
  <string-array name="wifi_calling_mode_values_without_wifi_only">
    <item msgid="2339246858001475047">"2"</item>
    <item msgid="6200207341126893791">"1"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="9092988115148569860">"Uporaba mobilnega omrežja, če omrežje Wi-Fi ni dosegljivo"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="240885549023046403">"Uporaba omrežja Wi-Fi, če mobilno omrežje ni dosegljivo"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3688265826855460036">"Klic prek omrežja Wi-Fi. Če izgubite povezavo Wi-Fi, bo klic končan."</string>
    <string name="wifi_calling_off_explanation" msgid="564780186974911501">"Ko je vklopljeno klicanje prek omrežja Wi-Fi, lahko telefon preusmeri klice prek omrežij Wi-Fi ali omrežja operaterja na podlagi vaše nastavitve in moči signala. Pred vklopom te funkcije pri operaterju preverite cene in druge podrobnosti.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="932729250447887545">"Naslov za nujne primere"</string>
    <string name="emergency_address_summary" msgid="7751971156196115129">"Uporabljen je kot vaš naslov, ko opravite klic v sili prek Wi‑Fi-ja"</string>
    <string name="private_dns_help_message" msgid="3299567069152568958"><annotation id="url">"Preberite več"</annotation>" o funkcijah zasebnega strežnika DNS"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="6845711858866828986">"Nastavitev upravlja operater"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="7492509632478260955">"Aktivirajte klicanje prek Wi-Fi-ja"</string>
    <string name="wifi_calling_turn_on" msgid="1171403510313983983">"Vklopite klicanje prek Wi-Fi-ja"</string>
    <string name="wifi_calling_not_supported" msgid="7878640438907807754">"Operater %1$s ne podpira klicanja prek Wi‑Fi-ja"</string>
    <string name="carrier" msgid="5264014738689761132">"Operater"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Zaslon"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Zvok"</string>
    <string name="all_volume_title" msgid="4296957391257836961">"Glasnost"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Glasbeni učinki"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Glasnost zvonjenja"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibriraj v tihem načinu"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Privzeti zvok obvestila"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Zvonjenje"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Obvestilo"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Za obvestila uporabljaj glasnost dohodnih klicev"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"Ne podpira delovnih profilov"</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Privzeti zvok obvestila"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Predstavnost"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Nastavi glasnost za glasbo in video"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarm"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Zvočne nastavitve za priklopljeno stojalo"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Zvok številčnice"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Zvoki ob dotiku"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Zvoki zaklepanja zaslona"</string>
    <string name="haptic_feedback_enable_title" msgid="7152163068278526530">"Vibriranje ob dotiku"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Zmanjšanje zunanjih zvokov"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Glasba, videoposnetki, igre in druge predstavnosti"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Zvonjenje in obvestila"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Obvestila"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmi"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Izklop zvonjenja in obvestil"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Izklop glasbe in drugih medijev"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Izklop zvoka obvestil"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Izklop alarmov"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Stojalo"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Nastavitvebn stojala"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Zvok"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Nastavitve za priklopljeno namizno stojalo"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Nastavitve za priklopljeno stojalo za avto"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"Tablični računalnik ni v stojalu"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"Telefon ni nameščen v stojalu"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Nastavitve za priklopljeno stojalo"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"Stojala ni mogoče najti"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Preden nastavite zvok, mora biti tablični računalnik v stojalu."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Preden nastavite zvok, mora biti telefon v stojalu."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Zvok ob vstavitvi v stojalo"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Predvajaj zvok med vstavljanjem tabličnega računalnika v stojalo ali odstranjevanjem iz njega"</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Predvajaj zvok pri vstavitvi telefona v stojalo ali odstranitvi iz njega"</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"Ne predvajaj zvoka med vstavljanjem tabličnega računalnika v stojalo ali odstranjevanjem iz njega"</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"Ne predvajaj zvoka pri vstavitvi telefona v stojalo ali odstranitvi iz njega"</string>
    <string name="account_settings" msgid="6403589284618783461">"Računi"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Računi za delovne profile – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Računi za osebne profile"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Delovni račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Osebni račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="1910951467596035063">"Iskanje"</string>
    <string name="display_settings" msgid="7965901687241669598">"Zaslon"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Samodejno zasukaj zaslon"</string>
    <string name="color_mode_title" msgid="9186249332902370471">"Barve"</string>
    <string name="color_mode_option_natural" msgid="5013837483986772758">"Naravne"</string>
    <string name="color_mode_option_boosted" msgid="8588223970257287524">"Poudarjene"</string>
    <string name="color_mode_option_saturated" msgid="4569683960058798843">"Nasičene"</string>
    <string name="color_mode_option_automatic" msgid="7996505473528529568">"Prilagodljivo"</string>
    <string name="color_mode_summary_natural" msgid="6624188642920403099">"Uporaba samo natančnih barv"</string>
    <string name="color_mode_summary_automatic" msgid="4669516973360709431">"Prilagoditev med živimi in natančnimi barvami"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Samodejno spremeni usmerjenost ob zasuku tabličnega računalnika"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Samodejno preklopi usmeritev ob zasuku telefona"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Samodejno spremeni usmerjenost ob zasuku tabličnega računalnika"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Samodejno preklopi usmeritev ob zasuku telefona"</string>
    <string name="brightness" msgid="8480105032417444275">"Raven svetlosti"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Svetlost"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Prilagoditev svetlosti zaslona"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Prilagodljiva svetlost"</string>
    <string name="auto_brightness_summary" msgid="1799041158760605375">"Optimiziranje ravni svetlosti glede na razpoložljivo svetlobo"</string>
    <string name="auto_brightness_summary_off" msgid="2802336459335410626">"Izklopljeno"</string>
    <string name="auto_brightness_summary_very_low" msgid="6483976609035853764">"Prednostna svetlost je zelo nizka"</string>
    <string name="auto_brightness_summary_low" msgid="5609877905833960427">"Prednostna svetlost je nizka"</string>
    <string name="auto_brightness_summary_default" msgid="7225666614394726845">"Prednostna svetlost je privzeta"</string>
    <string name="auto_brightness_summary_high" msgid="7172304165631136027">"Prednostna svetlost je visoka"</string>
    <string name="auto_brightness_summary_very_high" msgid="979277812582279078">"Prednostna svetlost je zelo visoka"</string>
    <string name="auto_brightness_off_title" msgid="2996864829946190795">"Izklopljeno"</string>
    <string name="auto_brightness_very_low_title" msgid="8252988638614126320">"Zelo nizka"</string>
    <string name="auto_brightness_low_title" msgid="1632186441514863377">"Nizka"</string>
    <string name="auto_brightness_default_title" msgid="936771997353506620">"Privzeta"</string>
    <string name="auto_brightness_high_title" msgid="2527853305981497345">"Visoka"</string>
    <string name="auto_brightness_very_high_title" msgid="8867164854439331022">"Zelo visoka"</string>
    <string name="auto_brightness_subtitle" msgid="6454652530864093466">"Prednostna raven svetlosti"</string>
    <string name="auto_brightness_off_summary" msgid="7629228736838155268">"Ne prilagodi glede na razpoložljivo svetlobo"</string>
    <string name="auto_brightness_very_high_summary" msgid="4551003097086220709">"Povečana poraba akumulatorja"</string>
    <string name="auto_brightness_disclaimer" msgid="871436423746343406">"Optimiziranje ravni svetlosti glede na razpoložljivo svetlobo. Ko je ta funkcija vklopljena, lahko še vedno začasno prilagodite svetlost."</string>
    <string name="auto_brightness_description" msgid="7310335517128283729">"Svetlost zaslona se bo samodejno prilagajala glede na okolje in dejavnosti. Če želite, da funkcija za prilagodljivo svetlost hitreje spozna vaše želje, lahko ročno premaknete drsnik."</string>
    <string name="night_display_title" msgid="2626451512200357686">"Nočna svetloba"</string>
    <string name="night_display_text" msgid="1837277457033025056">"Nočna svetloba zaslon obarva z jantarnim odtenkom. To olajša gledanje na zaslon ali branje pri šibki svetlobi in vam lahko pomaga prej zaspati."</string>
    <string name="night_display_auto_mode_title" msgid="6574111412154833409">"Urnik"</string>
    <string name="night_display_auto_mode_never" msgid="2483761922928753400">"Brez"</string>
    <string name="night_display_auto_mode_custom" msgid="2379394568898721765">"Vklop ob poljubni nastavljeni uri"</string>
    <string name="night_display_auto_mode_twilight" msgid="589042813708244059">"Vklop od sončn. zahoda do vzhoda"</string>
    <string name="night_display_start_time_title" msgid="8918016772613689584">"Začetni čas"</string>
    <string name="night_display_end_time_title" msgid="8286061578083519350">"Končni čas"</string>
    <string name="night_display_status_title" msgid="1784041143360286267">"Stanje"</string>
    <string name="night_display_temperature_title" msgid="1435292789272017136">"Intenzivnost"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Izklopljeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="3583590137322963513">"Brez samodejnega vklopa"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6365668239253173208">"Samodejni vklop ob <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3596291693781757392">"Samodejni vklop ob sončnem zahodu"</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Vklopljeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="9117830821363119835">"Brez samodejnega izklopa"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="5510753572245577263">"Samodejni izklop ob <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="852270120144683507">"Samodejni izklop ob sončnem vzhodu"</string>
    <string name="night_display_activation_on_manual" msgid="277343561277625826">"Vklopi zdaj"</string>
    <string name="night_display_activation_off_manual" msgid="4074557720918572883">"Izklopi zdaj"</string>
    <string name="night_display_activation_on_twilight" msgid="6976051971534953845">"Vklopi do sončnega vzhoda"</string>
    <string name="night_display_activation_off_twilight" msgid="7196227685059907233">"Izklopi do sončnega zahoda"</string>
    <string name="night_display_activation_on_custom" msgid="5472029024427933598">"Vklopi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="6169984658293744715">"Izklopi do <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="screen_timeout" msgid="4351334843529712571">"Stanje pripravljenosti"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Zaslon se izklopi"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Po toliko časa nedejavnosti: <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g>"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Ozadje"</string>
    <string name="wallpaper_settings_summary_default" msgid="3395741565658711416">"Privzeto"</string>
    <string name="wallpaper_settings_summary_custom" msgid="515035303981687172">"Po meri"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Spremenite ozadje"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Prilagajanje zaslona"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Izberite ozadje iz"</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Ohranjevalnik zaslona"</string>
    <string name="screensaver_settings_summary_either_long" msgid="7302740999250873332">"Med polnjenjem ali v stojalu"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"Eno ali drugo"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Med polnjenjem"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Ko je v stojalu"</string>
    <string name="screensaver_settings_summary_never" msgid="5165622985174349585">"Nikoli"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Izklopljeno"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1239088321034437608">"Če želite nadzirati, kaj se dogaja, ko je telefon na nosilcu in/ali v stanju pripravljenosti, vklopite ohranjevalnik zaslona."</string>
    <string name="screensaver_settings_when_to_dream" msgid="7262410541382890146">"Kdaj naj se zažene"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Trenutni ohranjevalnik zaslona"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Zaženi zdaj"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Nastavitve"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Samodejna svetlost"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Preklop iz stanja pripravlj. z dviganjem"</string>
    <string name="ambient_display_screen_title" msgid="4252755516328775766">"Prikaz na podlagi okolja"</string>
    <string name="ambient_display_screen_summary_always_on" msgid="7337555569694794132">"Vedno vključeno/višja poraba energije akumulatorja"</string>
    <string name="ambient_display_screen_summary_notifications" msgid="1449570742600868654">"Nova obvestila"</string>
    <string name="ambient_display_category_triggers" msgid="4359289754456268573">"Kdaj naj se prikaže"</string>
    <string name="doze_title" msgid="2375510714460456687">"Nova obvestila"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Preklop zaslona iz stanja pripravljenosti, ko prejmete obvestila"</string>
    <string name="doze_always_on_title" msgid="1046222370442629646">"Vedno vklopljeno"</string>
    <string name="doze_always_on_summary" msgid="6978257596231155345">"Prikaz ure, ikon obvestil in drugih informacij. Višja poraba energije akumulatorja."</string>
    <string name="title_font_size" msgid="4405544325522105222">"Velikost pisave"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Pomanjšava ali povečava besedila"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Nastavitve zaklepanja SIM"</string>
    <string name="sim_lock_settings_category" msgid="6242052161214271091">"Zaklepanje kartice SIM"</string>
    <string name="sim_lock_settings_summary_off" msgid="8028944267104896401">"Izklopljeno"</string>
    <string name="sim_lock_settings_summary_on" msgid="39103355956342985">"Zaklenjeno"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Zaklepanje kartice SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Zakleni kartico SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Zahtevaj PIN za uporabo tabličnega računalnika"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Zahtevaj kodo PIN za uporabo telefona"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Zahtevaj PIN za uporabo tabličnega računalnika"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Zahtevaj kodo PIN za uporabo telefona"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Spremeni kodo PIN kartice SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"Koda PIN za kartico SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Zakleni kartico SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Odkleni kartico SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"Stara koda PIN za kartico SIM"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nova koda PIN za kartico SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Znova vnesite novi PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"Koda PIN za kartico SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"Napačen PIN"</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"Kodi PIN se ne ujemata"</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"Kode PIN ni mogoče spremeniti.\nKoda PIN je morda napačna."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"Sprememba kode PIN za kartico SIM je uspela"</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"Zaklepanja kartice SIM ni mogoče spremeniti.\nMorda je koda PIN napačna."</string>
    <string name="sim_pin_disable_failed" msgid="7932981135799678220">"Kode PIN ni mogoče onemogočiti."</string>
    <string name="sim_pin_enable_failed" msgid="3414621075632931753">"Kode PIN ni mogoče omogočiti."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"V redu"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Prekliči"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Najdenih je bilo več kartic SIM"</string>
    <string name="sim_multi_sims_summary" msgid="2698176447067691396">"Izberite kartico SIM, ki jo želite uporabljati za prenos podatkov v mobilnih omrežjih."</string>
    <string name="sim_change_data_title" msgid="294357201685244532">"Druga kart. SIM za pren. pod.?"</string>
    <string name="sim_change_data_message" msgid="5854582807996717811">"Ali želite za prenos podatkov v mobilnih omrežjih uporabiti <xliff:g id="NEW_SIM">%1$s</xliff:g> namesto <xliff:g id="OLD_SIM">%2$s</xliff:g>?"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"Želite sprem. pred. kart. SIM?"</string>
    <string name="sim_preferred_message" msgid="8466930554330635780">"<xliff:g id="NEW_SIM">%1$s</xliff:g> je edina kartica SIM v napravi. Ali želite to kartico SIM uporabljati za prenos podatkov v mobilnih omrežjih, klice in pošiljanje sporočil SMS?"</string>
    <string name="wrong_pin_code_pukked" msgid="4003655226832658066">"Napačna koda PIN kartice SIM. Zdaj se boste morali za odklenitev naprave obrniti na operaterja."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="1582398808893048097">
      <item quantity="one">Napačna koda PIN kartice SIM. Na voljo imate še <xliff:g id="NUMBER_1">%d</xliff:g> poskus.</item>
      <item quantity="two">Napačna koda PIN kartice SIM. Na voljo imate še <xliff:g id="NUMBER_1">%d</xliff:g> poskusa.</item>
      <item quantity="few">Napačna koda PIN kartice SIM. Na voljo imate še <xliff:g id="NUMBER_1">%d</xliff:g> poskuse.</item>
      <item quantity="other">Napačna koda PIN kartice SIM. Na voljo imate še <xliff:g id="NUMBER_1">%d</xliff:g> poskusov.</item>
    </plurals>
    <string name="pin_failed" msgid="1848423634948587645">"Postopek za odklepanje s kodo PIN kartice SIM ni uspel."</string>
    <string name="device_info_settings" product="tablet" msgid="1119755927536987178">"Stanje tabličnega računalnika"</string>
    <string name="device_info_settings" product="default" msgid="475872867864762157">"Stanje telefona"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Sistemske posodobitve"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Različica sistema Android"</string>
    <string name="firmware_title" msgid="5203122368389157877">"Android"</string>
    <string name="security_patch" msgid="8438384045870296634">"Raven popravkov za varnost v Androidu"</string>
    <string name="model_info" msgid="1952009518045740889">"Model"</string>
    <string name="model_summary" msgid="8306235877567782987">"Model: %1$s"</string>
    <string name="hardware_info" msgid="2605080746512527805">"Model in strojna oprema"</string>
    <string name="hardware_revision" msgid="8893547686367095527">"Različica strojne opreme"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID opreme"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Različica radijske programske opreme"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Različica jedra"</string>
    <string name="build_number" msgid="3075795840572241758">"Delovna različica"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"Ni na voljo"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Stanje"</string>
    <string name="device_status" msgid="607405385799807324">"Stanje"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Stanje akumulatorja in omrežja ter drugi podatki"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Telefonska številka, signal itn."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Shramba"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Shramba"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Nastavitve shrambe"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Izpni pomnilnik USB, prikaži razpoložljiv pomnilnik"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Izpenjanje kartice SD, prikaz razpoložljivega pomnilnika"</string>
    <string name="imei_multi_sim" msgid="6387012961838800539">"IMEI (reža za kartico SIM %1$d)"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5948892105546651296">"Telefonska številka"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="2755592991367858860">"MDN (reža za kartico SIM %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="1898212200138025729">"Tel. št. (reža za SIM %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="1367110147304523864">"Številka MDN na kartici SIM"</string>
    <string name="status_number_sim_status" product="default" msgid="9123351360569466330">"Telefonska št. na kartici SIM"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Različica seznama prednostnih omrežij za gostovanje"</string>
    <string name="meid_multi_sim" msgid="748999971744491771">"MEID (reža za kartico SIM %1$d)"</string>
    <string name="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_data_network_type" msgid="7570837037428932780">"Vrsta mobilnega omrežja za prenos podatkov"</string>
    <string name="status_voice_network_type" msgid="5663112239742353547">"Vrsta mobilnega omrežja za glasovni klic"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Podatki operaterja"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Stanje mobilnega omrežja"</string>
    <string name="status_esim_id" msgid="6456255368300906317">"EID"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Stanje storitve"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Moč signala"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Gostovanje"</string>
    <string name="status_operator" msgid="2274875196954742087">"Omrežje"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Naslov MAC vmesnika Wi‑Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Naslov Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Serijska številka"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Čas delovanja"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Čas delovanja"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Notranja shramba"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Pomnilnik USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Kartica SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"Na voljo"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Na voljo (samo za branje)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Skupno prostora"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Izračunavanje ..."</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Aplikacije in podatki o aplikacijah"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Predstavnost"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Prenosi"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Slike, videoposnetki"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Zvok (glasba, melodije zvonjenja, podcasti ipd.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Druge datoteke"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Predpomnjeni podatki"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Izpni skupno shrambo"</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Izpni kartico SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Izpni notranji pomnilnik USB"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Izpni kartico SD, da jo lahko varno odstranim"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Vstavite pomnilnik USB za vpenjanje"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Vstavite kartico SD, da bo vpeta"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Vpni pomnilnik USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Vpni kartico SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Izbriši pomnilnik USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Izbriši kartico SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Izbriše vse podatke na notranjem pomnilniku USB, na primer glasbo ali fotografije"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Izbriše vse podatke na kartici SD, na primer glasbo ali fotografije"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"Želite počistiti predpomnjene podatke?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Počistili boste predpomnjene pod. vseh aplikacij."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"Funkcija MTP ali PTP je aktivna"</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"Želite izpeti pomnilnik USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"Želite izpeti kartico SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"Če izpnete pomnilnik USB, bodo nekatere aplikacije, ki jih uporabljate, nehale delovati in ne bodo na voljo, dokler pomnilnika USB spet ne vpnete."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="6998379994779187692">"Če izpnete kartico SD, se bodo nekatere aplikacije, ki jih uporabljate, ustavile in morda ne bodo na voljo, dokler znova ne vpnete kartice SD."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="9191518889746166147">"Pomnilnika USB ni bilo mogoče izpeti. Poskusite znova pozneje."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"Kartice SD ni mogoče izpeti. Poskusite znova pozneje."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"Pomnilnik USB bo izpet."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Kartica SD bo izpeta."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Izpenjanje"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Izpenjanje poteka"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Prostor za shranjevanje bo pošel"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"Nekatere sistemske funkcije, na primer sinhronizacija, morda ne delujejo pravilno. Poskusite sprostiti nekaj prostora tako, da zbrišete ali odpnete elemente, kot so aplikacije ali medijska vsebina."</string>
    <string name="storage_menu_rename" msgid="7141058657592615390">"Preimenovanje"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Vpenjanje"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Izvrzi"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Formatiraj"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Formatiraj kot prenosno shram."</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formatiraj kot notranjo shram."</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Preseli podatke"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Pozabi"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Nastavi"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Razišči"</string>
    <string name="storage_menu_free" msgid="6386070442027135427">"Sprostitev prostora"</string>
    <string name="storage_menu_manage" msgid="5914482953856430780">"Upravljanje shrambe"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Povezava USB z računalnikom"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Vzpostavi povezavo kot"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Predstavnostna naprava (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"V sistemu Windows lahko prenašate predstavnostne datoteke ali v računalniku Mac uporabite Android File Transfer (glejte www.android.com/filetransfer)"</string>
    <string name="usb_ptp_title" msgid="3852760810622389620">"Fotoaparat (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"Omogoča prenos fotografij s programsko opremo fotoaparata in prenos datotek v računalnikih, ki ne podpirajo protokola MTP"</string>
    <string name="usb_midi_title" msgid="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Omogoča, da aplikacije, ki podpirajo MIDI, delujejo prek povezave USB s programsko opremo za MIDI v računalniku."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Drugi uporabniki"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Shramba naprave"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Prenosna shramba"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"Uporabljeno <xliff:g id="USED">%1$s</xliff:g> od <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="storage_size_large" msgid="5691585991420946254">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="1303803057698959872">"Uporabljeno od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"Skupaj uporabljeno od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"Vpeto: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"Tega ni bilo mogoče vpeti: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"To je varno izvrženo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"Tega ni bilo mogoče varno izvreči: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_format_success" msgid="3023144070597190555">"To je formatirano: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"Tega ni bilo mogoče formatirati: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Preimenovanje shrambe"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"Naprava za shranjevanje <xliff:g id="NAME_0">^1</xliff:g> je varno izvržena, vendar je še vedno na voljo. \n\nČe želite uporabljati napravo za shranjevanje <xliff:g id="NAME_1">^1</xliff:g>, jo morate najprej vpeti."</string>
    <string name="storage_dialog_unmountable" msgid="3732209361668282254">"Naprava za shranjevanje <xliff:g id="NAME_0">^1</xliff:g> je poškodovana. \n\nČe želite uporabljati napravo za shranjevanje <xliff:g id="NAME_1">^1</xliff:g>, jo morate najprej nastaviti."</string>
    <string name="storage_dialog_unsupported" msgid="4503128224360482228">"Ta naprava ne podpira naprave za shranjevanje <xliff:g id="NAME_0">^1</xliff:g>. \n\nČe želite uporabljati napravo za shranjevanje <xliff:g id="NAME_1">^1</xliff:g> s to napravo, jo morate najprej nastaviti."</string>
    <string name="storage_internal_format_details" msgid="4018647158382548820">"Po formatiranju lahko uporabljate to shrambo (<xliff:g id="NAME_0">^1</xliff:g>) v drugih napravah. \n\nVsi podatki v tej shrambi (<xliff:g id="NAME_1">^1</xliff:g>) bodo izbrisani. Priporočamo, da podatke prej varnostno kopirate. \n\n"<b>"Varnostno kopiranje fotografij in druge predstavnosti"</b>" \nPremaknite predstavnostne datoteke v drugo shrambo v tej napravi ali jih s kablom USB prenesite v računalnik. \n\n"<b>"Varnostno kopiranje aplikacij"</b>" \nVse aplikacije, shranjene v tej shrambi (<xliff:g id="NAME_6">^1</xliff:g>), bodo odstranjene in podatki aplikacij izbrisani. Če želite ohraniti te aplikacije, jih premaknite v drugo shrambo v tej napravi."</string>
    <string name="storage_internal_unmount_details" msgid="3582802571684490057"><b>"Ko izvržete to shrambo (<xliff:g id="NAME_0">^1</xliff:g>), bodo aplikacije, shranjene na njej, prenehale delovati, predstavnostne datoteke, shranjene na njej, pa ne bodo na voljo, dokler je ne vstavite znova."</b>\n\n"Shramba <xliff:g id="NAME_1">^1</xliff:g> je formatirana tako, da deluje samo v tej napravi. V drugih ne bo delovala."</string>
    <string name="storage_internal_forget_details" msgid="9028875424669047327">"Če želite uporabljati aplikacije, fotografije ali podatke v shrambi <xliff:g id="NAME">^1</xliff:g>, jo znova vstavite. \n\nČe naprava ni na voljo, lahko izberete, da je ta shramba pozabljena. \n\nČe izberete, da je pozabljena, bodo vsi podatki, ki jih vsebuje naprava, za vedno izgubljeni. \n\nAplikacije lahko pozneje znova namestite, toda podatki, shranjeni v napravi, bodo izgubljeni."</string>
    <string name="storage_internal_forget_confirm_title" msgid="1370847944388479245">"Opustitev naprave za shr. <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"Vse aplikacije, fotografije in podatki, shranjeni v napravi za shranjevanje <xliff:g id="NAME">^1</xliff:g>, bodo za vedno izgubljeni."</string>
    <string name="storage_detail_apps" msgid="6141154016753507490">"Aplikacije"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Slike"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Videoposnetki"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Zvok"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Predpomnjeni podatki"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Drugo"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Sistem"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Razišči: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="8845766044697204852">"Med druge datoteke spadajo datoteke v skupni rabi, ki jih shranijo aplikacije, datoteke, ki jih prenesete iz interneta ali prek Bluetootha, datoteke sistema Android in druge. \n\nČe si želite ogledati vidno vsebino te naprave za shranjevanje <xliff:g id="NAME">^1</xliff:g>, se dotaknite »Razišči«."</string>
    <string name="storage_detail_dialog_system" msgid="862835644848361569">"Sistem vključuje datoteke, ki se uporabljajo za izvajanje Androida različice <xliff:g id="VERSION">%s</xliff:g>."</string>
    <string name="storage_detail_dialog_user" msgid="3267254783294197804">"Uporabnik <xliff:g id="USER_0">^1</xliff:g> je morda shranil fotografije, glasbo, aplikacije ali druge podatke, za kar je porabil <xliff:g id="SIZE">^2</xliff:g> shrambe. \n\nČe si želite ogledati podrobnosti, preklopite na uporabnika <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="5085400514028585772">"Nastavitev imena za: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Uporaba kot prenosna shramba"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"Za premikanje fotografij in druge predstavnosti med napravami."</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Uporaba kot notranja shramba"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"Za shranjevanje česar koli samo v tej napravi, vključno z aplikacijami in fotografijami. Zahteva formatiranje, ki onemogoča delovanje z drugimi napravami."</string>
    <string name="storage_wizard_format_confirm_title" msgid="2814021794538252546">"Format. kot notranja shramba"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"Če želite, da bo shramba <xliff:g id="NAME_0">^1</xliff:g> varna, jo morate formatirati. \n\nPo formatiranju bo ta shramba (<xliff:g id="NAME_1">^1</xliff:g>) delovala samo v tej napravi. \n\n"<b>"S formatiranjem se izbrišejo vsi podatki, ki so trenutno shranjeni v shrambi (<xliff:g id="NAME_2">^1</xliff:g>)."</b>" Če se želite izogniti izgubi podatkov, priporočamo, da jih varnostno kopirate."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="4905690038882041566">"Formatiranje kot prenosno shrambo"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"Za ta namen morate shrambo <xliff:g id="NAME_0">^1</xliff:g> formatirati. \n\n"<b>"S formatiranjem bodo izbrisani vsi podatki, shranjeni v shrambi <xliff:g id="NAME_1">^1</xliff:g>."</b>" Če se želite izogniti izgubi podatkov, priporočamo, da jih varnostno kopirate."</string>
    <string name="storage_wizard_format_confirm_next" msgid="2774557300531702572">"Izbris in formatiranje"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"Formatiranje shrambe <xliff:g id="NAME">^1</xliff:g> …"</string>
    <string name="storage_wizard_format_progress_body" msgid="5255269692453900303">"Med formatiranjem ne odstranite nosilca <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Premik podatkov v novo shrambo"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"Fotografije, datoteke in nekatere aplikacije lahko premaknete v novo shrambo <xliff:g id="NAME">^1</xliff:g>. \n\nPremik traja približno <xliff:g id="TIME">^2</xliff:g> in bo sprostil <xliff:g id="SIZE">^3</xliff:g> prostora v notranji shrambi. Nekatere aplikacije med premikanjem ne bodo delovale."</string>
    <string name="storage_wizard_migrate_now" msgid="4523444323744239143">"Premik zdaj"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Premik pozneje"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Premik podatkov"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><b>"Premik traja približno <xliff:g id="TIME">^1</xliff:g>. Sprostil bo <xliff:g id="SIZE">^2</xliff:g> prostora v shrambi <xliff:g id="NAME">^3</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="5509475628423823202">"Premik"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Premikanje podatkov …"</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"Med premikanjem: \n• Ne odstranite shrambe (<xliff:g id="NAME">^1</xliff:g>). \n• Nekatere aplikacije ne bodo delovale pravilno. \n• Naprava naj bo napolnjena."</string>
    <string name="storage_wizard_ready_title" msgid="6553867088682695655">"Nosilec <xliff:g id="NAME">^1</xliff:g> je pripravljen za uporabo"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"Shramba <xliff:g id="NAME">^1</xliff:g> je pripravljena za uporabo s fotografijami in drugo predstavnostjo."</string>
    <string name="storage_wizard_ready_internal_body" msgid="122532674037860197">"Nova shramba <xliff:g id="NAME">^1</xliff:g> deluje. \n\nČe želite premikati fotografije, datoteke in podatke aplikacij vanjo, odprite »Nastavitve« &gt; »Shramba«."</string>
    <string name="storage_wizard_move_confirm_title" msgid="292782012677890250">"Premik aplikacije <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"Premik aplikacije <xliff:g id="APP">^1</xliff:g> in njenih podatkov v shrambo <xliff:g id="NAME_0">^2</xliff:g> bo trajal samo nekaj trenutkov. Dokler premik ne bo dokončan, aplikacije ne bo mogoče uporabljati. \n\nShrambe <xliff:g id="NAME_1">^2</xliff:g> med premikanjem ne odstranite."</string>
    <string name="storage_wizard_move_unlock" msgid="1526216561023200694">"Če želite premakniti podatke, morate odkleniti uporabnika <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="4443920302548035674">"Premikanje aplikacije <xliff:g id="APP">^1</xliff:g> …"</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"Shrambe <xliff:g id="NAME">^1</xliff:g> med premikanjem ne odstranite. \n\nAplikacija <xliff:g id="APP">^2</xliff:g> v tej napravi ne bo na voljo, dokler premik ne bo dokončan."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="542047237524588792">"Preklic premika"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"Ta shramba <xliff:g id="NAME_0">^1</xliff:g> je videti počasna. \n\nLahko nadaljujete, vendar se bodo aplikacije, premaknjene na to lokacijo, morda zatikale, prenos podatkov pa bo dolgotrajen. \n\nRazmislite o uporabi hitrejše shrambe <xliff:g id="NAME_1">^1</xliff:g>, če želite boljše delovanje."</string>
    <string name="storage_wizard_init_v2_title" msgid="8858395869710288372">"Kako želite uporabljati nosilec <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="4315585580670552654">"Uporabi kot dodatno shrambo v tabličnem računalniku"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="570443086512059390">"Samo za aplikacije, datoteke in predstavnost v tej tablici"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="7760758592993284143">"Shramba tabličnega računalnika"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="8373070138732653456">"Uporabi kot dodatno shrambo v telefonu"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="685194340141573218">"Samo za aplikacije, datoteke in predstavnost v tem telefonu"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="904425171564310150">"Pomnilnik telefona"</string>
    <string name="storage_wizard_init_v2_or" msgid="1958295749349454436">"ali"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="3565348221712759463">"Uporabi kot prenosno shrambo"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="801198071793584445">"Za prenašanje datotek in predstavnosti med napravami"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="8662451480642784031">"Prenosna shramba"</string>
    <string name="storage_wizard_init_v2_later" msgid="1080613420170749130">"Nastavi pozneje"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="5744790239994621663">"Želite formatirati ta nosilec: <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="4614199613500900975">"Če želite shranjevati aplikacije, datoteke in predstavnost, morate nosilec <xliff:g id="NAME_0">^1</xliff:g> formatirati. \n\nS formatiranjem boste izbrisali obstoječo vsebino v nosilcu <xliff:g id="NAME_1">^2</xliff:g>. Da bi se izognili izgubi vsebine, jo varnostno kopirajte v drug nosilec <xliff:g id="NAME_2">^3</xliff:g> ali napravo."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="8258363472135537500">"Formatiraj <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="31406330052996898">"Želite premakniti vsebino v nos. <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4476553430145054781">"V nosilec <xliff:g id="NAME">^1</xliff:g> lahko premaknete datoteke, predstavnost in določene aplikacije. \n\nS tem premikom boste v shrambi tabličnega računalnika sprostili do <xliff:g id="SIZE">^2</xliff:g>. Premikanje bo trajalo približno <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="744760728669284385">"V nosilec <xliff:g id="NAME">^1</xliff:g> lahko premaknete datoteke, predstavnost in nekatere aplikacije. \n\nS tem premikom boste v shrambi telefona sprostili do <xliff:g id="SIZE">^2</xliff:g>. Premikanje bo trajalo približno <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="1239103359606165360">"Med premikanjem:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="7176991995007075843">"Ne odstranite nosilca <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="3671266712947078734">"Nekatere aplikacije ne bodo delovale"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="346012901366624052">"Naj bo ta tablični računalnik napolnjen"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="3061158350109289521">"Naj bo ta telefon napolnjen"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="1279041707982039591">"Premakni vsebino"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="8201360307047198853">"Premakni vsebino pozneje"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="1323344099111423785">"Premikanje vsebine …"</string>
    <string name="storage_wizard_slow_v2_title" msgid="1318285829973607727">"Počasna naprava za shranjevanje <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="6897444467730463117">"Nosilec <xliff:g id="NAME_0">^1</xliff:g> lahko še vedno uporabljate, vendar bo morda počasen. \n\nAplikacije, shranjene v nosilcu <xliff:g id="NAME_1">^2</xliff:g>, morda ne bodo pravilno delovale, prenos vsebine pa bo morda dolgotrajen. \n\nPoskusite uporabiti hitrejši nosilec <xliff:g id="NAME_2">^3</xliff:g> ali pa nosilec <xliff:g id="NAME_3">^4</xliff:g> uporabite kot prenosno shrambo."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="4126873669723115805">"Začni znova"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="49399942893518218">"Naprej"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="11937346870534608">"Vsebino lahko premaknete v nosilec <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="4658433206901211269">"Če želite vsebino premakniti v nosilec <xliff:g id="NAME">^1</xliff:g>, pojdite na "<b>"Nastavitve &gt; Shramba"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="6239886818487538806">"Vsebina je bila premaknjena v nosilec <xliff:g id="NAME_0">^1</xliff:g>. \n\nČe želite upravljati nosilec <xliff:g id="NAME_1">^2</xliff:g>, pojdite v "<b>"Nastavitve &gt; Shramba"</b>"."</string>
    <string name="battery_status_title" msgid="9159414319574976203">"Stanje akumulatorja"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Raven napolnjenosti akumulatorja"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN-ji"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Uredi dostopno točko"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"Ni nastavljeno"</string>
    <string name="apn_name" msgid="4115580098369824123">"Ime"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Strežnik proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Vrata"</string>
    <string name="apn_user" msgid="455637547356117761">"Uporabniško ime"</string>
    <string name="apn_password" msgid="5412301994998250968">"Geslo"</string>
    <string name="apn_server" msgid="2436185314756372858">"Strežnik"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"Storitveni center za sporočila MMS"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Strežnik proxy za sporočila MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Vrata MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"Mobilna koda države"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"Koda mobilnega omrežja"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Vrsta preverjanja pristnosti"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Brez"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP ali CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Vrsta APN-ja"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protokol APN za gostovanje"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Omogoči/onemogoči APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN omogočen"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN onemogočen"</string>
    <string name="bearer" msgid="594270280031923558">"Nosilec"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Vrsta MVNO"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Vrednost MVNO"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Izbriši APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"Nov APN"</string>
    <string name="menu_save" msgid="8109345640668285399">"Shrani"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Zavrzi"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"Polje z imenom ne sme biti prazno."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"APN ne sme biti prazen."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"Polje z mobilno kodo države mora vsebovati 3 števke."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"Polje s kodo mobilnega omrežja mora vsebovati 2 ali 3 števke."</string>
    <string name="error_adding_apn_type" msgid="4181334016628549645">"Operater ne podpira dodajanja APN-jev vrste %s."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Obnavljanje privzetih nastavitev APN-jev"</string>
    <string name="menu_restore" msgid="8260067415075573273">"Ponastavi na privzeto"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Ponastavitev privzetih nastavitev APN-jev končana"</string>
    <string name="reset_dashboard_title" msgid="6254873816990678620">"Možnosti ponastavitve"</string>
    <string name="reset_dashboard_summary" msgid="4851012632493522755">"Ponastavite lahko omrežje, aplikacije ali napravo"</string>
    <string name="reset_network_title" msgid="6166025966016873843">"Ponastavi Wi-Fi, mob. podatke in Bluetooth"</string>
    <string name="reset_network_desc" msgid="5547979398298881406">"S tem boste ponastavili vse omrežne nastavitve, vključno s temi:\n\n"<li>"Wi‑Fi"</li>\n<li>"Prenos podatkov v mobilnih omrežjih"</li>\n<li>"Bluetooth"</li></string>
    <string name="reset_esim_title" msgid="2419812515540592802">"Ponastavi tudi kartico e-SIM"</string>
    <string name="reset_esim_desc" msgid="6412324670559060446">"Iz telefona boste izbrisali vse digitalne kartice e-SIM. Za vnovičen prenos digitalnih kartic e-SIM se boste morali obrniti na operaterja. Z izbrisom ne boste prekinili naročniškega paketa za mobilno telefonijo."</string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Ponastavi nastavitve"</string>
    <string name="reset_network_final_desc" msgid="6388371121099245116">"Ali želite ponastaviti vse omrežne nastavitve? Tega dejanja ni mogoče razveljaviti."</string>
    <string name="reset_network_final_button_text" msgid="1797434793741744635">"Ponastavi nastavitve"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"Želite ponastaviti?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"Ponastavitev omrežnih nastavitev ni na voljo za tega uporabnika"</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Omrežne nastavitve so ponastavljene"</string>
    <!-- no translation found for reset_esim_error_title (7192618265425728179) -->
    <skip />
    <!-- no translation found for reset_esim_error_msg (4513391470683673969) -->
    <skip />
    <string name="master_clear_title" msgid="3531267871084279512">"Izbriši vse podatke (tovarniška ponastavitev)"</string>
    <string name="master_clear_short_title" msgid="8652450915870274285">"Izbriši vse podatke"</string>
    <string name="master_clear_desc" product="tablet" msgid="9146059417023157222">"S tem boste iz "<b>"notranjega pomnilnika"</b>" tabličnega računalnika izbrisali vse podatke:\n\n"<li>"Google Račun"</li>\n<li>"Podatke in nastavitve sistema in aplikacij"</li>\n<li>"Prenesene aplikacije"</li></string>
    <string name="master_clear_desc" product="default" msgid="4800386183314202571">"S tem boste iz "<b>"notranjega pomnilnika"</b>" telefona izbrisali vse podatke:\n\n"<li>"Google Račun"</li>\n<li>"Podatki in nastavitve sistema in aplikacij"</li>\n<li>"Prenesene aplikacije"</li></string>
    <string name="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Trenutno ste prijavljeni v te račune:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"V napravi so prisotni drugi uporabniki.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Glasba"</li>\n<li>"Fotografije"</li>\n<li>"Drugi uporabniški podatki"</li></string>
    <string name="master_clear_desc_also_erases_esim" msgid="6008213558725767177"><li>"Digitalne kartice e-SIM"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="5460926449093211144">\n\n"S tem ne boste prekinili naročniškega paketa za mobilno telefonijo."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\n\n"Če želite izbrisati glasbo, slike in druge uporabniške podatke, morate izbrisati "<b>"pomnilnik USB"</b>"."</string>
    <string name="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\n\n"Če želite izbrisati glasbo, slike in druge uporabniške podatke, morate izbrisati "<b>"kartico SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="969364037450286809">"Izbriši pomnilnik USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Izbriši kartico SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Izbriši vse podatke v notranjem pomnilniku USB, na primer glasbo ali fotografije."</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Izbriši vse podatke na kartici SD, na primer glasbo ali fotografije."</string>
    <string name="erase_esim_storage" msgid="5684858600215441932">"Izbriši kartico e-SIM"</string>
    <string name="erase_esim_storage_description" product="default" msgid="708691303677321598">"Brisanje vseh kartic e-SIM v telefonu. S tem ne boste prekinili naročniškega paketa za mobilno telefonijo."</string>
    <string name="erase_esim_storage_description" product="tablet" msgid="1780953956941209107">"Brisanje vseh kartic e-SIM v tabličnem računalniku. S tem ne boste prekinili naročniškega paketa za mobilno telefonijo."</string>
    <string name="master_clear_button_text" product="tablet" msgid="3130786116528304116">"Ponastavi tablični računalnik"</string>
    <string name="master_clear_button_text" product="default" msgid="7550632653343157971">"Ponastavi telefon"</string>
    <string name="master_clear_final_desc" msgid="7318683914280403086">"Želite izbrisati vse osebne podatke in prenesene aplikacije? Tega dejanja ni mogoče razveljaviti."</string>
    <string name="master_clear_final_button_text" msgid="5390908019019242910">"Izbriši vse"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"Ponastavitev ni opravljena, ker storitev System Clear ni na voljo."</string>
    <string name="master_clear_confirm_title" msgid="7572642091599403668">"Želite ponastaviti?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"Ponastavitev na tovarniške nastavitve ni na voljo za tega uporabnika"</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Brisanje"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Počakajte ..."</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Nastavitve klicanja"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Nastavite telefonski predal, preusmeritev klicev, čakajoči klic, ID klicatelja"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Internet prek USB-ja"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Prenosna dostopna točka"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Internet prek Bluetootha"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Internet prek mob. napr."</string>
    <string name="tether_settings_title_all" msgid="3058586928118801157">"Dostopna točka in skupna raba mobilnega interneta"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="930464462687425777">"Dostopna točka je vklopljena, internetna povezava prek telefona"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Dostopna točka je vklopljena"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="1618256180720077354">"Internetna povezava prek telefona"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"Dokler je vklopljeno varčevanje s podatki, ni mogoče vzpostaviti povezave z internetom prek mobilnega telefona ali uporabljati prenosnih dostopnih točk."</string>
    <string name="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Internetna povezava prek USB"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3711893746716442706">"Skupna raba internetne povezave telefona prek USB-ja"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="2292916486612255069">"Skupna raba internetne povezave tabličnega računalnika prek USB-ja"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Internet prek Bluetootha"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="8828883800511737077">"Skupna raba internetne povezave tabličnega računalnika prek Bluetootha"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="1904667146601254812">"Skupna raba internetne povezave telefona prek Bluetootha"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="376389105752995580">"Skupna raba internetne povezave naprave <xliff:g id="DEVICE_NAME">%1$d</xliff:g> prek Bluetootha"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="2135590598511178690">"Internetna povezava ni mogoča z več kot <xliff:g id="MAXCONNECTION">%1$d</xliff:g> naprav."</string>
    <string name="bluetooth_untether_blank" msgid="2871192409329334813">"Internetna povezava z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> bo prekinjena."</string>
    <string name="tethering_footer_info" msgid="7112228674056306147">"Uporabite dostopno točko in povezavo z internetom prek mobilnega telefona, da zagotovite internet drugim napravam prek svoje mobilne podatkovne povezave. Tudi aplikacije lahko ustvarijo dostopno točko za skupno rabo vsebin z napravami v bližini."</string>
    <string name="tethering_help_button_text" msgid="656117495547173630">"Pomoč"</string>
    <string name="network_settings_title" msgid="2876509814832830757">"Mobilno omrežje"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Naročniški paket za mobilno napravo"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"Aplikacija za SMS-je"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"Ali želite zamenjati aplikacijo za sporočila SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"Ali želite za SMS-e namesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> uporabljati aplikacijo <xliff:g id="NEW_APP">%1$s</xliff:g>?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="602683880284921998">"Ali želite za SMS-e uporabljati aplikacijo <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="network_scorer_picker_title" msgid="6383879578279046456">"Ponudnik ocenjevanja omrežij"</string>
    <string name="network_scorer_picker_none_preference" msgid="9028375117241790936">"Brez"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"Želite zamenjati Pomočnika za Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"Želite za upravljanje omrežnih povezav namesto aplikacije <xliff:g id="CURRENT_APP">%2$s</xliff:g> uporabljati aplikacijo <xliff:g id="NEW_APP">%1$s</xliff:g>?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="7444620909047611601">"Želite za upravljanje omrežnih povezav uporabljati aplikacijo <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Neznan ponudnik kartice SIM"</string>
    <string name="mobile_no_provisioning_url" msgid="9053814051811634125">"<xliff:g id="OPERATOR">%1$s</xliff:g> nima znanega splet. mesta za omogočanje uporabe"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Vstavite SIM in znova zaženite"</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Vzpostavite internetno povezavo"</string>
    <string name="location_title" msgid="1029961368397484576">"Moja lokacija"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Mesto za delovni profil"</string>
    <string name="location_app_level_permissions" msgid="1825588230817081339">"Dovoljenja na ravni aplikacije"</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Nedavne zahteve za lokacijo"</string>
    <string name="location_recent_location_requests_see_all" msgid="9063541547120162593">"Pokaži vse"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"V zadnjem času ni nobena aplikacija zahtevala lokacijskih podatkov"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Lokacijske storitve"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Visoka poraba akumulatorja"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Nizka poraba akumulatorja"</string>
    <string name="location_scanning_screen_title" msgid="4408076862929611554">"Iskanje"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Iskanje omrežij Wi‑Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="2691110218127379249">"Aplikacijam in storitvam omogoči, da kadar koli iščejo omrežja Wi-Fi v bližini, tudi ko je Wi-Fi izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Iskanje naprav Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="1285526059945206128">"Aplikacijam in storitvam omogoči, da kadar koli iščejo naprave v bližini, tudi ko je Bluetooth izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo."</string>
    <string name="location_network_based" msgid="9134175479520582215">"Lokacija Wi-Fi-ja in mob. omr."</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"Aplikacijam omogočite hitrejše določanje lokacije z Googlovo storitvijo za določanje lokacije. Anonimni podatki o lokaciji bodo zbrani in poslani Googlu."</string>
    <string name="location_neighborhood_level_wifi" msgid="4234820941954812210">"Določanje lokacije z Wi‑Fi-jem"</string>
    <string name="location_gps" msgid="8392461023569708478">"Sateliti GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"Za določanje lokacije omogočite aplikacijam uporabo GPS-a v tabličnem računalniku"</string>
    <string name="location_street_level" product="default" msgid="4617445745492014203">"Za določanje lokacije omogočite aplikacijam uporabo GPS-a v telefonu"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Uporabljaj GPS s pomočjo"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"Uporabljaj strežnik za pomoč pri sistemu GPS (ne označite, da zmanjšate uporabo omrežja)"</string>
    <string name="assisted_gps_disabled" msgid="6982698333968010748">"Uporabi strežnik za pomoč pri uporabi sistema GPS (ne označite, da izboljšate delovanje sistema GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Lokacija in Iskanje Google"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Naj Google uporablja vašo lokacijo za izboljšanje rezultatov iskanja in drugih storitev"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Dostop do moje lokacije"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Aplikacije, ki prosijo za vaše dovoljenje, lahko uporabijo podatke o lokaciji"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Viri lokacije"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"O tabličnem računalniku"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"O telefonu"</string>
    <string name="about_settings" product="device" msgid="6717640957897546887">"O napravi"</string>
    <string name="about_settings" product="emulator" msgid="221313099578564438">"O emulirani napravi"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Ogled pravnih informacij, stanja, različice programske opreme"</string>
    <string name="legal_information" msgid="5769301644270604095">"Pravne informacije"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Sodelavci"</string>
    <string name="manual" msgid="3025943393642974445">"Ročno"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Zakonsko predpisane oznake"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Priročnik z varn. in zak. predpis. inf."</string>
    <string name="copyright_title" msgid="865906688917260647">"Avtorska pravica"</string>
    <string name="license_title" msgid="1990487604356037871">"Licenca"</string>
    <string name="terms_title" msgid="7697580845616764642">"Določila in pogoji"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Licenca za WebView v sistemu"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Ozadja"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Ponudniki satelitskih posnetkov: \n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Priročnik"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Težava pri nalaganju priročnika."</string>
    <string name="settings_license_activity_title" msgid="8525014571806471216">"Licence drugih ponudnikov"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Pri nalaganju licenc je prišlo do težave."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Nalaganje …"</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Informacije o varnosti"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Informacije o varnosti"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="142307697309858185">"Nimate podatkovne povezave. Če si želite te informacije ogledati zdaj, obiščite %s v katerem koli računalniku z vzpostavljeno internetno povezavo."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Nalaganje …"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="2942199737559900752">"Nastavitev zaklepanja zaslona"</string>
    <string name="lockpassword_choose_your_password_message" msgid="5377842480961577542">"Zaradi varnosti nastavite geslo"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="6624409510609085450">"Nastavite geslo za prstni odtis"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="5901096361617543819">"Nastavite vzorec za prstni odtis"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="6658264750811929338">"Zaradi varnosti nastavite kodo PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="765344692615917183">"Nastavite kodo PIN za prstni odtis"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="8631545254345759087">"Zaradi varnosti nastavite vzorec"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="1266027268220850931">"Znova vnesite geslo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potrdite vzorec"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="7744513791910572550">"Znova vnesite kodo PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Gesli se ne ujemata"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"Kodi PIN se ne ujemata"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="2872194349688886781">"Znova narišite vzorec"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Izbira načina odklepanja"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Geslo je nastavljeno"</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Koda PIN je nastavljena"</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Vzorec je nastavljen"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Če želite nadaljevati, uporabite vzorec za napravo"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Če želite nadaljevati, vnesite kodo PIN za napravo"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Če želite nadaljevati, vnesite geslo za napravo"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Če želite nadaljevati, uporabite vzorec za delovni profil"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Če želite nadaljevati, vnesite kodo PIN za delovni profil"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Če želite nadaljevati, vnesite geslo za delovni profil"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="530802132223800623">"Zaradi večje varnosti vnesite vzorec za to napravo"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="7829294830078036417">"Zaradi večje varnosti vnesite kodo PIN za to napravo"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="3552644641574796973">"Zaradi večje varnosti vnesite geslo za to napravo"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="3003781907040522053">"Zaradi večje varnosti vnesite vzorec za delovni profil"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="3367491332598821552">"Zaradi večje varnosti vnesite kodo PIN za delovni profil"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="8159775129968582940">"Zaradi večje varnosti vnesite geslo za delovni profil"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6757336656791723193">"Telefon je bil ponastavljen na tovarniške nastavitve. Če želite uporabljati ta telefon, vnesite prejšnji vzorec."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="826520613445990470">"Telefon je bil ponastavljen na tovarniške nastavitve. Če želite uporabljati ta telefon, vnesite prejšnjo kodo PIN."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="8944081074615739040">"Telefon je bil ponastavljen na tovarniške nastavitve. Če želite uporabljati ta telefon, vnesite prejšnje geslo."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="2898036091609128286">"Potrdite vzorec"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="4141601774778898803">"Potrdite PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="3762615419295360480">"Potrdite geslo"</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"Napačna koda PIN"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Napačno geslo"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Napačen vzorec"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Varnost naprave"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Spremeni vzorec za odklepanje"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Spremeni kodo PIN za odklepanje"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Narišite vzorec za odklepanje"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Če želite pomoč, pritisnite meni."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Ko končate, dvignite prst"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Povežite vsaj toliko pik: <xliff:g id="NUMBER">%d</xliff:g>. Poskusite znova."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Vzorec je shranjen"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Znova narišite vzorec, da ga potrdite"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Novi vzorec za odklepanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Potrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Ponovno nariši"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Izbriši"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Naprej"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Vzorec za odklepanje"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Zahtevaj vzorec"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Za odklepanje zaslona je treba narisati vzorec"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Vzorec je viden"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="4864525074768391381">"Vzorec za profil naj bo viden"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Vibriranje ob dotiku"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Zaklepanje z vklopnim gumbom"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"Razen ko <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> poskrbi, da ostane odklenjen"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="1652352830005653447">"Nastavi vzorec za odklepanje"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Spremeni vzorec za odklepanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Kako narisati vzorec za odklepanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Preveč napačnih poskusov. Poskusite znova čez <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"Aplikacija ni nameščena v telefonu."</string>
    <string name="lock_settings_profile_title" msgid="2121876391814535295">"Varnost delovnega profila"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3334747927367115256">"Zaklepanje zaslona za delovni profil"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Uporaba enega zaklepanja"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Uporaba enega zaklepanja za delovni profil in zaslon naprave"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"Želite uporabljati eno zaklepanje?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="7128305504872026659">"Naprava bo za zaklepanje zaslona uporabljala zaklepanje delovnega profila. Delovni pravilniki bodo uporabljeni za obe zaklepanji."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="3221303098797469900">"Zaklepanje delovnega profila ne izpolnjuje varnostnih zahtev organizacije. Uporabljate lahko enako zaklepanje za zaslon naprave in delovni profil, vendar se bodo uporabili morebitni pravilniku o zaklepanju delovnega profila."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="8249970828159656518">"Uporabi eno zaklepanje"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Uporabi eno zaklepanje"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Enako kot zaklepanje zaslona naprave"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Upravljaj aplikacije"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Upravljanje in odstranjevanje nameščenih aplikacij"</string>
    <string name="applications_settings" msgid="5281808652705396152">"Podatki o aplikaciji"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Upravljanje aplikacij, nastavljanje bližnjic za hiter zagon"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Nastavitve aplikacij"</string>
    <string name="install_applications" msgid="4872012136210802181">"Neznani viri"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Dovoli vse vire aplikacij"</string>
    <string name="recent_app_category_title" msgid="6673071268966003928">"Nedavno odprte aplikacije"</string>
    <string name="see_all_apps_title" msgid="1317153498074308438">"Prikaži vse aplikacije (<xliff:g id="COUNT">%1$d</xliff:g>)"</string>
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"Neznane aplikacije lažje napadejo tablični računalnik in osebne podatke v njem. Če namestite aplikacije iz tega vira, se strinjate, da ste sami odgovorni za morebitno škodo, nastalo v tabličnem računalniku, ali izgubo podatkov, ki je lahko posledica uporabe teh aplikacij."</string>
    <string name="install_all_warning" product="default" msgid="1952257127370115988">"Neznane aplikacije lažje napadejo telefon in osebne podatke v njem. Če namestite aplikacije iz tega vira, se strinjate, da ste sami odgovorni za morebitno škodo, nastalo v telefonu, ali izgubo podatkov, ki je lahko posledica uporabe teh aplikacij."</string>
    <string name="install_all_warning" product="device" msgid="3648003301476423145">"Neznane aplikacije lažje napadejo napravo in osebne podatke v njej. Če namestite aplikacije iz tega vira, se strinjate, da ste sami odgovorni za morebitno škodo, nastalo v napravi, ali izgubo podatkov zaradi uporabe teh aplikacij."</string>
    <string name="advanced_settings" msgid="1777249286757067969">"Dodatne nastavitve"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Omogoči več možnosti nastavitev."</string>
    <string name="application_info_label" msgid="5736524913065714880">"Podatki o aplikaciji"</string>
    <string name="storage_label" msgid="8700867073480107253">"Prostor za shranjevanje"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Privzeto odpiranje"</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Privzete nastavitve"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Združljivost zaslona"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Dovoljenja"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Predpomnilnik"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Počisti predpomnilnik"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Predpomnilnik"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="3983110543017963732">
      <item quantity="one">%d element</item>
      <item quantity="two">%d elementa</item>
      <item quantity="few">%d elementi</item>
      <item quantity="other">%d elementov</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="8575655132961012158">"Počisti dostop"</string>
    <string name="controls_label" msgid="7611113077086853799">"Kontrolniki"</string>
    <string name="force_stop" msgid="7435006169872876756">"Prisilna ustavitev"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Skupaj"</string>
    <string name="application_size_label" msgid="7376689739076506885">"Velikost aplikacije"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplikacija na pogonu USB"</string>
    <string name="data_size_label" msgid="6117971066063850416">"Uporabniški podatki"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Podatki na pogonu USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Kartica SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Odstrani"</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Odstrani za vse uporabnike"</string>
    <string name="install_text" msgid="884360662922471113">"Namesti"</string>
    <string name="disable_text" msgid="6544054052049395202">"Onemogoči"</string>
    <string name="enable_text" msgid="9217362512327828987">"Omogoči"</string>
    <string name="clear_user_data_text" msgid="355574089263023363">"Počisti shrambo"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Odstrani posodobitve"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Izbrali ste, da se bo pri nekaterih dejanjih ta aplikacija samodejno zagnala."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Aplikaciji dovolite, da ustvari pripomočke in dostopa do njihovih podatkov."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"Ni privzetih nastavitev."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Počisti privzete nastavitve"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"Ta aplikacija morda ni namenjena za vaš zaslon. Tu lahko nastavite način prilagajanja zaslonu."</string>
    <string name="ask_compatibility" msgid="7225195569089607846">"Vprašaj, ko se zažene"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Upravljanje aplikacij"</string>
    <string name="unknown" msgid="1592123443519355854">"Neznano"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Razvrsti po imenu"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Razvrsti po velikosti"</string>
    <string name="sort_order_recent_notification" msgid="6064103501358974282">"Najnovejše"</string>
    <string name="sort_order_frequent_notification" msgid="1733204081305830670">"Najpogostejše"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Pokaži storitve, ki se izvajajo"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Pokaži predpom. procese"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Aplikacija v sili"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Ponastavi nastavitve aplikacij"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"Želite ponastaviti nastavitve aplikacij?"</string>
    <string name="reset_app_preferences_desc" msgid="4822447731869201512">"S tem bodo ponastavljene vse nastavitve za:\n\n "<li>"onemogočene aplikacije,"</li>\n" "<li>"obvestila za onemogočene aplikacije,"</li>\n" "<li>"privzete aplikacije za dejanja,"</li>\n" "<li>"omejitev prenosa podatkov v ozadju za aplikacije,"</li>\n" "<li>"omejitve dovoljenj."</li>\n\n" Podatkov iz aplikacij ne boste izgubili."</string>
    <string name="reset_app_preferences_button" msgid="2559089511841281242">"Ponastavi aplikacije"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Upravljaj prostor"</string>
    <string name="filter" msgid="2018011724373033887">"Filtriraj"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Izberite možnosti filtriranja"</string>
    <string name="filter_apps_all" msgid="8899612398848280352">"Vse aplikacije"</string>
    <string name="filter_apps_disabled" msgid="5862632369555319938">"Onemogočene aplikacije"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Preneseno"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"Se izvaja"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Pomnilnik USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"Na kartici SD"</string>
    <string name="not_installed" msgid="2797554494953450291">"Ni namešč. za tega uporabnika"</string>
    <string name="installed" msgid="3070865169422600098">"Nameščeno"</string>
    <string name="no_applications" msgid="7336588977497084921">"Ni aplikacij."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Notranja shramba"</string>
    <string name="internal_storage_sentence" msgid="889098931914857143">"notranja shramba"</string>
    <string name="sd_card_storage" product="nosdcard" msgid="2673203150465132465">"Pomnilnik USB"</string>
    <string name="sd_card_storage" product="default" msgid="7623513618171928235">"Shramba na kartici SD"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Preračunavanje velikosti ..."</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"Želite izbrisati podatke aplikacije?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"Vsi podatki te aplikacije bodo trajno izbrisani. To med drugim vključuje vse datoteke, nastavitve, račune in podatkovne zbirke."</string>
    <string name="dlg_ok" msgid="2402639055725653590">"V redu"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Prekliči"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"Aplikacije ni bilo mogoče najti na seznamu nameščenih aplikacij."</string>
    <string name="clear_failed_dlg_text" msgid="8651231637137025815">"Shrambe za aplikacijo ni bilo mogoče počistiti."</string>
    <string name="security_settings_desc" product="tablet" msgid="1292421279262430109">"Ta aplikacija ima v tabličnem računalniku dostop do:"</string>
    <string name="security_settings_desc" product="default" msgid="61749028818785244">"Ta aplikacija ima v telefonu dostop do tega:"</string>
    <string name="security_settings_desc_multi" product="tablet" msgid="7300932212437084403">"Aplikacija lahko dostopa do naslednjih elementov v vašem tabličnem računalniku. Da bi izboljšali učinkovitost in zmanjšali porabo pomnilnika, za <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> velja nekaj od teh dovoljenj, saj se izvaja v istem procesu kot <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="security_settings_desc_multi" product="default" msgid="6610268420793984752">"Aplikacija lahko dostopa do naslednjih elementov v telefonu. Da bi izboljšali učinkovitost in zmanjšali porabo pomnilnika, za <xliff:g id="BASE_APP_NAME">%1$s</xliff:g> velja nekaj od teh dovoljenj, saj se izvaja v istem procesu kot <xliff:g id="ADDITIONAL_APPS_LIST">%2$s</xliff:g>:"</string>
    <string name="join_two_items" msgid="1336880355987539064">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> in <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="1873827777191260824">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="218498527304674173">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> in <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="4333907712038448660">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="7556692394478220814">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="security_settings_billing_desc" msgid="8061019011821282358">"Ta aplikacija vam lahko zaračuna stroške:"</string>
    <string name="security_settings_premium_sms_desc" msgid="8734171334263713717">"Pošlji SMS za plačljive storitve"</string>
    <string name="computing_size" msgid="1599186977475211186">"Izračunavanje ..."</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"Velikosti paketa ni bilo mogoče izračunati."</string>
    <string name="empty_list_msg" msgid="3552095537348807772">"Nimate nameščenih aplikacij drugih ponudnikov."</string>
    <string name="version_text" msgid="9189073826278676425">"različica <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Premakni"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Premakni v tablični računalnik"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Premakni v telefon"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Premakni na pomnilnik USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Premakni na kartico SD"</string>
    <string name="moving" msgid="6431016143218876491">"Premikanje"</string>
    <string name="another_migration_already_in_progress" msgid="7817354268848365487">"Poteka že druga selitev."</string>
    <string name="insufficient_storage" msgid="481763122991093080">"Ni dovolj prostora za shranjevanje."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"Aplikacija ne obstaja."</string>
    <string name="app_forward_locked" msgid="6331564656683790866">"Aplikacija je zaščitena pred kopiranjem."</string>
    <string name="invalid_location" msgid="4354595459063675191">"Mesto namestitve ni veljavno."</string>
    <string name="system_package" msgid="1352722848400644991">"Sistemskih posodobitev ni mogoče namestiti na zunanji medij."</string>
    <string name="move_error_device_admin" msgid="8673026002690505763">"Skrbniške aplikacije naprave ni mogoče namestiti na zunanji medij."</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"Želite prisilno ustaviti?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Če boste vsilili zaustavitev aplikacije, morda ne bo pravilno delovala."</string>
    <string name="move_app_failed_dlg_title" msgid="1282561064082384192"></string>
    <string name="move_app_failed_dlg_text" msgid="187885379493011720">"Aplikacije ni bilo mogoče premakniti. <xliff:g id="REASON">%1$s</xliff:g>"</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Prednostno namestitveno mesto"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Spremenite prednostno namestitveno mesto za nove aplikacije."</string>
    <string name="app_disable_dlg_title" msgid="3916469657537695436">"Želite onemogočiti vgrajeno aplikacijo?"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Onemogočanje aplikacije"</string>
    <string name="app_disable_dlg_text" msgid="5632072173181990531">"Če onemogočite to aplikacijo, Android in druge aplikacije morda ne bodo več delovali, kot bi morali."</string>
    <string name="app_special_disable_dlg_title" msgid="2690148680327142674">"Ali želite izbrisati podatke in onemogočiti aplikacijo?"</string>
    <string name="app_special_disable_dlg_text" msgid="5832078825810635913">"Če onemogočite to aplikacijo, Android in druge aplikacije morda ne bodo več delovali, kot bi morali. Poleg tega bodo vaši podatki izbrisani."</string>
    <string name="app_disable_notifications_dlg_title" msgid="7669264654851761857">"Želite izklopiti obvestila?"</string>
    <string name="app_disable_notifications_dlg_text" msgid="5088484670924769845">"Če izklopite obvestila za to aplikacijo, boste morda zamudili pomembna opozorila in posodobitve."</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Trgovina"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Podrobnosti o aplikaciji"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"Aplikacija nameščena iz trgovine <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="4529934403276907045">"Več informacij v trgovini <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"Se izvaja"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Nikoli uporabljeno)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Ni privzetih aplikacij"</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Uporaba pomnilnika"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Ogled pomnilnika, ki ga uporabljajo aplikacije"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Ponovno zaganjanje"</string>
    <string name="cached" msgid="1059590879740175019">"Predpomnjeni procesi v ozadju"</string>
    <string name="no_running_services" msgid="2059536495597645347">"Nič se ne izvaja."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Zagnala aplikacija."</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"Prosto: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"V uporabi: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Uporabnik: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Odstranjen uporabnik"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces, <xliff:g id="NUMSERVICES">%2$d</xliff:g> storitev"</string>
    <string name="running_processes_item_description_s_p" msgid="8019860457123222953">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces, število storitev: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_item_description_p_s" msgid="744424668287252915">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesov in <xliff:g id="NUMSERVICES">%2$d</xliff:g> storitev"</string>
    <string name="running_processes_item_description_p_p" msgid="1607384595790852782">"Število procesov: <xliff:g id="NUMPROCESS">%1$d</xliff:g>, število storitev: <xliff:g id="NUMSERVICES">%2$d</xliff:g>"</string>
    <string name="running_processes_header_title" msgid="6588371727640789560">"Pomnilnik naprave"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"Poraba RAM-a za aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Prosto"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"Uporabljeno"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"Predpomnjeno"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-a"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Aplikacija, ki se izvaja"</string>
    <string name="no_services" msgid="7133900764462288263">"Nedejavno"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Storitve"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesi"</string>
    <string name="service_stop" msgid="6369807553277527248">"Ustavi"</string>
    <string name="service_manage" msgid="1876642087421959194">"Nastavitve"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"To storitev je zagnala aplikacija. Če jo ustavite, aplikacija morda ne bo delovala."</string>
    <string name="heavy_weight_stop_description" msgid="6050413065144035971">"Aplikacije ni mogoče varno ustaviti. Če jo ustavite, boste morda izgubili nekaj svojega trenutnega dela."</string>
    <string name="background_process_stop_description" msgid="3834163804031287685">"To je star proces aplikacije, ki se še vedno izvaja, če bi ga potrebovali. Običajno ga ni treba ustaviti."</string>
    <string name="service_manage_description" msgid="479683614471552426">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: trenutno v uporabi. Dotaknite se »Nastavitve«, če želite to nadzirati."</string>
    <string name="main_running_process_description" msgid="1130702347066340890">"Glavni proces je v uporabi."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"Storitev <xliff:g id="COMP_NAME">%1$s</xliff:g> je v uporabi."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"Ponudnik <xliff:g id="COMP_NAME">%1$s</xliff:g> je v uporabi."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"Želite ustaviti sistemsko storitev?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"Če ustavite to storitev, lahko nekatere funkcije v tabličnem računalniku nehajo pravilno delovati, dokler ga ne izklopite in znova vklopite."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="3920243762189484756">"Če ustavite to stgoritev, lahko nekatere funkcije v telefonu nehajo pravilno delovati, dokler ga ne izklopite in znova vklopite."</string>
    <string name="language_input_gesture_title" msgid="8749227808244881255">"Jeziki, vnos in poteze"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="7219895055450633449"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="756147879200943161"></string>
    <string name="language_input_gesture_summary_off" msgid="4617198819416948217"></string>
    <string name="language_settings" msgid="8758655933029560944">"Jeziki in vnos"</string>
    <string name="language_empty_list_user_restricted" msgid="5984015900102140696">"Nimate dovoljenja za spreminjanje jezika naprave."</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Jeziki in vnos"</string>
    <string name="input_assistance" msgid="7577795275222555487">"Pomoč pri vnosu"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Tipkovnica in načini vnosa"</string>
    <string name="phone_language" msgid="7116581601133118044">"Jeziki"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Samodejno zamenjaj"</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Popravi napačno natipkane besede"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Samodejna uporaba velikih začetnic"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Uporaba velike začetnice za prvo črko v stavku"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Samodejno vstavljanje ločil"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Nastavitve fizične tipkovnice"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Dvakrat pritisnite preslednico, da vnesete ».«"</string>
    <string name="show_password" msgid="4837897357002495384">"Pokaži gesla"</string>
    <string name="show_password_summary" msgid="3365397574784829969">"Za trenutek prikaži znake med vnašanjem"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"Ta pregledovalnik črkovanja bo morda lahko zbral vse besedilo, ki ga vnesete, vključno z osebnimi podatki, kot so gesla in številke kreditnih kartic. Pregledovalnik je iz aplikacije <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Ga želite uporabiti?"</string>
    <string name="spellchecker_quick_settings" msgid="246728645150092058">"Nastavitve"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Jezik"</string>
    <string name="keyboard_and_input_methods_category" msgid="6035224122054465137">"Tipkovnica in vnosi"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Navidezna tipkovnica"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Razpoložljiva navidezna tipkovnica"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Upravljanje tipkovnic"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Pomoč za tipkovnico"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Fizična tipkovnica"</string>
    <string name="show_ime" msgid="2658582193437188227">"Pokaži navidezno tipkovnico"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Obdrži na zaslonu, tudi ko je aktivna fizična tipkovnica"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Pomočnik za bližnjične tipke"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Prikaz razpoložljivih bližnjic"</string>
    <string name="default_keyboard_layout" msgid="4172606673510531271">"Privzeto"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Hitrost kazalca"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Krmilnik za igre"</string>
    <string name="vibrate_input_devices" msgid="421936611134697943">"Preusmeritev vibriranja"</string>
    <string name="vibrate_input_devices_summary" msgid="82093256723774584">"Pošiljanje vibriranja v krmilnik za igre, ko je povezan"</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Izbira razporeditve tipkovnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Nastavitev razporeditev tipkovnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Preklopite s Ctrl + preslednica"</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Privzeto"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Razporeditve tipkovnice"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Osebni slovar"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Dodaj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Dodaj v slovar"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Besedna zveza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Več možnosti"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Manj možnosti"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"V redu"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Beseda:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Bližnjica:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Vnesite besedo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Izbirna bližnjica"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Uredi besedo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Uredi"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Izbriši"</string>
    <string name="user_dict_settings_empty_text" msgid="1971969756133074922">"V uporabniškem slovarju ni besed. Če želite dodati besedo, se dotaknite gumba za dodajanje (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="6742000040975959247">"Za vse jezike"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Več jezikov ..."</string>
    <string name="testing" msgid="6584352735303604146">"Preizkušanje"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Informacije o tabličnem računalniku"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Informacije o telefonu"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Vnos besedila"</string>
    <string name="input_method" msgid="5434026103176856164">"Vnosna metoda"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Trenutna tipkovnica"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Izbirnik načina vnosa"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Samodejno"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Vedno pokaži"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Vedno skrij"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Nastavitev načinov vnosa"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Nastavitve"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Nastavitve"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Nastavitve za <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Izbira aktivnih načinov vnosa"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Nastavitve zaslonske tipkovnice"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Fizična tipkovnica"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Nastavitve fizične tipkovnice"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Izberi pripomoček"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Izberite pripomoček"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"Želite ustvariti pripomoček in dovoliti dostop?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"Ko ustvarite pripomoček, ima <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> dostop do vseh podatkov, ki jih ta prikazuje."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7037503685859688034">"Vedno dovoli, da <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> ustvari pripomočke in dostopa do njihovih podatkov"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"Statistika uporabe"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Statistika uporabe"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Razvrsti po:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplikacija"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Zadnjič uporabljeno"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Čas uporabe"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Pripom. za ljudi s pos. potreb."</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Nastavitve pripomočkov za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_settings_summary" msgid="981260486011624939">"Bralniki zaslona, prikaz, interakcija"</string>
    <string name="vision_settings_title" msgid="4204111425716868288">"Nastavitve vidnosti"</string>
    <string name="vision_settings_description" msgid="5679491180156408260">"To napravo lahko prilagodite svojim potrebam. Te funkcije za ljudi s posebnimi potrebami lahko pozneje spremenite v nastavitvah."</string>
    <string name="vision_settings_suggestion_title" msgid="8058794060304707004">"Spremenite velikost pisave"</string>
    <string name="screen_reader_category_title" msgid="7739154903913400641">"Bralniki zaslona"</string>
    <string name="audio_and_captions_category_title" msgid="3420727114421447524">"Zvok in besedilo na zaslonu"</string>
    <string name="display_category_title" msgid="685461049938269166">"Zaslon"</string>
    <string name="interaction_control_category_title" msgid="7836591031872839151">"Kontrolniki za interakcije"</string>
    <string name="user_installed_services_category_title" msgid="6426376488922158647">"Prenesene storitve"</string>
    <string name="experimental_category_title" msgid="5272318666666893547">"Poskusno"</string>
    <string name="talkback_title" msgid="7912059827205988080">"TalkBack"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Bralnik zaslona je predvsem za slepe in slabovidne"</string>
    <string name="select_to_speak_summary" msgid="4282846695497544515">"Če želite slišati vsebino elementov na zaslonu, se jih dotaknite"</string>
    <string name="accessibility_captioning_title" msgid="7589266662024836291">"Napisi"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Povečava"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Povečevanje s trikratnim dotikom"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="7141753038957538230">"Povečevanje z gumbom"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="2760906043221923793">"Povečevanje z gumbom in s trikratnim dotikom"</string>
    <string name="accessibility_preference_magnification_summary" msgid="5867883657521404509">"Povečava zaslona"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Če želite povečati, se trikrat dotaknite"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="3693116360267980492">"Če želite povečati, se dotaknite gumba"</string>
    <string name="accessibility_screen_magnification_summary" msgid="5258868553337478505"><b>"Če želite povečati"</b>", se hitro trikrat dotaknite zaslona.\n"<ul><li>"Povlecite z dvema ali več prsti po zaslonu, če se želite pomikati."</li>\n<li>"Povlecite dva ali več prstov skupaj, če želite prilagoditi povečavo."</li></ul>\n\n<b>"Če želite začasno povečati"</b>", se hitro trikrat dotaknite zaslona in pri tretjem dotiku zadržite prst na zaslonu.\n"<ul><li>"Povlecite, če se želite premikati po zaslonu."</li>\n<li>"Dvignite prst, če želite zmanjšati povečavo."</li></ul>\n\n"Povečava ni mogoča na tipkovnici in v vrstici za krmarjenje."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="1996584694050087161">"Ko je povečava vklopljena, za hitro povečevanje uporabite gumb »Dostopnost« na dnu zaslona.\n\n"<b>"Če želite povečati"</b>", se dotaknite gumba »Dostopnost«, nato pa se dotaknite poljubnega mesta na zaslonu.\n"<ul><li>"Povlecite z dvema ali več prsti po zaslonu, če se želite pomikati."</li>\n<li>"Povlecite dva ali več prstov skupaj, če želite prilagoditi povečavo."</li></ul>\n\n<b>"Če želite začasno povečati"</b>", se dotaknite gumba »Dostopnost«, nato pa se dotaknite poljubnega mesta na zaslonu in ga pridržite.\n"<ul><li>"Povlecite, če se želite premikati po zaslonu."</li>\n<li>"Dvignite prst, če želite zmanjšati povečavo."</li></ul>\n\n"Povečava ni mogoča na tipkovnici ali v vrstici za krmarjenje."</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="70533120652758190">"Gumb »Dostopnost« je nastavljen na <xliff:g id="SERVICE">%1$s</xliff:g>. Če želite uporabiti povečavo, se dotaknite gumba »Dostopnost« in ga pridržite, nato pa izberite povečavo."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="2048884356166982714">"Bližnjica na tipki za glasnost"</string>
    <string name="accessibility_shortcut_service_title" msgid="4779360749706905640">"Storitev z bližnjico"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="5490636079625489534">"Dovoli na zaklenjenem zaslonu"</string>
    <string name="accessibility_shortcut_description" msgid="1765853731190717372">"Ko je bližnjica vklopljena, lahko funkcijo za ljudi s posebnimi potrebami zaženete tako, da pritisnete obe tipki za glasnost in ju pridržite tri sekunde."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Visokokontrastno besedilo"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Samodejno posodobi povečavo zaslona"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Posodabljanje povečave zaslona pri prehodih aplik."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Gumb za vklop konča klic"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="535173100516295580">"Velik kazalec miške"</string>
    <string name="accessibility_disable_animations" msgid="5876035711526394795">"Odstranjevanje animacij"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Mono zvok"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Združevanje kanalov pri predvajanju zvoka"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="6708467774619266508">"Časovni zam. za dotik in pridržanje"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inverzija barv"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="7052959202195368109">"Lahko vpliva na učinkovitost delovanja"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2434062071927416098">"Čas negibnosti"</string>
    <string name="accessibility_autoclick_description" msgid="4908960598910896933">"Če uporabljate miško, lahko nastavite, da kazalec samodejno izvede dejanje, ko se določen čas ne premika."</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Zakasnitev pred klikom"</string>
    <string name="accessibility_vibration_settings_title" msgid="3453277326300320803">"Vibriranje"</string>
    <string name="accessibility_notification_vibration_title" msgid="660829933960942244">"Vibriranje za zvonjenje in obvestila"</string>
    <string name="accessibility_touch_vibration_title" msgid="7931823772673770492">"Vibriranje ob dotiku"</string>
    <string name="accessibility_service_master_switch_title" msgid="6835441300276358239">"Uporaba storitve"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="8655284637968823154">"Uporaba popravljanja barv"</string>
    <string name="accessibility_caption_master_switch_title" msgid="4010227386676077826">"Uporaba napisov"</string>
    <string name="accessibility_hearingaid_title" msgid="8312145423610648518">"Slušni pripomočki"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="6240237523789614599">"Noben slušni pripomoček ni povezan"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="2947474468412309778">"Dodajanje slušnih pripomočkov"</string>
    <string name="accessibility_hearingaid_pair_instructions_first_message" msgid="3912093691643131154">"Če želite seznaniti slušne pripomočke, na naslednjem zaslonu poiščite napravo in se je dotaknite."</string>
    <string name="accessibility_hearingaid_pair_instructions_second_message" msgid="5596683393607650243">"Prepričajte se, da so slušni pripomočki v načinu seznanjanja."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="3924362383258688984">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je aktivna"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="3160782397139295486">
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> shranjen slušni pripomoček</item>
      <item quantity="two"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> shranjena slušna pripomočka</item>
      <item quantity="few"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> shranjeni slušni pripomočki</item>
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> shranjenih slušnih pripomočkov</item>
    </plurals>
    <string name="accessibility_summary_state_enabled" msgid="7914278500885887763">"Vklopljeno"</string>
    <string name="accessibility_summary_state_disabled" msgid="2984230257590246745">"Izklopljeno"</string>
    <string name="accessibility_summary_state_stopped" msgid="1144156815350270876">"Ne deluje. Dotaknite se za več informacij."</string>
    <string name="accessibility_description_state_stopped" msgid="6953539746047006596">"Ta storitev ne deluje pravilno."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Prikaži v »Hitrih nastavitvah«"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Način za popravljanje"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="one">Izjemno kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="two">Izjemno kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Izjemno kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Izjemno kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay" formatted="false" msgid="5589565607652364932">
      <item quantity="one">Zelo kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="two">Zelo kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Zelo kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Zelo kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5887754135102768400">
      <item quantity="one">Kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="two">Kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Kratka zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="6340683412750219405">
      <item quantity="one">Dolga zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="two">Dolga zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Dolga zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Dolga zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay" formatted="false" msgid="3503199424330634970">
      <item quantity="one">Zelo dolga zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="two">Zelo dolga zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="few">Zelo dolga zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="other">Zelo dolga zakasnitev (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="1372393829668784669">"Zvonjenje <xliff:g id="SUMMARY_RING">%1$s</xliff:g>, dotik <xliff:g id="SUMMARY_TOUCH">%2$s</xliff:g>"</string>
    <string name="accessibility_vibration_summary_off" msgid="1753566394591809629">"Vibriranje za zvonjenje in obvestila je izklopljeno"</string>
    <string name="accessibility_vibration_summary_low" msgid="7628418309029013867">"Vibriranje za zvonjenje in obvestila je nastavljeno na šibko"</string>
    <string name="accessibility_vibration_summary_medium" msgid="3422136736880414093">"Vibriranje za zvonjenje in obvestila je nastavljeno na srednje"</string>
    <string name="accessibility_vibration_summary_high" msgid="3239807793182635729">"Vibriranje za zvonjenje in obvestila je nastavljeno na močno"</string>
    <string name="accessibility_vibration_intensity_off" msgid="4613890213008630847">"Izklop"</string>
    <string name="accessibility_vibration_intensity_low" msgid="2017572546489862987">"Šibko"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="3782136025830279769">"Srednje"</string>
    <string name="accessibility_vibration_intensity_high" msgid="2543921139337952491">"Močno"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Nastavitve"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Vklopljeno"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Izkloplj."</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Predogled"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Standardne možnosti"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Jezik"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Velikost besedila"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Slog napisov"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Možnosti po meri"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Barva ozadja"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Neprosojnost ozadja"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Barva oken za napise"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Neprosojnost oken za napise"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Barva besedila"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Neprosojnost besedila"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Barva roba"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Vrsta roba"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Skupina pisav"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Napisi bodo videti tako:"</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Privzeto"</string>
    <string name="color_title" msgid="4258931051732243983">"Barva"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Privzeto"</string>
    <string name="color_none" msgid="3475640044925814795">"Brez"</string>
    <string name="color_white" msgid="8045195170201590239">"Bela"</string>
    <string name="color_gray" msgid="9192312087142726313">"Siva"</string>
    <string name="color_black" msgid="7517353520909872561">"Črna"</string>
    <string name="color_red" msgid="4949354900304125428">"Rdeča"</string>
    <string name="color_green" msgid="5537717328428845841">"Zelena"</string>
    <string name="color_blue" msgid="7731984529016953223">"Modra"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Cijan"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Rumena"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Magenta"</string>
    <string name="enable_service_title" msgid="3061307612673835592">"Želite uporabiti storitev <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="capabilities_list_title" msgid="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> mora:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"Ker aplikacija zakriva zahtevo za dovoljenje, z nastavitvami ni mogoče preveriti vašega odziva."</string>
    <string name="enable_service_encryption_warning" msgid="3064686622453974606">"Če vklopite storitev <xliff:g id="SERVICE">%1$s</xliff:g>, vaša naprava ne bo uporabljala zaklepanja zaslona za izboljšanje šifriranja podatkov."</string>
    <string name="secure_lock_encryption_warning" msgid="460911459695077779">"Vaša naprava ne bo uporabljala zaklepanja zaslona za izboljšanje šifriranja podatkov, ker ste vklopili storitev za ljudi s posebnimi potrebami."</string>
    <string name="enable_service_pattern_reason" msgid="777577618063306751">"Ker vklop storitve <xliff:g id="SERVICE">%1$s</xliff:g> vpliva na šifriranje podatkov, morate potrditi vzorec."</string>
    <string name="enable_service_pin_reason" msgid="7882035264853248228">"Ker vklop storitve <xliff:g id="SERVICE">%1$s</xliff:g> vpliva na šifriranje podatkov, morate potrditi kodo PIN."</string>
    <string name="enable_service_password_reason" msgid="1224075277603097951">"Ker vklop storitve <xliff:g id="SERVICE">%1$s</xliff:g> vpliva na šifriranje podatkov, morate potrditi geslo."</string>
    <string name="capability_title_receiveAccessibilityEvents" msgid="1869032063969970755">"Opazovati vaša dejanja"</string>
    <string name="capability_desc_receiveAccessibilityEvents" msgid="6640333613848713883">"Prejmite obvestila, ko uporabljate aplikacijo."</string>
    <string name="disable_service_title" msgid="3624005212728512896">"Želite izklopiti <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="2247101878627941561">"Če se dotaknete »V redu«, ustavite storitev <xliff:g id="SERVICE">%1$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="7200948194639038807">"Nameščena ni nobena storitev"</string>
    <string name="accessibility_no_service_selected" msgid="2840969718780083998">"Nobena storitev ni izbrana"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"Ni opisa."</string>
    <string name="settings_button" msgid="3006713718908152930">"Nastavitve"</string>
    <string name="print_settings" msgid="4742428530112487843">"Tiskanje"</string>
    <string name="print_settings_summary_no_service" msgid="6354322414246865875">"Izklopljeno"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="6005468025646083029">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> storitev tiskanja je vklopljena</item>
      <item quantity="two"><xliff:g id="COUNT">%1$d</xliff:g> storitvi tiskanja sta vklopljeni</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> storitve tiskanja so vklopljene</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> storitev tiskanja je vklopljenih</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="5810106725778525400">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> tiskalno opravilo</item>
      <item quantity="two"><xliff:g id="COUNT">%1$d</xliff:g> tiskalni opravili</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> tiskalna opravila</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> tiskalnih opravil</item>
    </plurals>
    <string name="print_settings_title" msgid="3685449667822217816">"Tiskalne storitve"</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"Nameščena ni nobena storitev"</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"Tiskalnikov ni mogoče najti"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Nastavitve"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Dodajanje tiskalnikov"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Vklopljeno"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"Izklop"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Dodaj storitev"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Dodajanje tiskalnika"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Iskanje"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Iskanje tiskalnikov"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Storitev je onemogočena"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Zahteve za tiskanje"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Tiskalno opravilo"</string>
    <string name="print_restart" msgid="8373999687329384202">"Začni znova"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Prekliči"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="1228890182762324249">"Konfiguriranje: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Tiskanje: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Preklic: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Napaka tiskalnika: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"Tiskalnik je blokiral <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Iskalno polje je prikazano"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Iskalno polje je skrito"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Več informacij o tem tiskalniku"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Akumulator"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Kaj porablja energijo akumulatorja"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Podatki o porabi akumulatorja niso na voljo."</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Preostali čas: <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do napolnjenosti"</string>
    <string name="background_activity_title" msgid="8482171736539410135">"Omejitev dejavnosti v ozadju"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Dovoli, da se aplikacija izvaja v ozadju"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"Aplikaciji ni dovoljeno izvajanje v ozadju"</string>
    <string name="background_activity_summary_whitelisted" msgid="1079899502347973947">"Dejavnosti v ozadju ni mogoče omejiti"</string>
    <string name="background_activity_warning_dialog_title" msgid="2216249969149568871">"Želite omejiti dejavnost v ozadju?"</string>
    <string name="background_activity_warning_dialog_text" msgid="7049624449246121981">"Če boste omejili dejavnost aplikacije v ozadju, morda ne bo pravilno delovala"</string>
    <string name="background_activity_disabled_dialog_text" msgid="6133420589651880824">"Ker za to aplikacijo ni izbrana nastavitev optimiziranja porabe akumulatorja, je ni mogoče omejiti.\n\nČe želite omejiti aplikacijo, najprej vklopite optimizacijo akumulatorja."</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Uporaba zaslona od polne napolnjenosti"</string>
    <string name="device_screen_consumption" msgid="4607589286438986687">"Poraba zaslona"</string>
    <string name="device_cellular_network" msgid="4724773411762382950">"Pregledovanje mobilnih omrežij"</string>
    <string name="power_usage_list_summary" msgid="5584049564906462506">"Poraba energije od polne napolnjenosti akumulatorja"</string>
    <string name="screen_usage_summary" msgid="6687403051423153550">"Trajanje vklopljenosti zaslona od polne napolnjenosti akumulatorja"</string>
    <string name="device_usage_list_summary" msgid="5623036661468763251">"Poraba naprave od polne napolnjenosti akumulatorja"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Uporaba akumulatorja po odklopu"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Uporaba akumulatorja od ponastavitve"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"Čas napajanja iz akumulatorja: <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> od odklopa"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Napajanje"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Zaslon vklopljen"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS:"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Fotoaparat je vklopljen"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Svetilka je vklopljena"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi‑Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Z odklenjenim zaslonom"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Signal mobilnega omrežja"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Čas odklenjenega zaslona"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Čas z vklopljenim Wi-Fi-jem"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Čas z vklopljenim Wi-Fi-jem"</string>
    <string name="advanced_battery_title" msgid="6768618303037280828">"Poraba akumulatorja"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Podrobnosti zgodovine"</string>
    <string name="battery_details_title" msgid="6101394441569858580">"Poraba akumulatorja"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Podrobnosti uporabe"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Prilagodi porabo energije"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Vključeni paketi"</string>
    <string name="battery_abnormal_details_title" msgid="5469019021857291216">"Energijsko potratne aplikacije"</string>
    <string name="battery_abnormal_wakelock_summary" msgid="4326186999058828831">"Ohranjanje prebujene naprave"</string>
    <string name="battery_abnormal_wakeup_alarm_summary" msgid="644657277875785240">"Prebujanje naprave iz ozadja"</string>
    <string name="battery_abnormal_location_summary" msgid="6552797246798806002">"Pogosto zahtevanje lokacije"</string>
    <string name="battery_abnormal_apps_summary" msgid="792553273248686972">"Nepravilno delovanje več aplikacij (<xliff:g id="NUMBER">%1$d</xliff:g>)"</string>
    <string name="battery_tip_summary_title" msgid="368729969313047399">"Aplikacije delujejo normalno"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="2198778125778121221">"Telefon ima običajno porabo energije akumulatorja v ozadju"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="1183976728682325345">"Tablični računalnik ima običajno porabo energije akumulatorja v ozadju"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="363718204492523920">"Naprava ima običajno porabo energije akumulatorja v ozadju"</string>
    <string name="battery_tip_low_battery_title" msgid="5103420355109677385">"Akumulator je skoraj prazen"</string>
    <string name="battery_tip_low_battery_summary" msgid="4702986182940709150">"Akumulator ne more zagotoviti dolgega časa delovanja"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2542822112725248683">"Izboljšajte čas delovanja akumulatorja telefona"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6452567046912954866">"Izboljšajte čas delovanja akumulatorja tabličnega računalnika"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4445149029390556382">"Izboljšajte čas delovanja akumulatorja naprave"</string>
    <string name="battery_tip_smart_battery_summary" msgid="2326809294592208069">"Vklopite varčevanje z energijo akumulatorja"</string>
    <string name="battery_tip_early_heads_up_title" msgid="5788492366387119807">"Vklop varčevanja z energijo akumulatorja"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="1639271439914224547">"Akumulator se bo morda izpraznil prej kot običajno"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4294083319255926811">"Varčevanje z energijo akumulatorja je vklopljeno"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7054036010928794364">"Nekatere funkcije bodo morda omejene"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="1282187115295901930">"Telefon uporabljate več kot običajno"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="7422137233845959351">"Tablični računalnik uporabljate več kot običajno"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="5483320224273724068">"Napravo uporabljate več kot običajno"</string>
    <string name="battery_tip_high_usage_summary" msgid="6341311803303581798">"Akumulator bo morda kmalu izpraznjen"</string>
    <string name="battery_tip_dialog_message" product="default" msgid="7001932078713215338">"Telefon ste uporabljali več kot običajno. Akumulator se bo morda izpraznil prej, kot ste pričakovali.\n\nNajpogosteje uporabljene aplikacije (<xliff:g id="NUMBER">%1$d</xliff:g>) od zadnje polne napolnjenosti:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="8482296786233647690">"Tablični računalnik ste uporabljali več kot običajno. Akumulator se bo morda izpraznil prej, kot ste pričakovali.\n\nNajpogosteje uporabljene aplikacije (<xliff:g id="NUMBER">%1$d</xliff:g>) od polne napolnjenosti:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="2806861679225286129">"Napravo ste uporabljali več kot običajno. Akumulator se bo morda izpraznil prej, kot ste pričakovali.\n\nNajpogosteje uporabljene aplikacije (<xliff:g id="NUMBER">%1$d</xliff:g>) od zadnje polne napolnjenosti:"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="467228882789275512">
      <item quantity="one">Omeji %1$d aplikacijo</item>
      <item quantity="two">Omeji %1$d aplikaciji</item>
      <item quantity="few">Omeji %1$d aplikacije</item>
      <item quantity="other">Omeji %1$d aplikacij</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="2996094393897875408">
      <item quantity="one">Nedavno je bila omejena %2$d aplikacija</item>
      <item quantity="two">Nedavno sta bili omejeni %2$d aplikaciji</item>
      <item quantity="few">Nedavno so bile omejene %2$d aplikacije</item>
      <item quantity="other">Nedavno je bilo omejenih %2$d aplikacij</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="5768962491638423979">
      <item quantity="one">%2$d aplikacija ima visoko porabo energije akumulatorja v ozadju</item>
      <item quantity="two">%2$d aplikaciji imata visoko porabo energije akumulatorja v ozadju</item>
      <item quantity="few">%2$d aplikacije imajo visoko porabo energije akumulatorja v ozadju</item>
      <item quantity="other">%2$d aplikacij ima visoko porabo energije akumulatorja v ozadju</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="1040488674178753191">
      <item quantity="one">Te aplikacije se ne smejo izvajati v ozadju</item>
      <item quantity="two">Te aplikacije se ne smejo izvajati v ozadju</item>
      <item quantity="few">Te aplikacije se ne smejo izvajati v ozadju</item>
      <item quantity="other">Te aplikacije se ne smejo izvajati v ozadju</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="8130618585820429591">
      <item quantity="one">Želite omejiti %1$d aplikacijo?</item>
      <item quantity="two">Želite omejiti %1$d aplikaciji?</item>
      <item quantity="few">Želite omejiti %1$d aplikacije?</item>
      <item quantity="other">Želite omejiti %1$d aplikacij?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="7271391929137806299">"Če želite varčevati z energijo akumulatorja, preprečite aplikaciji <xliff:g id="APP">%1$s</xliff:g>, da bi porabljala energijo akumulatorja v ozadju. Ta aplikacija morda ne bo delovala pravilno, obvestila pa bodo morda zakasnjena."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="3175700359860699627">"Če želite varčevati z energijo akumulatorja, preprečite tem aplikacijam, da bi porabljale energijo akumulatorja v ozadju. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena.\n\nAplikacije:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="582641081128076191">"Če želite varčevati z energijo akumulatorja, preprečite tem aplikacijam, da bi porabljale energijo akumulatorja v ozadju. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena.\n\nAplikacije:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="8291115820018013353">"Omeji"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="4321334634106715162">"Želite odstraniti omejitev?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="6537761705584610231">"Ta aplikacija bo lahko porabljala energijo akumulatorja za izvajanje v ozadju. Akumulator se bo morda izpraznil prej, kot ste pričakovali."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="6022058431218137646">"Odstrani"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="3058235875830858902">"Prekliči"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="4628448253185085796">"Aplikacije porabljajo običajno količino energije akumulatorja. V primeru prekomerne porabe energije vam bo telefon predlagal ustrezne ukrepe.\n\nČe akumulatorju zmanjkuje energije, lahko vedno vklopite varčevanje z energijo akumulatorja."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="8327950887399420971">"Aplikacije porabljajo običajno količino energije akumulatorja. V primeru prekomerne porabe energije vam bo tablični računalnik predlagal ustrezne ukrepe.\n\nČe akumulatorju zmanjkuje energije, lahko vedno vklopite varčevanje z energijo akumulatorja."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="6753742263807939789">"Aplikacije porabljajo običajno količino energije akumulatorja. V primeru prekomerne porabe energije vam bo naprava predlagala ustrezne ukrepe.\n\nČe akumulatorju zmanjkuje energije, lahko vedno vklopite varčevanje z energijo akumulatorja."</string>
    <string name="smart_battery_manager_title" msgid="870632749556793417">"Varčevanje z energijo akumulatorja"</string>
    <string name="smart_battery_title" msgid="6218785691872466076">"Samodejno upravljanje aplikacij"</string>
    <string name="smart_battery_summary" msgid="1339184602000004058">"Omejite porabljanje energije akumulatorja za aplikacije, ki jih ne uporabljate pogosto"</string>
    <string name="smart_battery_footer" product="default" msgid="5555604955956219544">"Ko varčevanje z energijo akumulatorja zazna, da aplikacije porabljajo energijo akumulatorja, lahko te aplikacije omejite. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena."</string>
    <string name="smart_battery_footer" product="tablet" msgid="5555604955956219544">"Ko varčevanje z energijo akumulatorja zazna, da aplikacije porabljajo energijo akumulatorja, lahko te aplikacije omejite. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena."</string>
    <string name="smart_battery_footer" product="device" msgid="5555604955956219544">"Ko varčevanje z energijo akumulatorja zazna, da aplikacije porabljajo energijo akumulatorja, lahko te aplikacije omejite. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena."</string>
    <string name="restricted_app_title" msgid="8982477293044330653">"Omejene aplikacije"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="7355687633914223530">
      <item quantity="one">Omejitev porabe energije akumulatorja za %1$d aplikacijo</item>
      <item quantity="two">Omejitev porabe energije akumulatorja za %1$d aplikaciji</item>
      <item quantity="few">Omejitev porabe energije akumulatorja za %1$d aplikacije</item>
      <item quantity="other">Omejitev porabe energije akumulatorja za %1$d aplikacij</item>
    </plurals>
    <string name="restricted_app_detail_footer" msgid="6739863162364046859">"Te aplikacije so porabljale energijo akumulatorja v ozadju. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena."</string>
    <string name="battery_auto_restriction_title" msgid="6553271897488963709">"Uporaba varčevanja z energijo akumulatorja"</string>
    <string name="battery_auto_restriction_summary" msgid="8561335400991281062">"Zaznavanje, ko aplikacije porabljajo energijo akumulatorja"</string>
    <string name="battery_manager_on" msgid="8643310865054362396">"Vklopljeno / Zaznavanje, ko aplikacije porabljajo energijo akumulatorja"</string>
    <string name="battery_manager_off" msgid="5473135235710343576">"Izklopljeno"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="1026141135861471129">
      <item quantity="one">%1$d aplikacija je omejena</item>
      <item quantity="two">%1$d aplikaciji sta omejeni</item>
      <item quantity="few">%1$d aplikacije so omejene</item>
      <item quantity="other">%1$d aplikacij je omejenih</item>
    </plurals>
    <string name="dialog_stop_title" msgid="6395127715596746479">"Želite ustaviti aplikacijo?"</string>
    <string name="dialog_stop_message" product="default" msgid="4006631636646776488">"Telefon ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP">%1$s</xliff:g> ohranja telefon prebujen.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo.\n\nČe se težava ponovi, boste za podaljšanje časa delovanja akumulatorja morda morali aplikacijo odstraniti."</string>
    <string name="dialog_stop_message" product="tablet" msgid="2369957934555162428">"Tablični računalnik ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP">%1$s</xliff:g> ohranja tablični računalnik prebujen.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo.\n\nČe se težava ponovi, boste za podaljšanje časa delovanja akumulatorja morda morali aplikacijo odstraniti."</string>
    <string name="dialog_stop_message" product="device" msgid="6195430620406365292">"Naprava ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP">%1$s</xliff:g> ohranja napravo prebujeno.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo.\n\nČe se težava ponovi, boste za podaljšanje časa delovanja akumulatorja morda morali aplikacijo odstraniti."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="1638726742782558262">"Telefon ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP_0">%1$s</xliff:g> nenehno prebuja telefon.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo <xliff:g id="APP_1">%1$s</xliff:g>.\n\nČe se težava ponovi, boste za podaljšanje časa delovanja akumulatorja morda morali aplikacijo odstraniti."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="8771690983566539742">"Tablični računalnik ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP_0">%1$s</xliff:g> nenehno prebuja tablični računalnik.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo <xliff:g id="APP_1">%1$s</xliff:g>.\n\nČe se težava ponovi, boste za podaljšanje časa delovanja akumulatorja morda morali aplikacijo odstraniti."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="2854944538238649520">"Naprava ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP_0">%1$s</xliff:g> nenehno prebuja napravo.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo <xliff:g id="APP_1">%1$s</xliff:g>.\n\nČe se težava ponovi, boste za podaljšanje časa delovanja akumulatorja morda morali aplikacijo odstraniti."</string>
    <string name="dialog_stop_ok" msgid="2319777211264004900">"Ustavi aplikacijo"</string>
    <string name="dialog_background_check_title" msgid="6936542136153283692">"Želite izklopiti izvajanje v ozadju in zaustaviti aplikacijo?"</string>
    <string name="dialog_background_check_message" product="default" msgid="4045827746349279563">"Telefon ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP_0">%1$s</xliff:g> nenehno prebuja telefon.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo <xliff:g id="APP_1">%1$s</xliff:g> in preprečite njeno izvajanje v ozadju."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="8348214419901788270">"Tablični računalnik ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP_0">%1$s</xliff:g> nenehno prebuja tablični računalnik.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo <xliff:g id="APP_1">%1$s</xliff:g> in preprečite njeno izvajanje v ozadju."</string>
    <string name="dialog_background_check_message" product="device" msgid="5847977433118915863">"Naprava ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP_0">%1$s</xliff:g> nenehno prebuja napravo.\n\nTežavo lahko poskusite rešiti tako, da zaustavite aplikacijo <xliff:g id="APP_1">%1$s</xliff:g> in preprečite njeno izvajanje v ozadju."</string>
    <string name="dialog_background_check_ok" msgid="412876934682899659">"Izklopi"</string>
    <string name="dialog_location_title" msgid="5888917530725874727">"Želite izklopiti ugotavljanje lokacije?"</string>
    <string name="dialog_location_message" product="default" msgid="7774807745601479888">"Telefon ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP">%1$s</xliff:g> nenehno zahteva lokacijo, tudi ko aplikacije ne uporabljate.\n\nTežavo lahko odpravite tako, da izklopite ugotavljanje lokacije za to aplikacijo."</string>
    <string name="dialog_location_message" product="tablet" msgid="118745801732181618">"Tablični računalnik ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP">%1$s</xliff:g> nenehno zahteva lokacijo, tudi ko aplikacije ne uporabljate.\n\nTežavo lahko odpravite tako, da izklopite ugotavljanje lokacije za to aplikacijo."</string>
    <string name="dialog_location_message" product="device" msgid="6783678153382298295">"Naprava ne more ustrezno upravljati porabe energije akumulatorja, ker aplikacija <xliff:g id="APP">%1$s</xliff:g> nenehno zahteva lokacijo, tudi ko aplikacije ne uporabljate.\n\nTežavo lahko odpravite tako, da izklopite ugotavljanje lokacije za to aplikacijo."</string>
    <string name="dialog_location_ok" msgid="4572391197601313986">"Izklopi"</string>
    <string name="power_screen" msgid="3023346080675904613">"Zaslon"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Svetilka"</string>
    <string name="power_camera" msgid="4976286950934622605">"Fotoaparat"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="3392999761958982492">"Mobilno omrežje v stanju pripravljenosti"</string>
    <string name="power_phone" msgid="5392641106474567277">"Glasovni klici"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablični računalnik nedejaven"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Nedejaven telefon"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Razno"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Preveč šteto"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"Skupni čas za CPE"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"Ospredje CPE"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Ohrani odklenjen zaslon"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi vklopljen"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablični računalnik"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Telefon"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Paketi, poslani v mob. omrežju"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Paketi, prejeti v mob. omrežju"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Mobilna radijska enota aktivna"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Paketi, poslani v omrežju Wi-Fi"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Paketi, prejeti v omrežju Wi-Fi"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Zvok"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Fotoaparat"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Svetilka"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Trajanje osvetlitve"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Čas brez signala"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Skupna zmogljivost akumulatorja"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Izračunana poraba energije"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Zaznana poraba energije"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Prisilna ustavitev"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Podatki o aplikaciji"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Nastavitve aplikacij"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Nastavitve zaslona"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Nastavitve za Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Nastavitve Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"Energija akumulatorja, ki so jo porabili glasovni klici"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"Uporaba akumulatorja, ko je tablični računalnik nedejaven"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"Poraba energije akumulatorja, kadar je telefon nedejaven"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"Energija akumulatorja, ki jo je porabil radijski vmesnik"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Na območjih brez mobilnega signala preklopite v način za letalo, da prihranite energijo"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Energija akumulatorja, porabljena za bliskavico"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Energija akumulatorja, ki jo porablja fotoaparat"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"Energija akumulatorja, porabljena za osvetlitev zaslona"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Zmanjšajte svetlost zaslona in/ali časovno omejitev za vklop zaslona"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Energija akumulatorja, ki jo je porabil Wi‑Fi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Izklopite Wi-Fi, ko ga ne uporabljate ali če ni na voljo"</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Energija akumulatorja, ki jo je porabil Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Izklopite funkcijo Bluetooth, kadar je ne uporabljate"</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Poskusite vzpostaviti povezavo z drugo napravo Bluetooth"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Energija akumulatorja, ki jo je porabila aplikacija"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Ustavi ali odstrani aplikacijo"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Izberite način za varčevanje z energijo akumulatorja"</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"Aplikacija morda omogoča nastavitve za zmanjšanje porabe energije akumulatorja"</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Energija akumulatorja, ki jo je porabil uporabnik"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Drugi viri porabe energije"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"Poraba akumulatorja je približek porabe energije in ne vključuje vseh virov porabe akumulatorja. »Drugi viri« so razlika med izračunano približno porabo energije in dejansko porabo, zaznano pri akumulatorju."</string>
    <string name="battery_desc_overcounted" msgid="5481865509489228603">"Preveč šteta uporaba energije"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="2690821851327075443">"Trajanje uporabe: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="2964359540508103032">"Čas dejavnosti: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="6537658662149713585">"Uporaba zaslona: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="1135316757755282999">"<xliff:g id="PERCENT">%1$s</xliff:g> porabil: <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="2093409063297375436">"<xliff:g id="PERCENT">%1$s</xliff:g> celotne napolnjenosti akumulatorja"</string>
    <string name="battery_detail_since_full_charge" msgid="7515347842046955855">"Razčlenitev od zadnje napolnjenosti akumulatorja"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Zadnja polna napolnjenost"</string>
    <string name="battery_full_charge_last" msgid="8892335687734288031">"Polno napolnjena naprava deluje približno"</string>
    <string name="battery_footer_summary" msgid="67169726550144016">"Podatki o uporabi akumulatorja so približni in se lahko spremenijo glede na uporabo naprave"</string>
    <string name="battery_detail_foreground" msgid="3350401514602032183">"Med aktivno uporabo"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"Med izvajanjem v ozadju"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Poraba akumulatorja"</string>
    <string name="battery_detail_info_title" msgid="8227822131405620369">"Od polne napolnjenosti akumulatorja"</string>
    <string name="battery_detail_manage_title" msgid="9094314252105828014">"Upravljanje porabe akumulatorja"</string>
    <string name="advanced_battery_graph_subtext" msgid="5621073891377915877">"Ocena preostalega časa delovanja akumulatorja temelji na načinu uporabe naprave"</string>
    <string name="estimated_time_left" msgid="7514194472683370877">"Približni preostali čas"</string>
    <string name="estimated_charging_time_left" msgid="5614442409326164691">"Do napolnjenosti"</string>
    <string name="estimated_time_description" msgid="8760210909000037089">"Ocena je odvisna od uporabe in se lahko spremeni."</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> od odklopa"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Po zadnjem odklopu za <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Skupna poraba"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Osveži"</string>
    <string name="process_kernel_label" msgid="3916858646836739323">"OS Android"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Predstavnostni strežnik"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimizacija aplikacij"</string>
    <string name="battery_saver" msgid="8172485772238572153">"Varčevanje z energijo akumulatorja"</string>
    <string name="battery_saver_auto_title" msgid="8368709389419695611">"Samodejni vklop"</string>
    <string name="battery_saver_seekbar_title" msgid="4705356758573183963">"Pri <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_seekbar_title_placeholder" msgid="1138980155985636295">"Vklop"</string>
    <string name="battery_saver_master_switch_title" msgid="622539414546588436">"Uporaba varčevanja z energijo akumulatorja"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Samodejni vklop"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nikoli"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="8665950426992057191">"pri <xliff:g id="PERCENT">%1$s</xliff:g> napolnjenosti akumulatorja"</string>
    <string name="battery_percentage" msgid="723291197508049369">"Odstotek napolnjenosti akumulatorja"</string>
    <string name="battery_percentage_description" msgid="8511658577507384014">"Pokaži odstotek napolnjenosti akumulatorja v vrstici stanja"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Statistični podatki o procesih"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Statistični podatki o procesih, ki se izvajajo"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Poraba pomnilnika"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"Uporabljeno <xliff:g id="USEDRAM">%1$s</xliff:g> od <xliff:g id="TOTALRAM">%2$s</xliff:g> v obdobju <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="6522457033380025618">"Uporabljeno <xliff:g id="PERCENT">%1$s</xliff:g> RAM-a v obdobju <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="3934992858120683459">"V ozadju"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"V ospredju"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"Predpomnjeni"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"Sistem Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Izvorno"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Jedro"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Predpomnjeno"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Uporaba RAM-a"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Uporaba RAM-a (v ozadju)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Trajanje izvajanja"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Procesi"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Storitve"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Trajanje"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Podrobnosti pomnilnika"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 ure"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 ur"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 ur"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 dan"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Prikaži sistemske procese"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Skrij sistemske procese"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Prikaži odstotke"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Uporaba USS-ja"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Vrsta statističnih podatkov"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"V ozadju"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"V ospredju"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"Predpomnjeni"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Glasovni vnos in izhod"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Nastavitve glasovnega vnosa in izhoda"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Glasovno iskanje"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Tipkovnica Android"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Nastavitve glasovnega vnosa"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Glasovni vnos"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Storitve glasovnega vnosa"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Polna uporaba sprožilnih besed in govora"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Pretvorba preprostega govora v besedilo"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"Storitev glasovnega vnosa bo lahko izvajala stalno vklopljeno nadziranje glasu in v vašem imenu upravljala aplikacije, ki omogočajo glasovno upravljanje. Storitev izvira iz aplikacije <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Želite omogočiti njeno uporabo?"</string>
    <string name="tts_engine_preference_title" msgid="1578826947311494239">"Prednostni mehanizem"</string>
    <string name="tts_engine_settings_title" msgid="6886964122861384818">"Nastavitve mehanizma"</string>
    <string name="tts_sliders_title" msgid="992059150784095263">"Hitrost in višina tona govora"</string>
    <string name="tts_engine_section_title" msgid="6289240207677024034">"Mehanizem"</string>
    <string name="tts_install_voice_title" msgid="6275828614052514320">"Glasovi"</string>
    <string name="tts_spoken_language" msgid="5542499183472504027">"Govorjeni jezik"</string>
    <string name="tts_install_voices_title" msgid="8808823756936022641">"Namestitev glasov"</string>
    <string name="tts_install_voices_text" msgid="5292606786380069134">"Pojdite v aplikacijo <xliff:g id="TTS_APP_NAME">%s</xliff:g>, če želite namestiti glasove"</string>
    <string name="tts_install_voices_open" msgid="667467793360277465">"Odpri aplikacijo"</string>
    <string name="tts_install_voices_cancel" msgid="4711492804851107459">"Prekliči"</string>
    <string name="tts_reset" msgid="2661752909256313270">"Ponastavi"</string>
    <string name="tts_play" msgid="2628469503798633884">"Predvajaj"</string>
    <string name="gadget_title" msgid="5519037532720577836">"Nadzor porabe"</string>
    <string name="gadget_toggle_wifi" msgid="319262861956544493">"Posodabljanje nastavitve Wi‑Fi-ja"</string>
    <string name="gadget_toggle_bluetooth" msgid="7538903239807020826">"Posodabljanje nastavitev Bluetooth"</string>
    <string name="gadget_state_template" msgid="5156935629902649932">"<xliff:g id="ID_1">%1$s</xliff:g> <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="gadget_state_on" msgid="6909119593004937688">"vklopljeno"</string>
    <string name="gadget_state_off" msgid="5220212352953066317">"izklopljeno"</string>
    <string name="gadget_state_turning_on" msgid="3395992057029439039">"vklapljanje"</string>
    <string name="gadget_state_turning_off" msgid="2395546048102176157">"izklapljanje"</string>
    <string name="gadget_wifi" msgid="4712584536500629417">"Wi‑Fi"</string>
    <string name="gadget_bluetooth" msgid="8998572807378694410">"Bluetooth"</string>
    <string name="gadget_location" msgid="2974757497945178165">"Lokacija"</string>
    <string name="gadget_sync" msgid="858895763714222152">"Sinhronizacija"</string>
    <string name="gadget_brightness_template" msgid="930541920933123603">"Svetlost <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="gadget_brightness_state_auto" msgid="6667967252426515446">"samodejno"</string>
    <string name="gadget_brightness_state_full" msgid="6814570109772137631">"najsvetleje"</string>
    <string name="gadget_brightness_state_half" msgid="3696671957608774204">"polovično"</string>
    <string name="gadget_brightness_state_off" msgid="946382262872753084">"izklopljeno"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Shramba poverilnic"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Namestitev iz shrambe"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Namesti s kartice SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Namestitev potrdil iz shrambe"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Namesti potrdila s kartice SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Brisanje poverilnic"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Odstranitev vseh potrdil"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Preverjene poverilnice"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Prikaži zaupanja vredna potrdila overiteljev"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Uporabniške poverilnice"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Ogled in spreminjanje shranjenih poverilnic"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Dodatno"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Vrsta shrambe"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Strojna"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Samo programska"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Za tega uporabnika niso na voljo poverilnice"</string>
    <string name="credential_for_vpn_and_apps" msgid="4168197158768443365">"Nameščeno za VPN in aplikacije"</string>
    <string name="credential_for_wifi" msgid="6228425986551591864">"Nameščeno za Wi-Fi"</string>
    <string name="credentials_unlock" msgid="385427939577366499"></string>
    <string name="credentials_unlock_hint" msgid="2301301378040499348">"Vnesite geslo za shrambo poverilnic."</string>
    <string name="credentials_old_password" msgid="7553393815538684028">"Trenutno geslo:"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"Želite odstraniti vso vsebino?"</string>
    <string name="credentials_wrong_password" msgid="2541932597104054807">"Napačno geslo."</string>
    <string name="credentials_reset_warning" msgid="5320653011511797600">"Napačno geslo. Poskusite lahko še enkrat, preden se shramba poverilnic izbriše."</string>
    <string name="credentials_reset_warning_plural" msgid="6514085665301095279">"Napačno geslo. Poskusite lahko še <xliff:g id="NUMBER">%1$d</xliff:g>-krat, preden se shramba poverilnic izbriše."</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Shramba poverilnic je izbrisana."</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Shrambe pover. ni mogoče izbr."</string>
    <string name="credentials_enabled" msgid="7588607413349978930">"Shramba poverilnic je omogočena."</string>
    <string name="credentials_configure_lock_screen_hint" msgid="8058230497337529036">"Preden lahko uporabite shrambo poverilnic, morate v napravi nastaviti varno zaklepanje zaslona."</string>
    <string name="credentials_configure_lock_screen_button" msgid="253239765216055321">"NASTAVITEV ZAKLEPANJA"</string>
    <string name="usage_access_title" msgid="332333405495457839">"Apl. z dost. do pod. o uporabi"</string>
    <string name="emergency_tone_title" msgid="254495218194925271">"Signal za klice v sili"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Nastavi način delovanja ob klicanju v sili"</string>
    <string name="privacy_settings_title" msgid="2978878794187459190">"Varnostno kopiranje"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Varnostno kopiranje in obnovitev"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Osebni podatki"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Varn. kopiraj podatke"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"Varnostno kopiranje podatkov aplikacij, gesel za Wi-Fi in drugih nastavitev v Googlove strežnike"</string>
    <string name="backup_configure_account_title" msgid="3790872965773196615">"Račun za kopiranje"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Vključi podatke aplikacije"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Samodejna obnovitev"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Obnovitev varnostno kopiranih nastavitev in podatkov pri vnovični namestitvi aplikacije"</string>
    <string name="backup_inactive_title" msgid="685838037986644604">"Storitev varnostnega kopiranja ni aktivna"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Trenutno v nobenem računu niso shranjeni varnostno kopirani podatki"</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"Ali želite ustaviti varnostno kopiranje gesel za Wi-Fi, zaznamkov, drugih nastavitev in podatkov aplikacij ter izbrisati vse kopije iz Googlovih strežnikov?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="694766389396659626">"Ali želite zaustaviti varnostno kopiranje podatkov naprave (kot so gesla za Wi-Fi in zgodovina klicev) in podatkov aplikacij (na primer nastavitve in datoteke, ki jih shranjujejo aplikacije) ter izbrisati vse kopije iz oddaljenih strežnikov?"</string>
    <string name="fullbackup_data_summary" msgid="960850365007767734">"Samodejno shranjevanje podatkov naprave (na primer gesel za Wi-Fi in zgodovine klicev) in podatkov aplikacij (na primer nastavitev in datotek, ki jih shranjujejo aplikacije) na daljavo.\n\nKo vklopite samodejno varnostno kopiranje, se podatki naprave in aplikacij redno shranjujejo na daljavo. Podatki aplikacij so lahko kateri koli podatki, ki jih je shranila aplikacija (na podlagi nastavitev razvijalca), vključno z morebitnimi občutljivimi podatki, kot so stiki, sporočila in fotografije."</string>
    <string name="device_admin_settings_title" msgid="4960761799560705902">"Nastavitve skrbnika naprave"</string>
    <string name="active_device_admin_msg" msgid="578748451637360192">"Skrbniška aplikacija naprave"</string>
    <string name="remove_device_admin" msgid="9207368982033308173">"Deaktiviraj to skrbniško aplikacijo naprave"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Odstrani aplikacijo"</string>
    <string name="remove_and_uninstall_device_admin" msgid="3837625952436169878">"Deaktiviraj in odstrani"</string>
    <string name="select_device_admin_msg" msgid="7347389359013278077">"Skrbniške aplikacije naprave"</string>
    <string name="no_device_admins" msgid="4846602835339095768">"Na voljo ni nobena skrbniška aplikacija naprave"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Osebno"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Delo"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"Na voljo ni nobenega posrednika zaupanja"</string>
    <string name="add_device_admin_msg" msgid="1501847129819382149">"Aktivacija skrbniške aplikacije naprave?"</string>
    <string name="add_device_admin" msgid="4192055385312215731">"Aktiviraj skrbniško aplikacijo te naprave"</string>
    <string name="device_admin_add_title" msgid="3140663753671809044">"Skrbnik naprave"</string>
    <string name="device_admin_warning" msgid="7482834776510188134">"Če aktivirate to skrbniško aplikacijo, boste aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> omogočili izvajanje teh postopkov:"</string>
    <string name="device_admin_status" msgid="7234814785374977990">"Ta skrbniška aplikacija je aktivna in aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> omogoča izvajanje teh postopkov:"</string>
    <string name="profile_owner_add_title" msgid="6249331160676175009">"Želite aktivirati Upravitelja profilov?"</string>
    <string name="adding_profile_owner_warning" msgid="1354474524852805802">"Če nadaljujete, bo uporabnika upravljal skrbnik, ki lahko poleg osebnih podatkov shranjuje tudi povezane podatke.\n\nSkrbnik lahko nadzira in upravlja nastavitve, dostop, aplikacije ter podatke, povezane s tem uporabnikom, vključno z omrežno dejavnostjo in podatki o lokaciji naprave."</string>
    <string name="admin_disabled_other_options" msgid="7712694507069054530">"Druge možnosti je onemogočil skrbnik"</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Več podrobnosti"</string>
    <string name="sound_category_sound_title" msgid="1488759370067953996">"Splošno"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Dnevnik obvestil"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Ton zvonjenja in vibriranje"</string>
    <string name="sound_category_system_title" msgid="1480844520622721141">"Sistem"</string>
    <string name="wifi_setup_title" msgid="2970260757780025029">"Namestitev povezave Wi‑Fi"</string>
    <string name="wifi_setup_title_editing_network" msgid="6020614644556717979">"Vzpostavitev povezave z omrežjem Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_connecting_network" msgid="5572226790101017822">"Vzpostavljanje povezave z omrežjem Wi-Fi <xliff:g id="NETWORK_NAME">%s</xliff:g> …"</string>
    <string name="wifi_setup_title_connected_network" msgid="1608788657122010919">"Vzpostavljena povezava z omrežjem Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_setup_title_add_network" msgid="6932651000151032301">"Dodajanje omrežja"</string>
    <string name="wifi_setup_not_connected" msgid="6997432604664057052">"Povezava ni vzpostavljena"</string>
    <string name="wifi_setup_add_network" msgid="5939624680150051807">"Dodaj omrežje"</string>
    <string name="wifi_setup_refresh_list" msgid="3411615711486911064">"Osveži seznam"</string>
    <string name="wifi_setup_skip" msgid="6661541841684895522">"Preskoči"</string>
    <string name="wifi_setup_next" msgid="3388694784447820477">"Naprej"</string>
    <string name="wifi_setup_back" msgid="144777383739164044">"Nazaj"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"O omrežju"</string>
    <string name="wifi_setup_connect" msgid="7954456989590237049">"Vzpostavi povezavo"</string>
    <string name="wifi_setup_forget" msgid="2562847595567347526">"Pozabi"</string>
    <string name="wifi_setup_save" msgid="3659235094218508211">"Shrani"</string>
    <string name="wifi_setup_cancel" msgid="3185216020264410239">"Prekliči"</string>
    <string name="wifi_setup_status_scanning" msgid="5317003416385428036">"Iskanje omrežij ..."</string>
    <string name="wifi_setup_status_select_network" msgid="3960480613544747397">"Dotaknite se omrežja, če želite vzpostaviti povezavo"</string>
    <string name="wifi_setup_status_existing_network" msgid="6394925174802598186">"Poveži se z obstoječim omrežjem"</string>
    <string name="wifi_setup_status_unsecured_network" msgid="8143046977328718252">"Poveži z nezaščitenim omrežjem"</string>
    <string name="wifi_setup_status_edit_network" msgid="4765340816724760717">"Vnesite konfiguracijo omrežja"</string>
    <string name="wifi_setup_status_new_network" msgid="7468952850452301083">"Poveži se z novim omrežjem"</string>
    <string name="wifi_setup_status_connecting" msgid="4971421484401530740">"Povezovanje ..."</string>
    <string name="wifi_setup_status_proceed_to_next" msgid="6708250000342940031">"Naprej"</string>
    <string name="wifi_setup_status_eap_not_supported" msgid="6796317704783144190">"EAP ni podprt."</string>
    <string name="wifi_setup_eap_not_supported" msgid="6812710317883658843">"Povezave EAP Wi-Fi ne morete nastaviti med namestitvijo. To lahko po namestitvi naredite v Nastavitve &gt; Brezžično in omrežja."</string>
    <string name="wifi_setup_description_connecting" msgid="2793554932006756795">"Vzpostavljanje povezave lahko traja nekaj minut ..."</string>
    <string name="wifi_setup_description_connected" msgid="6649168170073219153">"Če želite nadaljevati nastavitev, se dotaknite "<b>"Naprej"</b>".\n\nČe se želite povezati z drugim omrežjem Wi-Fi, se dotaknite "<b>"Nazaj"</b>"."</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sinhronizacija omogočena"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sinhronizacija onemogočena"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Sinhronizacija poteka"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Napaka pri sinhronizaciji"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Sinhronizacija ni uspela"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sinhronizacija je aktivna"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sinhroniziranje"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"Težava pri sinhronizaciji. Kmalu bo spet na voljo."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Dodaj račun"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"Delovni profil še ni na voljo"</string>
    <string name="work_mode_label" msgid="7157582467956920750">"Delovni profil"</string>
    <string name="work_mode_on_summary" msgid="3628349169847990263">"Upravlja vaša organizacija"</string>
    <string name="work_mode_off_summary" msgid="2657138190560082508">"Aplikacije in obvestila so izklopljeni"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Odstrani delovni profil"</string>
    <string name="background_data" msgid="5779592891375473817">"Podatki v ozadju"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Aplikacije lahko kadar koli sinhronizirajo, pošiljajo in prejemajo podatke"</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"Želite onemogočiti podatke v ozadju?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"Če onemogočite podatke v ozadju, podaljšate življenjsko dobo akumulatorja in zmanjšate rabo podatkov. Nekatere aplikacije bodo mogoče še vedno potrebovale povezavo s podatki v ozadju."</string>
    <string name="sync_automatically" msgid="1682730255435062059">"Samodejna sinh. podatkov aplik."</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sinhroniz. je VKLOP."</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sinhron. je IZKLOP."</string>
    <string name="sync_error" msgid="5060969083117872149">"Sinhron. napaka"</string>
    <string name="last_synced" msgid="4242919465367022234">"Zadnje sinhroniziranje: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sinhroniziranje ..."</string>
    <string name="settings_backup" msgid="2274732978260797031">"Varnostno kopiranje nastavitev"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Varnostno kopiranje nastavitev"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sinhroniziraj"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Prekliči sinhronizacijo"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Dotaknite se za sinhronizacijo<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Koledar"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Stiki"</string>
    <string name="sync_plug" msgid="3905078969081888738"><font fgcolor="#ffffffff">"Pozdravljeni v storitvi Google Sync."</font>" \nGooglov pristop k sinhroniziranju podatkov, s katerim lahko dostopate do stikov, koledarskih vnosov in drugih podatkov ne glede na to, kje ste."</string>
    <string name="header_application_sync_settings" msgid="6205903695598000286">"Nastavitve sinhronizacije aplikacij"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Podatki in sinhronizacija"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Spremeni geslo"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Nastavitve računa"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Odstrani račun"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Dodajanje računa"</string>
    <string name="finish_button_label" msgid="481587707657751116">"Končaj"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"Želite odstraniti račun?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"Z odstranitvijo računa boste iz tabličnega računalnika izbrisali vsa sporočila, stike in druge podatke v računu."</string>
    <string name="really_remove_account_message" product="default" msgid="3483528757922948356">"Z odstranitvijo računa boste iz telefona izbrisali vsa sporočila, stike in druge podatke v računu."</string>
    <string name="really_remove_account_message" product="device" msgid="7507474724882080166">"Z odstranitvijo računa boste iz naprave izbrisali vsa sporočila, stike in druge podatke v računu."</string>
    <string name="remove_account_failed" msgid="3901397272647112455">"Skrbnik ne dovoli te spremembe"</string>
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"Ročna sinhronizacija ni mogoča"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"Sinhronizacija za ta element je trenutno onemogočena. Če želite spremeniti nastavitev, vklopite podatke v ozadju in samodejno sinhronizacijo."</string>
    <string name="enter_password" msgid="8035706727471334122">"Če želite zagnati Android, vnesite geslo"</string>
    <string name="enter_pin" msgid="5305333588093263790">"Če želite zagnati Android, vnesite PIN"</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Če želite zagnati Android, narišite vzorec"</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Napačen vzorec"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Napačno geslo"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"Napačna koda PIN"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Preverjanje ..."</string>
    <string name="starting_android" msgid="4001324195902252681">"Zagon Androida ..."</string>
    <string name="delete" msgid="4219243412325163003">"Izbriši"</string>
    <string name="misc_files" msgid="6720680815969643497">"Razne datoteke"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"izbrano: <xliff:g id="NUMBER">%1$d</xliff:g> od <xliff:g id="TOTAL">%2$d</xliff:g>"</string>
    <string name="misc_files_selected_count_bytes" msgid="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> od skupaj <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Izberi vse"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Podatkovni promet"</string>
    <string name="data_usage_app_summary_title" msgid="4147258989837459172">"Prenos podatk. aplikacije"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"Operaterjeve meritve porabe podatkov so morda drugačne kot v napravi."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Uporaba aplikacije"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"PODATKI O APLIKACIJI"</string>
    <string name="data_usage_cellular_data" msgid="9168928285122125137">"Prenos podatkov v mobilnem omrežju"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Nastavitev omejitve prenosa podatkov"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Cikel porabe podatkov"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Uporaba aplikacije"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Podatkovno gostovanje"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Omejitev podatkov v ozadju"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Dovoli podatke v ozadju"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Ločena uporaba 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Pokaži porabo za Wi‑Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Skrij Wi‑Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Pokaži uporabo etherneta"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Skrij porabo etherneta"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Omejitve omrežja"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Samodejno sinhroniziranje podatkov"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"Kartice SIM"</string>
    <string name="data_usage_menu_cellular_networks" msgid="8339835014751511300">"Mobilna omrežja"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"Ustavljeno zaradi omejitve"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Samod. sinhronizacija podatkov"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Samod. sinhron. oseb. podatkov"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Samod. sinhr. delov. podatkov"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Spremeni cikel ..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Dan za ponastavitev cikla porabe podatkov:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"V tem obdobju ni podatkov uporabljala nobena aplikacija."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Ospredje"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Ozadje"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"omejeno"</string>
    <string name="data_usage_disable_mobile" msgid="8656552431969276305">"Želite izklopiti prenos podatkov v mobilnih omrežjih?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Nast. omejitev mobilnih podatkov"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Nastavi omejitev podatkov za 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Nast. omejitev za EDGE in UMTS"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Nast. omej. pod. za Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Mobilni"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Mobilno"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Brez"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Mobilni podatki"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Podatki 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Podatki 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="1523331545457578362">"Gostovanje"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"Ospredje:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"Ozadje:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Nastavitve aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="7359227831562303223">"Podatki v ozadju"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="5853552187570622572">"Omogoči prenos podatkov v mobilnem omrežju v ozadju"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Če želite za to aplikacijo omejiti prenos podatkov v ozadju, nastavite omejitev prenosa podatkov v mobilnih omrežjih."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"Želite omejiti podatke v ozadju?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"Ta funkcija lahko povzroči prenehanje delovanja aplikacije, ki je odvisna od podatkov v ozadju, če so na voljo samo mobilna omrežja.\n\nUstreznejši kontrolniki za uporabo podatkov so na voljo v nastavitvah v aplikaciji."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="55012417305745608">"Prenos podatkov v ozadju lahko omejite samo, če nastavite omejitev količine podatkov, prenesenih v mobilnih omrežjih."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2438617846762244389">"Želite vklopiti samodejno sinhroniziranje podatkov?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"Morebitne spremembe v računih, ki jih naredite v spletu, bodo samodejno kopirane v tablični računalnik.\n\nNekateri računi morda tudi samodejno kopirajo morebitne spremembe, ki jih naredite v tabličnem računalniku, v splet. Tako deluje Google Račun."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="8651376294887142858">"Morebitne spremembe v računih, ki jih naredite v spletu, bodo samodejno kopirane v telefon.\n\nNekateri računi morda tudi samodejno kopirajo morebitne spremembe, ki jih naredite v telefonu, v splet. Tako deluje Google Račun."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="9013139130490125793">"Želite izklopiti samodejno sinhroniziranje podatkov?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"S tem zmanjšate količino prenesenih podatkov in porabo akumulatorja, vendar boste morali vsak posamezen račun sinhronizirati ročno, da dobite najnovejše podatke. Prav tako ne boste dobili obvestil o posodobitvah."</string>
    <string name="data_usage_cycle_editor_title" msgid="1373797281540188533">"Datum ponastavitve cikla porabe"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Datum v posameznem mesecu:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Nastavi"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Nastavi opozorilo o uporabi podatkov"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Nastavi omejitev količine prenesenih podatkov"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Omejitev porabe podatkov"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="4983487893343645667">"Tablični računalnik bo izklopil prenos podatkov v mobilnih omrežjih, ko bo dosežena nastavljena omejitev.\n\nKer količino prenesenih podatkov meri tablični računalnik, operater pa jo morda drugače, priporočamo, da nastavite nekoliko manjšo omejitev."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="3926320594049434225">"Telefon bo izklopil prenos podatkov v mobilnih omrežjih, ko bo dosežena nastavljena omejitev.\n\nKer količino prenesenih podatkov meri telefon, operater pa jo morda drugače, priporočamo, da nastavite nekoliko manjšo omejitev."</string>
    <string name="data_usage_restrict_background_title" msgid="2201315502223035062">"Želite omejiti podatke v ozadju?"</string>
    <string name="data_usage_restrict_background" msgid="434093644726734586">"Če omejite prenos podatkov v mobilnih omrežjih v ozadju, nekatere aplikacije in storitve ne bodo delovale, kadar niste povezani v omrežje Wi-Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="7096707497743363380">"Če omejite prenos podatkov v mobilnih omrežjih v ozadju, nekatere aplikacije in storitve ne bodo delovale, kadar niste povezani v omrežje Wi-Fi.\n\nNastavitev vpliva na vse uporabnike v tem tabličnem računalniku."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="7910798414964288424">"Če omejite prenos podatkov v mobilnih omrežjih v ozadju, nekatere aplikacije in storitve ne bodo delovale, kadar niste povezani v omrežje Wi-Fi.\n\nNastavitev vpliva na vse uporabnike v tem telefonu."</string>
    <string name="data_usage_sweep_warning" msgid="6387081852568846982"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">" <xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"opozorilo"</font></string>
    <string name="data_usage_sweep_limit" msgid="860566507375933039"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"omejitev"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="614263770923231598">"Odstranjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Odstranjene aplikacije in uporabniki"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"prejeto: <xliff:g id="RECEIVED">%1$s</xliff:g>, poslano: <xliff:g id="SENT">%2$s</xliff:g>"</string>
    <string name="data_usage_total_during_range" msgid="4091294280619255237">"<xliff:g id="RANGE">%2$s</xliff:g>: približna količina prenesenih podatkov: <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="1925687342154538972">"<xliff:g id="RANGE">%2$s</xliff:g>: približna količina prenesenih podatkov, merjena s tabličnim računalnikom: <xliff:g id="TOTAL">%1$s</xliff:g>. Operater jo lahko obračunava drugače."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="5063981061103812900">"<xliff:g id="RANGE">%2$s</xliff:g>: približna količina prenesenih podatkov, merjena s telefonom: <xliff:g id="TOTAL">%1$s</xliff:g>. Operater jo lahko obračunava drugače."</string>
    <string name="data_usage_metered_title" msgid="7383175371006596441">"Omejitve omrežja"</string>
    <string name="data_usage_metered_body" msgid="7655851702771342507">"Ko je prenos podatkov v ozadju omejen, se omrežja z omejeno količino prenosa obravnavajo kot mobilna omrežja. V primeru velikih prenosov lahko aplikacije opozorijo pred uporabo teh omrežij."</string>
    <string name="data_usage_metered_mobile" msgid="5423305619126978393">"Mobilna omrežja"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Wi‑Fi z omejeno količ. prenosa"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Če želite izbrati omrežje z omej. kol. prenosa, vklopite Wi-Fi."</string>
    <string name="data_usage_metered_auto" msgid="1262028400911918865">"Samodejno"</string>
    <string name="data_usage_metered_yes" msgid="9217539611385225894">"Z omejenim prenosom podatkov"</string>
    <string name="data_usage_metered_no" msgid="4025232961929071789">"Z neomejenim prenosom podatkov"</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"Operaterjeve meritve porabe podatkov so morda drugačne kot v napravi."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Klic v sili"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Nazaj na klic"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Ime"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Vrsta"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Naslov strežnika"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Šifriranje PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"Skrivnost L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identifikator IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Ključ v predhodni skupni rabi IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Uporabniško potrdilo IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Overjeno potrdilo IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Potrdilo strežnika IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Prikaži dodatne možnosti"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Domene za iskanje DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Strežniki DNS (npr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Poti za posredovanje (npr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Uporabniško ime"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Geslo"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Shrani podatke o računu"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(ni uporabljeno)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(ne preveri strežnika)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(prejeto iz strežnika)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="7574518311224455825">"Ta vrsta omrežja VPN ne more biti stalno vklopljena."</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="477304620899799383">"Stalno vklopljeno omrežje VPN podpira samo številske naslove strežnikov."</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="2226648961940273294">"Za stalno vklopljeno omrežje VPN mora biti naveden strežnik DNS."</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3551394495620249972">"Za stalno vklopljeno omrežje VPN morajo biti naslovi strežnikov DNS številski."</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="5959352052515258208">"Vneseni podatki ne podpirajo stalno vklopljenega omrežja VPN."</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Prekliči"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Opusti"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Shrani"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Vzpostavi povezavo"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Zamenjaj"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Urejanje profila VPN"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Pozabi"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Povezovanje z <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="3743970132487505659">"Prekinitev povezave s tem omrežjem VPN?"</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Prekini povezavo"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Različica <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="2232239391189465752">"Pozabi omrežje VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="2963898301277610248">"Želite zamenjati obstoječe omrežje VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="4009987321156037267">"Ali želite, da je omrežje VPN stalno vklopljeno?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="7144543717673197102">"Ko je ta nastavitev vklopljena, ne boste imeli internetne povezave, dokler se ne vzpostavi povezava z omrežjem VPN."</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="798121133114824006">"Vaše obstoječe omrežje VPN bo zamenjano in ne boste imeli internetne povezave, dokler se ne vzpostavi povezava z omrežjem VPN."</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="3011818750025879902">"S stalno vklopljenim omrežjem VPN ste že povezani. Če se povežete z drugim, bo obstoječe omrežje VPN zamenjano in stalno vklopljeni način se bo izklopil."</string>
    <string name="vpn_replace_vpn_message" msgid="5611635724578812860">"Z omrežjem VPN ste že povezani. Če se povežete z drugim, bo obstoječe omrežje VPN zamenjano."</string>
    <string name="vpn_turn_on" msgid="2363136869284273872">"Vklopi"</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"Z omrežjem VPN <xliff:g id="VPN_NAME">%1$s</xliff:g> ni mogoče vzpostaviti povezave."</string>
    <string name="vpn_cant_connect_message" msgid="1352832123114214283">"Ta aplikacija ne podpira stalno vklopljenega omrežja VPN."</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Dodajanje profila VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Urejanje profila"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Brisanja profila"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"Stalno vklopljen VPN"</string>
    <string name="vpn_no_vpns_added" msgid="5002741367858707244">"Dodano ni bilo nobeno omrežje VPN"</string>
    <string name="vpn_always_on_summary" msgid="2821344524094363617">"Stalna povezava v omrežje VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="592304911378771510">"Ta aplikacija tega ne podpira"</string>
    <string name="vpn_always_on_summary_active" msgid="8800736191241875669">"Vedno vklopljeno in aktivno"</string>
    <string name="vpn_require_connection" msgid="8388183166574269666">"Blokiraj povezave brez omrežja VPN"</string>
    <string name="vpn_require_connection_title" msgid="159053539340576331">"Ali zahtevate povezavo VPN?"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"Izberite profil za navidezno zasebno omrežje (VPN), s katerim boste vedno povezani. Omrežni promet bo dovoljen samo prek tega omrežja VPN."</string>
    <string name="vpn_lockdown_none" msgid="9214462857336483711">"Brez"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"Za stalno vklopljeno navidezno zasebno omrežje je potreben naslov IP tako za strežnik kot za DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"Ni omrežne povezave. Poskusite pozneje."</string>
    <string name="vpn_disconnected" msgid="280531508768927471">"Povezava z VPN je prekinjena"</string>
    <string name="vpn_disconnected_summary" msgid="3082851661207900606">"Brez"</string>
    <string name="vpn_missing_cert" msgid="5357192202207234745">"Ni potrdila. Uredite profil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Uporabnik"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Onemogoči"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Omogoči"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Odstrani"</string>
    <string name="trusted_credentials_trust_label" msgid="8003264222650785429">"Zaupaj"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"Želite omogočiti sistemsko overjeno potrdilo?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"Želite onemogočiti sistemsko overjeno potrdilo?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"Želite trajno odstraniti uporabniško overjeno potrdilo?"</string>
    <string name="credential_contains" msgid="3984922924723974084">"Ta vnos vsebuje:"</string>
    <string name="one_userkey" msgid="6034020579534914349">"en uporabniški ključ"</string>
    <string name="one_usercrt" msgid="2150319011101639509">"eno uporabniško potrdilo"</string>
    <string name="one_cacrt" msgid="6844397037970164809">"eno potrdilo overitelja potrdil"</string>
    <string name="n_cacrts" msgid="5979300323482053820">"Potrdila overitelja potrdil: %d"</string>
    <string name="user_credential_title" msgid="1954061209643070652">"Podrobnosti poverilnic"</string>
    <string name="user_credential_removed" msgid="6514189495799401838">"Odstranjena poverilnica: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="3729607560420971841">"Ni nameščenih uporabniških poverilnic"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Črkovalnik"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Sem vnesite trenutno geslo za popolno varnostno kopiranje"</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Sem vnesite novo geslo za popolno varnostno kopiranje"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Znova vnesite novo geslo za popolno varnostno kopiranje"</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Nastavi geslo za varnostno kopijo"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Prekliči"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Dodatne posodobitve sistema"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Omrežje je lahko nadzorovano"</string>
    <string name="done_button" msgid="1991471253042622230">"Končano"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <item quantity="one">Označevanje potrdil kot zaupanja vrednih ali odstranitev potrdil</item>
      <item quantity="two">Označevanje potrdil kot zaupanja vrednih ali odstranitev potrdil</item>
      <item quantity="few">Označevanje potrdil kot zaupanja vrednih ali odstranitev potrdil</item>
      <item quantity="other">Označevanje potrdil kot zaupanja vrednih ali odstranitev potrdil</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="1489335297837656666">
      <item quantity="one">Skrbnik domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je v napravi namestil overitelje potrdil, s čimer morda lahko spremlja dejavnost naprave v omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o teh potrdilih, se obrnite na skrbnika.</item>
      <item quantity="two">Skrbnik domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je v napravi namestil overitelje potrdil, s čimer morda lahko spremlja dejavnost naprave v omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o teh potrdilih, se obrnite na skrbnika.</item>
      <item quantity="few">Skrbnik domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je v napravi namestil overitelje potrdil, s čimer morda lahko spremlja dejavnost naprave v omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o teh potrdilih, se obrnite na skrbnika.</item>
      <item quantity="other">Skrbnik domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je v napravi namestil overitelje potrdil, s čimer morda lahko spremlja dejavnost naprave v omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o teh potrdilih, se obrnite na skrbnika.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="30645643499556573">
      <item quantity="one">Skrbnik domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je namestil overitelje potrdil za vaš delovni profil, s čimer morda lahko spremlja dejavnost v službenem omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o teh potrdilih, se obrnite na skrbnika.</item>
      <item quantity="two">Skrbnik domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je namestil overitelje potrdil za vaš delovni profil, s čimer morda lahko spremlja dejavnost v službenem omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o teh potrdilih, se obrnite na skrbnika.</item>
      <item quantity="few">Skrbnik domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je namestil overitelje potrdil za vaš delovni profil, s čimer morda lahko spremlja dejavnost v službenem omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o teh potrdilih, se obrnite na skrbnika.</item>
      <item quantity="other">Skrbnik domene <xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> je namestil overitelje potrdil za vaš delovni profil, s čimer morda lahko spremlja dejavnost v službenem omrežju, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o teh potrdilih, se obrnite na skrbnika.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="8216218659139190498">"Tretja oseba lahko nadzira vašo omrežno dejavnost, vključno z e-poštnimi sporočili, aplikacijami in varnimi spletnimi mesti.\n\nTo ji omogoča zaupanja vredna poverilnica, ki je nameščena v vaši napravi."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="2426799352517325228">
      <item quantity="one">Preveri potrdila</item>
      <item quantity="two">Preveri potrdila</item>
      <item quantity="few">Preveri potrdila</item>
      <item quantity="other">Preveri potrdila</item>
    </plurals>
    <string name="user_settings_title" msgid="3493908927709169019">"Več uporabnikov"</string>
    <string name="user_list_title" msgid="7937158411137563543">"Uporabniki in profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Dodajanje uporabnika ali profila"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Dodaj uporabnika"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Omejen profil"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"Preden lahko ustvarite profil z omejitvami, morate nastaviti zaklepanje zaslona, da zaščitite aplikacije in osebne podatke."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Nastavi zaklepanje"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"Uporabnik ni nastavljen"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Ni nastavljeno – omejen profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Ni nastavljeno – delovni profil"</string>
    <string name="user_admin" msgid="993402590002400782">"Skrbnik"</string>
    <string name="user_you" msgid="1639158809315025986">"Vi (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Vzdevek"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Dodaj"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Dodate lahko do toliko uporabnikov: <xliff:g id="USER_COUNT">%1$d</xliff:g>"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Uporabniki imajo svoje aplikacije in vsebino"</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Dostop do aplikacij in vsebine iz vašega računa lahko omejite"</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Uporabnik"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Omejen profil"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"Dodajanje novega uporabnika?"</string>
    <string name="user_add_user_message_long" msgid="6768718238082929201">"To napravo lahko daste v skupno rabo z drugimi tako, da ustvarite dodatne uporabnike. Vsak ima svoj prostor, ki ga lahko prilagodi z aplikacijami, ozadji in drugim. Uporabniki lahko tudi prilagodijo nastavitve naprave, ki vplivajo na vse, na primer nastavitve omrežja Wi-Fi.\n\nKo dodate novega uporabnika, mora ta nastaviti svoj prostor.\n\nVsak uporabnik lahko posodobi aplikacije za vse druge uporabnike. Nastavitve in storitve funkcij za ljudi s posebnimi potrebami morda ne bodo prenesene v prostor novega uporabnika."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Ko dodate novega uporabnika, mora ta nastaviti svoj prostor.\n\nVsak uporabnik lahko posodobi aplikacije za vse druge uporabnike."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"Želite uporabnika nastaviti zdaj?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Prepričajte se, da ima oseba čas za nastavitev svojega prostora."</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"Želite zdaj nastaviti profil?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Želim nastaviti zdaj"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Ne zdaj"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Uporabnike lahko upravlja samo lastnik tabličnega računalnika."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Uporabnike lahko upravlja samo lastnik telefona."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Profili z omejitvami ne morejo dodajati računov"</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Izbris up. <xliff:g id="USER_NAME">%1$s</xliff:g> iz napr."</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Nastavitve zaklepanja zaslona"</string>
    <string name="user_add_on_lockscreen_menu" msgid="9072312646546364619">"Dodajanje uporabnikov na zaklenjenem zaslonu"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Nov uporabnik"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Nov profil"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"Želite izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="1163721647646152032">"Odstranitev uporabnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"Odstranitev profila?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"Želite odstraniti delovni profil?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"V tem tabličnem računalniku boste izgubili prostor in podatke. Tega dejanja ni mogoče razveljaviti."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="7943645442479360048">"V tem telefonu boste izgubili prostor in podatke. Tega dejanja ni mogoče razveljaviti."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Vse aplikacije in vsi podatki bodo izbrisani."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Če nadaljujete, bodo izbrisane vse aplikacije in podatki v tem profilu."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Vse aplikacije in vsi podatki bodo izbrisani."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Dodajanje novega uporabnika ..."</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Izbriši uporabnika"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Izbriši"</string>
    <string name="user_guest" msgid="8475274842845401871">"Gost"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Odstranitev gosta"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"Želite odstraniti gosta?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Vse aplikacije in podatki v tej seji bodo izbrisani."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Odstrani"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Vklop telefonskih klicev"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Vklop telefonskih klicev in sporočil SMS"</string>
    <string name="user_remove_user" msgid="6490483480937295389">"Odstranjevanje uporabnika"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"Želite vklopiti telefonske klice?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Zgodovina klicev bo v skupni rabi s tem uporabnikom."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"Vklop telefonskih klicev in sporočil SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"Zgodovina klicev in sporočil SMS bo dana v skupno rabo s tem uporabnikom."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Informacije za nujne primere"</string>
    <string name="emergency_info_summary" msgid="5062945162967838521">"Podatki in stiki za uporabnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Omogočanje aplikacij in vsebine"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplikacije z omejitvami"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Dodatne nastavitve za aplikacijo"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Plačilo z dotikom"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Kako deluje"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Plačujte v trgovinah s telefonom"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"Privzeto za plačevanje"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Ni nastavljeno"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="3234730182120288495">"Uporaba privzete aplikacije"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Vedno"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Razen ko je odprta druga aplikacija za plačevanje"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"Na terminalu, ki omogoča plačevanje z dotikom, plačaj z aplikacijo:"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Plačevanje v terminalu"</string>
    <string name="nfc_how_it_works_content" msgid="4749007806393224934">"Nastavite aplikacijo za plačevanje. Nato prislonite hrbtno stran telefona h kateremu koli terminalu s simbolom za brezstično plačevanje."</string>
    <string name="nfc_how_it_works_got_it" msgid="259653300203217402">"Razumem"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Več ..."</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"Želite nastaviti kot prednostno?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"Ali želite za plačevanje z dotikom vedno uporabiti aplikacijo <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"Ali želite za plačevanje z dotikom namesto aplikacije <xliff:g id="APP_1">%2$s</xliff:g> vedno uporabiti aplikacijo <xliff:g id="APP_0">%1$s</xliff:g>?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Omejitve"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Odstranitev omejitev"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Sprememba kode PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Pokaži obvestila"</string>
    <string name="help_label" msgid="6886837949306318591">"Pomoč in povr. inf."</string>
    <string name="support_summary" msgid="2705726826263742491">"Članki s pomočjo, telefon in klepet, prvi koraki"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Račun za vsebino"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID fotografije"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Skrajne grožnje"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Prejem. opozoril o skrajnih grožnjah za življenje in premož."</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Resne grožnje"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Prejem. opozoril o resnih grožnjah za življenje in premož."</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Opozorila AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Prejemanje objav o ugrabitvah otrok"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Ponovitev"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Omogočanje Upravitelja klicev"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Omogoči tej storitvi upravljanje načina izvajanja klicev."</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Upravitelj klicev"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="4124461751977706019">"Nujna opozorila"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Omrežni operaterji"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Imena dostopnih točk (APN)"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="5808043757309522392">"Izboljšan način 4G LTE"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1376589643017218924">"Uporabi prenos podatkov prek LTE za izboljšanje glasu in komunikacij (priporočeno)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Prednostna vrsta omrežja"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (priporočeno)"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"Delovna kartica SIM"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Dostop do aplikacij in vsebine"</string>
    <string name="user_rename" msgid="8523499513614655279">"PREIMENOVANJE"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Nastavitev omejitev za aplikacijo"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Nadzira aplikacija <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Ta aplikacija lahko dostopa do vaših računov"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"Ta aplikacija lahko dostopa do vaših računov. Upravlja jo aplikacija <xliff:g id="APP">%1$s</xliff:g>."</string>
    <string name="restriction_wifi_config_title" msgid="8889556384136994814">"Wi-Fi in mobilna omrežja"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Dovoli spreminjanje nastavitev za Wi-Fi in mobilna omrežja"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Dovoli spreminjanje seznanjanj in nastavitev naprav Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"Omogoča izmenjavo podatkov, ko se naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> dotakne druge naprave NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="3891097373396149915">"Dovoli izmenjavo podatkov, ko se tablični računalnik dotakne druge naprave"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Dovoli izmenjavo podatkov, ko se telefon dotakne druge naprave"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Aplikacije lahko uporabljajo podatke o vaši lokaciji"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Nazaj"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Naprej"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Dokončaj"</string>
    <string name="user_image_take_photo" msgid="1280274310152803669">"Posnemi fotografijo"</string>
    <string name="user_image_choose_photo" msgid="7940990613897477057">"Izberite fotografijo iz galerije"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Izberite fotografijo"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"Kartici SIM"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"Kartice SIM"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<xliff:g id="SIM_NAME">%1$s</xliff:g> – <xliff:g id="SIM_NUMBER">%2$s</xliff:g>"</string>
    <string name="sim_cards_changed_message" msgid="7900721153345139783">"Kartice SIM so spremenjene"</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Dotaknite se, če želite nastaviti dejavnosti"</string>
    <string name="sim_cellular_data_unavailable" msgid="9109302537004566098">"Prenos podatkov v mob. omr. ni na voljo"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Dotaknite se, če želite izbrati SIM za prenos podatkov"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Vedno uporabi to možnost za klice"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Izbira kartice SIM za prenos podatkov"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Preklop podatkovne kartice SIM. Lahko traja kakšno minuto …"</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Klicanje z …"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Izberite kartico SIM"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"Kartica SIM je prazna"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Ime kartice SIM"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Vnesite ime kartice SIM"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Reža za SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Operater"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Številka"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Barva kartice SIM"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Izberite kartico SIM"</string>
    <string name="color_orange" msgid="4417567658855022517">"Oranžna"</string>
    <string name="color_purple" msgid="3888532466427762504">"Vijolična"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"Ni vstavljenih kartic SIM"</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Stanje kartice SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="5725659316463979194">"Stanje kartice SIM (reža za SIM %1$d)"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Povratni klic s privzete kartice SIM"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"Kartica SIM za odhodne klice"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Druge nastavitve klicev"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"PNO"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Onemog. odd. imena omrež."</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"Če onemogočite oddajanje imena omrežja, tretjim osebam onemogočite dostop do podatkov o omrežju."</string>
    <string name="preferred_network_offload_popup" msgid="2252915199889604600">"Če onemogočite oddajanje imena omrežja, preprečite samodejno povezovanje s skritimi omrežji."</string>
    <string name="sim_signal_strength" msgid="9144010043784767984">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="6272913297433198340">"Zamenjava kartic SIM."</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Dotaknite se, če želite nastaviti"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"Prednostna kartica SIM za:"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Vedno vprašaj"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Zahtevana je izbira"</string>
    <string name="sim_selection_channel_title" msgid="2760909074892782589">"Izbira kartice SIM"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Nastavitve"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="5597356221942118048">
      <item quantity="one">Pokaži %d skrit element</item>
      <item quantity="two">Pokaži %d skrita elementa</item>
      <item quantity="few">Pokaži %d skrite elemente</item>
      <item quantity="other">Pokaži %d skritih elementov</item>
    </plurals>
    <string name="dashboard_suggestion_condition_footer_content_description" msgid="2898588191174845961">"Strni"</string>
    <string name="network_dashboard_title" msgid="3135144174846753758">"Omrežje in internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="3851083934739500429">"mobilno"</string>
    <string name="network_dashboard_summary_data_usage" msgid="3843261364705042212">"prenesena količina podatkov"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"dostopna točka"</string>
    <string name="connected_devices_dashboard_title" msgid="2355264951438890709">"Povezane naprave"</string>
    <string name="connected_devices_dashboard_summary" msgid="2665221896894251402">"Bluetooth, način vožnje, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="3840842725283655533">"Bluetooth, način vožnje"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="5018708106066758867">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="5250078362483148199">"Bluetooth"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Aplikacije in obvestila"</string>
    <string name="app_and_notification_dashboard_summary" msgid="2363314178802548682">"Dovoljenja, privzete aplikacije"</string>
    <string name="account_dashboard_title" msgid="5895948991491438911">"Računi"</string>
    <string name="account_dashboard_default_summary" msgid="3998347400161811075">"Dodan ni bil noben račun"</string>
    <string name="app_default_dashboard_title" msgid="7342549305933047317">"Privzete aplikacije"</string>
    <string name="system_dashboard_summary" msgid="5797743225249766685">"Jeziki, čas, varnostno kopiranje, posodobitve"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Nastavitve"</string>
    <string name="search_menu" msgid="6283419262313758339">"Preišči nastavitve"</string>
    <string name="keywords_wifi" msgid="3646884600964177062">"wifi, wi-fi, omrežna povezava, internet, brezžično, podatki, wi fi"</string>
    <string name="keywords_change_wifi_state" msgid="627068244033681010">"wifi, wi-fi, preklop, upravljanje"</string>
    <string name="keywords_more_default_sms_app" msgid="8597706109432491909">"SMS, pošiljanje sporočil SMS, sporočila, sporočanje, privzeto"</string>
    <string name="keywords_more_mobile_networks" msgid="8995946622054642367">"mobilno omrežje, mobilno, operater, brezžično, podatki, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"wifi, wi-fi, klic, klicanje"</string>
    <string name="keywords_home" msgid="294182527446892659">"zaganjalnik, privzeto, aplikacije"</string>
    <string name="keywords_display" msgid="8910345814565493016">"zaslon, zaslon na dotik"</string>
    <string name="keywords_display_brightness_level" msgid="3138350812626210404">"zatemnitev zaslona, zaslon na dotik, akumulator, svetlo"</string>
    <string name="keywords_display_auto_brightness" msgid="3325150824507953765">"zatemnitev zaslona, zaslon na dotik, akumulator"</string>
    <string name="keywords_display_night_display" msgid="2534032823231355074">"zatemnitev zaslona, noč, obarvanje, preklop na nočni način, svetlost, barva zaslona, barva"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"ozadje, prilagajanje, prilagajanje zaslona"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"velikost besedila"</string>
    <string name="keywords_display_cast_screen" msgid="7684618996741933067">"projiciranje, predvajanje"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"prostor, disk, trdi disk, uporaba naprave"</string>
    <string name="keywords_battery" msgid="1173830745699768388">"poraba energije, polnjenje"</string>
    <string name="keywords_spell_checker" msgid="1399641226370605729">"črkovanje, slovar, preverjanje črkovanja, samodejno popravljanje"</string>
    <string name="keywords_voice_input" msgid="769778245192531102">"prepoznavalnik, vnos, govor, govori, jezik, prostoročno, prostoročno, prepoznavanje, žaljivka, zvok, zgodovina, slušalka bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="5150660047085754699">"hitrost, jezik, privzeto, govor, govorjenje, pretvorba besedila v govor, dostopnost bralnik zaslona, slep"</string>
    <string name="keywords_date_and_time" msgid="758325881602648204">"ura, vojaško"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"ponastavitev, obnovitev, tovarniško"</string>
    <string name="keywords_factory_data_reset" msgid="2261491208836438871">"izbrisati, obnoviti, počistiti, odstraniti, tovarniška ponastavitev, ponastavitev na tovarniške nastavitve"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"tiskalnik"</string>
    <string name="keywords_sounds" msgid="5633386070971736608">"pisk zvočnika, zvočnik, glasnost, utišati, tišina, zvok, glasba"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"ne moti, prekinjaj, prekinitev, motnja"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="6615286961552714686">"v bližini, lokacija, zgodovina, poročanje"</string>
    <string name="keywords_accounts" msgid="1957925565953357627">"račun"</string>
    <string name="keywords_users" msgid="3434190133131387942">"omejitev, omeji, omejeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"popravljanje besedila, pravilno, zvok, vibriranje, samodejno, jezik, poteza, predlaganje, predlog, tema, žaljivo, beseda, vrsta, emodžiji, mednarodno"</string>
    <string name="keywords_reset_apps" msgid="5293291209613191845">"ponastavitev, nastavitve, privzeto"</string>
    <string name="keywords_emergency_app" msgid="3143078441279044780">"nujni primer, ice, aplikacij, privzeto"</string>
    <string name="keywords_default_phone_app" msgid="4213090563141778486">"telefon, klicalnik, privzeto"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"aplikacije, prenos, aplikacije, sistem"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"aplikacije, dovoljenja, varnost"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"aplikacije, privzeto"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"prezrtje, optimizacije, dremanje, aplikacija v pripravljenosti"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"živo, RGB, sRGB, barva, naravno, standardno"</string>
    <string name="keywords_color_temperature" msgid="6239410718075715449">"barva, temperatura, D65, D73, bela, rumena, modra topla, hladna"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"podrsanje za odklepanje, geslo, vzorec, PIN"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"delovna preizkušnja, delo, profil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"delovni profil, upravljan profil, poenotiti, poenotenje, delo, profil"</string>
    <string name="keywords_gesture" msgid="3526905012224714078">"poteze"</string>
    <string name="keywords_payment_settings" msgid="5220104934130446416">"plačaj, dotakni se, plačevanje z dotikom, plačila"</string>
    <string name="keywords_backup" msgid="470070289135403022">"varnostna kopija, varnostno kopiranje, varnostno kopirati"</string>
    <string name="keywords_assist_gesture_launch" msgid="813968759791342591">"poteza"</string>
    <string name="keywords_imei_info" msgid="7230982940217544527">"imei, meid, min, različica seznama prednostnih omrežij za gostovanje, različica programske opreme za imei"</string>
    <string name="keywords_sim_status" msgid="1474422416860990564">"omrežje, stanje mobilnega omrežja, stanje storitve, moč signala, vrsta mobilnega omrežja, gostovanje, iccid"</string>
    <string name="keywords_model_and_hardware" msgid="1459248377212829642">"serijska številka, različica strojne opreme"</string>
    <string name="keywords_android_version" msgid="9069747153590902819">"raven varnostnih popravkov za android, različica radijske programske opreme, različica jedra"</string>
    <string name="keywords_ambient_display_screen" msgid="5874969496073249362">"prikaz na podlagi okolja, prikaz na zaklenjenem zaslonu"</string>
    <string name="keywords_fingerprint_settings" msgid="239222512315619538">"prstni odtis"</string>
    <string name="keywords_auto_rotate" msgid="5620879898668211494">"zavrteti, obrniti, vrtenje, pokončno, ležeče, postavitev, navpično, vodoravno"</string>
    <string name="keywords_system_update_settings" msgid="7752189778843741773">"nadgradnja, android"</string>
    <string name="keywords_zen_mode_settings" msgid="6526742836231604995">"ne moti, razpored, obvestila, blokirati, utišati, vibriranje, spanje, delo, zbranost, izklopiti zvok, dan, delavnik, vikend, noč med tednom, dogodek"</string>
    <string name="keywords_screen_timeout" msgid="8161370660970309476">"zaslon, čas zaklepanja, časovna omejitev, zaklenjen zaslon"</string>
    <string name="keywords_storage_settings" msgid="1642340184392317296">"pomnilnik, podatki, izbrisati, počistiti, sprostiti, prostor"</string>
    <string name="keywords_bluetooth_settings" msgid="6804844062789439858">"povezano, naprava, slušalke, slušalke z mikrofonom, zvočnik, brezžično, seznaniti, seznanitev, ušesne slušalke, glasba, predstavnost"</string>
    <string name="keywords_wallpaper" msgid="5058364390917429896">"ozadje, zaslon, zaklenjen zaslon, tema"</string>
    <string name="keywords_assist_input" msgid="5017533309492679287">"privzeto, pomočnik"</string>
    <string name="keywords_default_browser" msgid="8324486019657636744">"privzeto, privzeti brskalnik"</string>
    <string name="keywords_default_payment_app" msgid="3838565809518896799">"plačilo, plačevanje, privzeto"</string>
    <string name="keywords_default_links" msgid="5830406261253835547">"privzeto"</string>
    <string name="keywords_ambient_display" msgid="3103487805748659132">"dohodno obvestilo"</string>
    <string name="keywords_hotspot_tethering" msgid="1137511742967410918">"povezava z internetom prek mobilnega telefona prek kabla USB, povezava z internetom prek mobilnega telefona prek povezave Bluetooth, dostopna točka wifi"</string>
    <string name="keywords_touch_vibration" msgid="5983211715076385822">"haptično, vibriranje, zaslon, občutljivost"</string>
    <string name="keywords_ring_vibration" msgid="2393528037008999296">"haptično, vibriranje, telefon, klic, občutljivost"</string>
    <string name="setup_wifi_nfc_tag" msgid="9028353016222911016">"Nastavitev brezžič. oznake NFC"</string>
    <string name="write_tag" msgid="8571858602896222537">"Zapiši"</string>
    <string name="status_awaiting_tap" msgid="2130145523773160617">"Dotaknite se oznake za zapisovanje ..."</string>
    <string name="status_invalid_password" msgid="2575271864572897406">"Neveljavno geslo. Poskusite znova."</string>
    <string name="status_write_success" msgid="5228419086308251169">"Uspešno."</string>
    <string name="status_failed_to_write" msgid="8072752734686294718">"Na oznako NFC ni mogoče zapisati podatkov. Če težave ne odpravite, poskusite z drugo oznako."</string>
    <string name="status_tag_not_writable" msgid="2511611539977682175">"Na oznako NFC ni mogoče zapisovati. Uporabite drugo oznako."</string>
    <string name="default_sound" msgid="8821684447333687810">"Privzeti zvok"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Glasnost zvonjenja: <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="3402435125958012986">"Glasnost, vibriranje, ne moti"</string>
    <string name="sound_settings_summary_vibrate" msgid="1869282574422220096">"Zvonjenje je nastavljeno na vibriranje"</string>
    <string name="sound_settings_summary_silent" msgid="5074529767435584948">"Zvonjenje je nastavljeno na tiho"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Glasnost zvonjenja: 80 %"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Glasnost predstavnosti"</string>
    <string name="call_volume_option_title" msgid="1265865226974255384">"Glasnost klica"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Glasnost alarma"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Glasnost zvonjenja"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Glasnost obvestila"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Melodija zvonjenja telefona"</string>
    <string name="notification_ringtone_title" msgid="4468722874617061231">"Privzeti zvok obvestila"</string>
    <string name="notification_unknown_sound_title" msgid="2535027767851838335">"Zvok iz aplikacije"</string>
    <string name="notification_sound_default" msgid="565135733949733766">"Privzeti zvok obvestila"</string>
    <string name="alarm_ringtone_title" msgid="6344025478514311386">"Privzeti zvok alarma"</string>
    <string name="vibrate_when_ringing_title" msgid="3806079144545849032">"Vibriranje tudi za klice"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Drugi zvoki"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Toni tipkovnice"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Zvoki ob zaklepanju zaslona"</string>
    <string name="charging_sounds_title" msgid="1132272552057504251">"Zvoki polnjenja"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Zvok ob odlaganju v nosilec"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Zvoki dotikov"</string>
    <string name="vibrate_on_touch_title" msgid="1510405818894719079">"Vibriranje ob dotiku"</string>
    <string name="vibrate_on_touch_summary" msgid="8015901758501868229">"Odziv z vibriranjem ob dotiku, pritisku tipk in drugem"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Zvočnik nosilca je vklopljen"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Vsi zvoki"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Samo zvoki predstavnosti"</string>
    <string name="emergency_tone_silent" msgid="3750231842974733677">"Tišina"</string>
    <string name="emergency_tone_alert" msgid="8523447641290736852">"Toni"</string>
    <string name="emergency_tone_vibrate" msgid="2278872257053690683">"Vibriranje"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Zvoki ob zagonu"</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Nikoli"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="7346979080337117366">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> pravilo</item>
      <item quantity="two"><xliff:g id="ON_COUNT">%d</xliff:g> pravili</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> pravila</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> pravil</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="1066226840983908121">"Ne moti"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Vklop načina »ne moti«"</string>
    <string name="zen_mode_behavior_settings_title" msgid="5453115212674008032">"Izjeme"</string>
    <string name="zen_mode_duration_settings_title" msgid="229547412251222757">"Trajanje"</string>
    <string name="zen_mode_behavior_allow_title" msgid="3845615648136218141">"Dovoli te zvoke in vibriranja:"</string>
    <string name="zen_mode_behavior_no_sound" msgid="1219626004723208056">"Brez zvoka"</string>
    <string name="zen_mode_behavior_total_silence" msgid="2229976744274214528">"Popolna tišina"</string>
    <string name="zen_mode_behavior_no_sound_except" msgid="4968477585788243114">"Brez zvoka razen: <xliff:g id="CATEGORIES">%1$s</xliff:g>"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="6455884547877702466">"Brez zvoka razen alarmov in predstavnosti"</string>
    <string name="zen_mode_automation_settings_title" msgid="2517800938791944915">"Samodejni vklop"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="7069221762714457987">"Samodejna pravila"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="9041488774587594301">"Samodejno pravilo"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="4321254843908888574">"Utišanje telefona ob določenih urah"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="6223252025075862701">"Nastavitev pravil za način »Ne moti«"</string>
    <string name="zen_mode_use_automatic_rule" msgid="4509513632574025380">"Uporabi pravilo"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Samo prednostno"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Samo alarmi"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Popolna tišina"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="6751708745442997940">"Blokiranje vizualnih motenj"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="6308824824208120508">"Dovoli vizualne znake"</string>
    <string name="zen_mode_settings_category" msgid="3982039687186952865">"Ko je vklopljen način »ne moti«"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="478040192977063582">"Obvestila"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="3690261619682396872">"Brez zvočnega opozarjanja na obvestila"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="5810076116489877312">"Obvestila bodo prikazana na zaslonu"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="3465600930732602159">"Telefon ob prejemu obvestil ne bo predvajal zvoka ali vibriral."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5305121630186687339">"Brez vidnega in zvočnega opozarjanja na obvestila"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="7555448406901864904">"Obvestila ne bodo prikazana in ne bodo pospremljena z zvokom"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="6559283246372102465">"Telefon ne bo prikazoval novih ali obstoječih obvestil in ne bo predvajal zvoka ali vibriral. Če s prstom povlečete navzdol z vrha zaslona, obvestila ne bodo prikazana.\n\nUpoštevajte, da se bodo nujna obvestila o delovanju in stanju telefona še vedno prikazovala."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="7498689167767941034">"Po meri"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4250962169561739747">"Omogoči nastavitev po meri"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="6676997522330453597">"Odstrani nastavitev po meri"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="5450158135853888485">"Brez zvočnega opozarjanja na obvestila"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="7416121534987213074">"Delno skrito"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="3618285192806732504">"Brez vidnega in zvočnega opozarjanja na obvestila"</string>
    <string name="zen_mode_what_to_block_title" msgid="5480903548365697159">"Omejitve po meri"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="4659484530849212827">"Pri vklopljenem zaslonu"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="4276414460889400625">"Pri izklopljenem zaslonu"</string>
    <string name="zen_mode_block_effect_sound" msgid="7383953383758025895">"Izklopi zvok in vibriranje"</string>
    <string name="zen_mode_block_effect_intent" msgid="350764335391428447">"Ne vklopi zaslona"</string>
    <string name="zen_mode_block_effect_light" msgid="8106976110224107316">"Ne pokaži utripajoče lučke"</string>
    <string name="zen_mode_block_effect_peek" msgid="6836997464098657115">"Ne prikaži obvestil na zaslonu"</string>
    <string name="zen_mode_block_effect_status" msgid="6642532634292373081">"Skrij ikone v vrstici stanja"</string>
    <string name="zen_mode_block_effect_badge" msgid="4656911773512844243">"Skrij obvestilne pike"</string>
    <string name="zen_mode_block_effect_ambient" msgid="4704755879961212658">"Ne vklopi za obvestila"</string>
    <string name="zen_mode_block_effect_list" msgid="3882541635576592530">"Skrij s seznama obvestil"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="2617875282623486256">"Nikoli"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="1230265589026355094">"Pri izklopljenem zaslonu"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="6017536991063513394">"Pri vklopljenem zaslonu"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1065107568053759972">"Zvok in vibriranje"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="3635646031575107456">"Zvok, vibriranje in nekateri vizualni znaki obvestil"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="1213328945418248026">"Zvok, vibriranje in vizualni znaki obvestil"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="5710896246703497760">"Obvestila, potrebna za osnovno delovanje telefona in obveščanje o njegovem stanju, ne bodo nikoli skrita"</string>
    <string name="zen_mode_no_exceptions" msgid="7653433997399582247">"Nič"</string>
    <string name="zen_mode_other_options" msgid="520015080445012355">"druge možnosti"</string>
    <string name="zen_mode_add" msgid="90014394953272517">"Dodaj"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="8287824809739581837">"Vklopi"</string>
    <string name="zen_mode_button_turn_on" msgid="2824380626482175552">"Vklopi zdaj"</string>
    <string name="zen_mode_button_turn_off" msgid="6181953727880503094">"Izklopi zdaj"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8860646554263965569">"Način »ne moti« bo vklopljen do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="7186615007561990908">"Način »ne moti« bo ostal vklopljen, dokler ga ne izklopite"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="7780048616476170427">"Način »ne moti« je bil samodejno vklopljen na podlagi pravila (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="1721179577382915270">"Način »ne moti« je samodejno vklopila aplikacija (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Samo prednostno"</string>
    <string name="zen_mode_and_condition" msgid="4927230238450354412">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="1202632669798211342">"Vklopljeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off_with_info" msgid="2348629457144123849">"Izklopljeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off" msgid="4375814717589425561">"Izklopljeno"</string>
    <string name="zen_mode_sound_summary_on" msgid="7718273231309882914">"Vklopljeno"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="5976427426278136178">"Vedno vprašaj (razen če se vklopi samodejno)"</string>
    <string name="zen_mode_duration_summary_forever" msgid="3144786357459137066">"Dokler ne izklopite (razen če se vklopi samodejno)"</string>
    <plurals name="zen_mode_duration_summary_time_hours" formatted="false" msgid="1060823390336822337">
      <item quantity="one"><xliff:g id="NUM_HOURS">%d</xliff:g> ura (razen če se vklopi samodejno)</item>
      <item quantity="two"><xliff:g id="NUM_HOURS">%d</xliff:g> uri (razen če se vklopi samodejno)</item>
      <item quantity="few"><xliff:g id="NUM_HOURS">%d</xliff:g> ure (razen če se vklopi samodejno)</item>
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> ur (razen če se vklopi samodejno)</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="3959860288930526323">"<xliff:g id="NUM_MINUTES">%d</xliff:g> min. (razen če se vklopi samodejno)"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="8115159143760078050">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> pravilo se lahko samodejno vklopi</item>
      <item quantity="two"><xliff:g id="ON_COUNT">%d</xliff:g> pravili se lahko samodejno vklopita</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> pravila se lahko samodejno vklopijo</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> pravil se lahko samodejno vklopi</item>
    </plurals>
    <string name="zen_category_behavior" msgid="2989256030084350296">"Delovanje"</string>
    <string name="zen_category_exceptions" msgid="7601136604273265629">"Izjeme"</string>
    <string name="zen_category_schedule" msgid="9000447592251450453">"Urnik"</string>
    <string name="zen_sound_title" msgid="424490228488531372">"Zvok in vibriranje"</string>
    <string name="zen_sound_footer" msgid="7621745273287208979">"Pri vklopljenem načinu »ne moti« bosta zvok in vibriranje izklopljena v vseh primerih razen za zgoraj omogočene elemente."</string>
    <string name="zen_sound_category_title" msgid="4336596939661729188">"Prezri vse razen"</string>
    <string name="zen_sound_all_muted" msgid="4850363350480968114">"Prezrto"</string>
    <string name="zen_sound_none_muted" msgid="3938508512103612527">"Ni prezrto"</string>
    <string name="zen_sound_one_allowed" msgid="8447313454438932276">"Zvok je izklopljen; dovoljeni zvok: <xliff:g id="SOUND_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_sound_two_allowed" msgid="980491120444358550">"Zvok je izklopljen; dovoljena zvoka: <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g> in <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_sound_three_allowed" msgid="3455767205934547985">"Zvok je izklopljen; dovoljeni zvoki: <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g>, <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g> in <xliff:g id="SOUND_TYPE_2">%3$s</xliff:g>"</string>
    <string name="zen_msg_event_reminder_title" msgid="5137894077488924820">"Sporočila, dogodki in opomniki"</string>
    <string name="zen_msg_event_reminder_footer" msgid="4376930591019535192">"Pri vklopljenem načinu »ne moti« bodo prezrta vsa sporočila, opomniki in dogodki razen za zgoraj omogočene elemente. Nastavitve sporočil lahko prilagodite tako, da boste dosegljivi za prijatelje, družinske člane ali druge stike."</string>
    <string name="zen_onboarding_ok" msgid="6131211000824433013">"Končano"</string>
    <string name="zen_onboarding_settings" msgid="9046451821239946868">"Nastavitve"</string>
    <string name="zen_onboarding_new_setting_title" msgid="1893095176110470711">"Brez vidnega in zvočnega opozarjanja na obvestila"</string>
    <string name="zen_onboarding_current_setting_title" msgid="776426065129609376">"Brez zvočnega opozarjanja na obvestila"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="6293026064871880706">"Obvestila ne bodo prikazana in ne bodo pospremljena z zvokom. Klici od stikov z zvezdico in večkratnih klicateljev so dovoljeni."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="1280614488924843713">"(trenutna nastavitev)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="1352808651270918932">"Želite spremeniti nastavitve obvestil v načinu »ne moti«?"</string>
    <string name="sound_work_settings" msgid="6774324553228566442">"Zvoki v delovnem profilu"</string>
    <string name="work_use_personal_sounds_title" msgid="1148331221338458874">"Uporaba zvokov iz os. profila"</string>
    <string name="work_use_personal_sounds_summary" msgid="6207040454949823153">"Zvoki v delovnem in osebnem profilu so enaki"</string>
    <string name="work_ringtone_title" msgid="5806657896300235315">"Delovni ton zvonjenja"</string>
    <string name="work_notification_ringtone_title" msgid="6081247402404510004">"Privzeti delovni zvok obvestila"</string>
    <string name="work_alarm_ringtone_title" msgid="1441926676833738891">"Privzeti delovni zvok alarma"</string>
    <string name="work_sound_same_as_personal" msgid="3123383644475266478">"Kot v osebnem profilu"</string>
    <string name="work_sync_dialog_title" msgid="7123973297187354813">"Ali želite zamenjati zvoke?"</string>
    <string name="work_sync_dialog_yes" msgid="7243884940551635717">"Zamenjaj"</string>
    <string name="work_sync_dialog_message" msgid="7841728953710863208">"Zvoki iz osebnega profila bodo uporabljeni v delovnem profilu"</string>
    <string name="ringtones_install_custom_sound_title" msgid="5948792721161302255">"Želite dodati zvok po meri?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="2195581481608512786">"Ta datoteka bo kopirana v mapo <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="5675912303120102366">"Melodije zvonjenja"</string>
    <string name="other_sound_category_preference_title" msgid="2521096636124314015">"Drugi zvoki in vibriranja"</string>
    <string name="configure_notification_settings" msgid="7616737397127242615">"Obvestila"</string>
    <string name="recent_notifications" msgid="5660639387705060156">"Nedavno poslano"</string>
    <string name="recent_notifications_see_all_title" msgid="8572160812124540326">"Prikaz vseh za zadnjih 7 dni"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Dodatno"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Obvestila za delovni profil"</string>
    <string name="notification_badging_title" msgid="5938709971403474078">"Dovoli obvestilne pike"</string>
    <string name="notification_pulse_title" msgid="1905382958860387030">"Utripajoča lučka"</string>
    <string name="lock_screen_notifications_title" msgid="2583595963286467672">"Na zaklenjenem zaslonu"</string>
    <string name="locked_work_profile_notification_title" msgid="8327882003361551992">"Ko je delovni profil zaklenjen"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Pokaži vso vsebino obvestil"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="8301305044690264958">"Skrivanje občutljive vsebine"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"Sploh ne prikazuj obvestil"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6164532459432182244">"Kako naj se obvestila prikazujejo, ko je naprava zaklenjena?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1416589393106326972">"Obvestila"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Pokaži vso vsebino obvestil za delovni profil"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2005907007779384635">"Skrivanje občutljive vsebine za delovni profil"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"Kako naj se obvestila o profilu prikazujejo, ko je naprava zaklenjena?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Obvestila o profilu"</string>
    <string name="notifications_title" msgid="8086372779371204971">"Obvestila"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Obvestila aplikacij"</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Kategorija obvestil"</string>
    <string name="notification_group_title" msgid="7180506440133859601">"Skupina kategorij obvestil"</string>
    <string name="notification_importance_title" msgid="4368578960344731828">"Vedenje"</string>
    <string name="notification_importance_unspecified" msgid="6622173510486113958">"Omogoči zvok"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Nikoli ne pokaži obvestil"</string>
    <string name="notification_importance_min" msgid="9054819132085066824">"Prikaži brez zvoka in minimiraj"</string>
    <string name="notification_importance_low" msgid="2445139943005315690">"Prikaži brez zvoka"</string>
    <string name="notification_importance_default" msgid="5958338024601957516">"Predvajaj zvok"</string>
    <string name="notification_importance_high" msgid="2082429479238228527">"Predvajaj zvok in prikaži na zaslonu"</string>
    <string name="notification_importance_high_silent" msgid="2667033773703765252">"Prikaži na zaslonu"</string>
    <string name="notification_importance_min_title" msgid="6974673091137544803">"Nizka pomembnost"</string>
    <string name="notification_importance_low_title" msgid="8131254047772814309">"Srednja pomembnost"</string>
    <string name="notification_importance_default_title" msgid="9120383978536089489">"Visoka pomembnost"</string>
    <string name="notification_importance_high_title" msgid="3058778300264746473">"Nujno"</string>
    <string name="allow_interruption" msgid="7136150018111848721">"Dovoli prekinitve"</string>
    <string name="allow_interruption_summary" msgid="7870159391333957050">"Dovoli aplikaciji, da predvaja zvok, vibrira in/ali prikaže obvestila na zaslonu"</string>
    <string name="notification_channel_summary_min" msgid="5401718014765921892">"Nizka pomembnost"</string>
    <string name="notification_channel_summary_low" msgid="322317684244981244">"Srednja pomembnost"</string>
    <string name="notification_channel_summary_default" msgid="1111749130423589931">"Visoka pomembnost"</string>
    <string name="notification_channel_summary_high" msgid="2085017556511003283">"Nujna pomembnost"</string>
    <string name="notification_switch_label" msgid="6843075654538931025">"Pokaži obvestila"</string>
    <string name="default_notification_assistant" msgid="7631945224761430146">"Pomočnik za obvestila"</string>
    <string name="notifications_sent_daily" msgid="3584506541352710975">"~<xliff:g id="NUMBER">%1$s</xliff:g> na dan"</string>
    <string name="notifications_sent_weekly" msgid="1030525736746720584">"~<xliff:g id="NUMBER">%1$s</xliff:g> na teden"</string>
    <string name="notifications_sent_never" msgid="1001964786456700536">"Nikoli"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Dostop do obvestil"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8748026238701253040">"Dostop do obvestil delovnega profila je blokiran"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Aplikacije ne morejo brati obvestil"</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="7930130030691218387">
      <item quantity="one">%d aplikacija lahko bere obvestila</item>
      <item quantity="two">%d aplikaciji lahko bereta obvestila</item>
      <item quantity="few">%d aplikacije lahko berejo obvestila</item>
      <item quantity="other">%d aplikacij lahko bere obvestila</item>
    </plurals>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Nobena nameščena aplikacija ni zahtevala dostopa do obvestil."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"Želite storitvi <xliff:g id="SERVICE">%1$s</xliff:g> dovoliti dostop do obvestil?"</string>
    <string name="notification_listener_security_warning_summary" msgid="119203147791040151">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> lahko prebere vsa obvestila, vključno z osebnimi podatki, kot so imena stikov ter besedilo prejetih sporočil. Prav tako lahko opusti obvestila ali sproži gumbe dejanj pri obvestilih. \n\nS tem lahko aplikacija tudi vklopi ali izklopi način »ne moti« in spremeni povezane nastavitve."</string>
    <string name="notification_listener_disable_warning_summary" msgid="6738915379642948000">"Če za aplikacijo <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> izklopite dostop do obvestil, bo dostop do načina »ne moti« morda tudi izklopljen."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="8333442186428083057">"Izklop"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Prekliči"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Storitve za pomoč za VR"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Nobena nameščena aplikacija ni zahtevala izvajanja kot storitev za pomoč za VR."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"Dovolite storitvi <xliff:g id="SERVICE">%1$s</xliff:g> dostop za storitev za VR?"</string>
    <string name="vr_listener_security_warning_summary" msgid="6931541068825094653">"Poslušalec <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> se bo lahko izvajal, ko boste uporabljali aplikacije v načinu za navidezno resničnost."</string>
    <string name="display_vr_pref_title" msgid="8104485269504335481">"Ko je naprava v načinu VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="5707494209944718537">"Zmanjšanje zameglitve (priporočeno)"</string>
    <string name="display_vr_pref_off" msgid="2190091757123260989">"Zmanjšanje utripanja"</string>
    <string name="picture_in_picture_title" msgid="5824849294270017113">"Slika v sliki"</string>
    <string name="picture_in_picture_empty_text" msgid="685224245260197779">"Nobena aktivna aplikacija ne podpira načina slike v sliki"</string>
    <string name="picture_in_picture_keywords" msgid="8361318686701764690">"pip slika v sliki"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4080800421316791732">"Slika v sliki"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="1131910667023738296">"Dovoli sliko v sliki"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="1264019085827708920">"Dovoli tej aplikaciji, da ustvari okno s sliko v sliki, medtem ko je aplikacija odprta ali potem ko jo zapustite (na primer, da nadaljujete z ogledom videoposnetka). To okno prekrije druge aplikacije, ki jih uporabljate."</string>
    <string name="manage_zen_access_title" msgid="2611116122628520522">"Dostop do načina »ne moti«"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Nobena nameščena aplikacija ni zahtevala dostopa do načina »ne moti«"</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Nalaganje aplikacij ..."</string>
    <string name="app_notifications_off_desc" msgid="8289223211387083447">"Na vašo zahtevo je prikazovanje obvestil te aplikacije blokirano v tej napravi Android"</string>
    <string name="channel_notifications_off_desc" msgid="9013011134681491778">"Na vašo zahtevo je prikazovanje te kategorije obvestil blokirano v tej napravi Android"</string>
    <string name="channel_group_notifications_off_desc" msgid="2315252834146837470">"Na vašo zahtevo je prikazovanje te skupine obvestil blokirano v tej napravi Android"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Kategorije"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Drugo"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="3420621520561455358">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g> kategoriji</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorij</item>
    </plurals>
    <string name="no_channels" msgid="3077375508177744586">"Ta aplikacija ni objavila nobenih obvestil"</string>
    <string name="app_settings_link" msgid="8894946007543660906">"Dodatne nastavitve v aplikaciji"</string>
    <string name="app_notification_listing_summary_zero" msgid="8046168435207424440">"Vklopljeno za vse aplikacije"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="6709582776823665660">
      <item quantity="one">Izklopljeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikacijo</item>
      <item quantity="two">Izklopljeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikaciji</item>
      <item quantity="few">Izklopljeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other">Izklopljeno za <xliff:g id="COUNT_1">%d</xliff:g> aplikacij</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="8028574302599397935">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> kategorija je izbrisana</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g> kategoriji sta izbrisani</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> kategorije so izbrisane</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> kategorij je izbrisanih</item>
    </plurals>
    <string name="notification_toggle_on" msgid="650145396718191048">"Vklopljeno"</string>
    <string name="notification_toggle_off" msgid="2142010737190671762">"Izklopljeno"</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Blokiraj vse"</string>
    <string name="app_notification_block_summary" msgid="4744020456943215352">"Nikoli ne prikaži teh obvestil"</string>
    <string name="notification_content_block_title" msgid="5854232570963006360">"Pokaži obvestila"</string>
    <string name="notification_content_block_summary" msgid="7746185794438882389">"Nikoli ne pokaži obvestil na zaslonu z obvestili ali v zunanjih napravah."</string>
    <string name="notification_badge_title" msgid="6370122441168519809">"Dovoli obvestilno piko"</string>
    <string name="notification_channel_badge_title" msgid="2240827899882847087">"Pokaži obvestilno piko"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Preglasitev načina »Ne moti«"</string>
    <string name="app_notification_override_dnd_summary" msgid="2612502099373472686">"Dovoli prikazovanje teh obvestil tudi, ko je vklopljen način »ne moti«"</string>
    <string name="app_notification_visibility_override_title" msgid="7821124557634786985">"Na zaklenjenem zaslonu"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Blokirano"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prednost"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Občutljivo"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Končano"</string>
    <string name="app_notification_importance_title" msgid="8002263131149345584">"Pomembnost"</string>
    <string name="notification_show_lights_title" msgid="7671781299688190532">"Utripajoča lučka"</string>
    <string name="notification_vibrate_title" msgid="1646667807969755957">"Vibriranje"</string>
    <string name="notification_channel_sound_title" msgid="3899212238513507941">"Zvok"</string>
    <string name="zen_mode_rule_delete_button" msgid="903658142711011617">"Izbriši"</string>
    <string name="zen_mode_rule_rename_button" msgid="4642843370946599164">"Preimenuj"</string>
    <string name="zen_mode_rule_name" msgid="5149068059383837549">"Ime pravila"</string>
    <string name="zen_mode_rule_name_hint" msgid="3781174510556433384">"Vnesite ime pravila"</string>
    <string name="zen_mode_rule_name_warning" msgid="4517805381294494314">"Ime pravila je že uporabljeno"</string>
    <string name="zen_mode_add_rule" msgid="9100929184624317193">"Dodaj pravilo"</string>
    <string name="zen_mode_add_event_rule" msgid="3997335103633946552">"Dodaj pravilo za dogodek"</string>
    <string name="zen_mode_add_time_rule" msgid="5002080000597838703">"Dodaj časovno pravilo"</string>
    <string name="zen_mode_delete_rule" msgid="2985902330199039533">"Izbris pravila"</string>
    <string name="zen_mode_choose_rule_type" msgid="5423746638871953459">"Izberite vrsto pravila"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"Želite izbrisati pravilo »<xliff:g id="RULE">%1$s</xliff:g>«?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Izbris"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"Neznano"</string>
    <string name="zen_mode_app_set_behavior" msgid="1534429320064381355">"Teh nastavitev trenutno ni mogoče spremeniti. Aplikacija (<xliff:g id="APP_NAME">%1$s</xliff:g>) je samodejno vklopila način »ne moti« z delovanjem po meri."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="2558968232814237874">"Teh nastavitev trenutno ni mogoče spremeniti. Aplikacija je samodejno vklopila način »ne moti« z delovanjem po meri."</string>
    <string name="zen_mode_qs_set_behavior" msgid="6200424436456086312">"Teh nastavitev trenutno ni mogoče spremeniti. Način »ne moti« je bil ročno vklopljen z delovanjem po meri."</string>
    <string name="zen_schedule_rule_type_name" msgid="6163149826036287324">"Čas"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Samodejno pravilo nastavljeno tako, da se v določenem obdobju vklopi stanje »Ne moti«"</string>
    <string name="zen_event_rule_type_name" msgid="6503468472212606158">"Dogodek"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Samodejno pravilo nastavljeno tako, da se med določenimi dogodki vklopi stanje »Ne moti«"</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Med dogodki za"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Med dogodki za <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"kateri koli koledar"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"Kjer je odgovor <xliff:g id="REPLY">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"Kateri koli koledar"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"Kjer je odgovor"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"Da, Mogoče ali Neodgovorjeno"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"Da ali Mogoče"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Da"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"Pravila ni mogoče najti."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="976098744828219297">"Vklopljeno/<xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="2101201392041867409">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="3195058680641389948">"Dnevi"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Brez"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Vsak dan"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="767054141267122030">"Alarm lahko preglasi končni čas"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="4597050434723180422">"Ustavi se ob končnem času ali naslednjem alarmu (kar se zgodi prej)"</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g>–<xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"Od <xliff:g id="START">%1$s</xliff:g> do <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="7051492091133751208">"Klici"</string>
    <string name="zen_mode_calls_title" msgid="623395033931747661">"Dovoli klice"</string>
    <string name="zen_mode_calls_footer" msgid="3618700268458237781">"Pri vklopljenem načinu »ne moti« so dohodni klici blokirani. Nastavitve lahko prilagodite tako, da boste dosegljivi za prijatelje, družinske člane ali druge stike."</string>
    <string name="zen_mode_starred_contacts_title" msgid="1848464279786960190">"Stiki z zvezdico"</string>
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts" formatted="false" msgid="500105380255018671">
      <item quantity="one">Še <xliff:g id="NUM_PEOPLE">%d</xliff:g> druga oseba</item>
      <item quantity="two">Še <xliff:g id="NUM_PEOPLE">%d</xliff:g> drugi osebi</item>
      <item quantity="few">Še <xliff:g id="NUM_PEOPLE">%d</xliff:g> druge osebe</item>
      <item quantity="other">Še <xliff:g id="NUM_PEOPLE">%d</xliff:g> drugih oseb</item>
    </plurals>
    <string name="zen_mode_messages" msgid="5886440273537510894">"Sporočila"</string>
    <string name="zen_mode_messages_title" msgid="7729380010396411129">"Dovoli sporočila"</string>
    <string name="zen_mode_all_messages" msgid="8257021584561639816">"Sporočila"</string>
    <string name="zen_mode_selected_messages" msgid="1047355526202106114">"Nekatera sporočila"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"Od kogar koli"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Samo od stikov"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Samo od stikov z zvezdico"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="4046151920710059778">"Od stikov z zvezdico in večkratnih klicateljev"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="1528716671301999084">"Od stikov in večkratnih klicateljev"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7105261473107715445">"Samo od večkratnih klicateljev"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Nič"</string>
    <string name="zen_mode_alarms" msgid="2165302777886552926">"Alarmi"</string>
    <string name="zen_mode_media" msgid="8808264142134422380">"Predstavnost"</string>
    <string name="zen_mode_system" msgid="2541380718411593581">"Zvoki dotikov"</string>
    <string name="zen_mode_reminders" msgid="5458502056440485730">"Opomniki"</string>
    <string name="zen_mode_reminders_title" msgid="2345044406347406902">"Dovoli opomnike"</string>
    <string name="zen_mode_events" msgid="7914446030988618264">"Dogodki"</string>
    <string name="zen_mode_events_title" msgid="5597241655883329085">"Dovoli dogodke"</string>
    <string name="zen_mode_all_callers" msgid="2378065871253871057">"vseh"</string>
    <string name="zen_mode_contacts_callers" msgid="5569804103920394175">"stikov"</string>
    <string name="zen_mode_starred_callers" msgid="1023167821338514140">"stiki z zvezdico"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Klicatelji, ki večkrat kličejo"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8553876328249671783">"Dovoli večkratne klicatelje"</string>
    <string name="zen_mode_calls_summary_one" msgid="3972333792749874863">"Od: <xliff:g id="CALLER_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_mode_calls_summary_two" msgid="6592821501321201329">"Od <xliff:g id="CALLER_TYPE">%1$s</xliff:g> in <xliff:g id="CALLERT_TPYE">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="239685342222975733">"Če ista oseba kliče že drugič v <xliff:g id="MINUTES">%d</xliff:g> min."</string>
    <string name="zen_mode_behavior_summary_custom" msgid="168127313238020146">"Po meri"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Samodejni vklop"</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nikoli"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Vsako noč"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Noči med tednom"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Ura začetka"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Ura konca"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> naslednji dan"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Sprememba na samo alarme za nedoločen čas"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <item quantity="one">Sprememba na samo alarme za <xliff:g id="DURATION">%1$d</xliff:g> minuto (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="two">Sprememba na samo alarme za <xliff:g id="DURATION">%1$d</xliff:g> minuti (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="few">Sprememba na samo alarme za <xliff:g id="DURATION">%1$d</xliff:g> minute (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
      <item quantity="other">Sprememba na samo alarme za <xliff:g id="DURATION">%1$d</xliff:g> minut (do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g>)</item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="2407703455581767748">
      <item quantity="one">Sprememba na samo alarme za <xliff:g id="DURATION">%1$d</xliff:g> uro do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="two">Sprememba na samo alarme za <xliff:g id="DURATION">%1$d</xliff:g> uri do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="few">Sprememba na samo alarme za <xliff:g id="DURATION">%1$d</xliff:g> ure do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="other">Sprememba na samo alarme za <xliff:g id="DURATION">%1$d</xliff:g> ur do <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="7465525754879341907">"Sprememba na samo alarme do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Sprememba na vedno prekini"</string>
    <string name="zen_mode_screen_on" msgid="8774571998575673502">"Pri vklopljenem zaslonu"</string>
    <string name="zen_mode_screen_on_summary" msgid="2208664848367443505">"Obvestilom, utišanim z načinom »ne moti«, dovoli, da se prikažejo na zaslonu skupaj z ikono v vrstici stanja"</string>
    <string name="zen_mode_screen_off" msgid="3144446765110327937">"Pri izklopljenem zaslonu"</string>
    <string name="zen_mode_screen_off_summary" msgid="7430034620565812258">"Obvestilom, utišanim z načinom »ne moti«, dovoli, da vklopijo zaslon in sprožijo utripanje lučke"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="2826121465026642017">"Obvestilom, utišanim z načinom »ne moti«, dovoli, da vklopijo zaslon"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Nastavitve obvestil"</string>
    <string name="suggestion_button_text" msgid="3275010948381252006">"V redu"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Pošlji povratne info. o tej napravi"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1085834515677448072">"Vnos skrbniške kode PIN"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Vklopljeno"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Izklopljeno"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Pripenjanje zaslona"</string>
    <string name="screen_pinning_description" msgid="1110847562111827766">"Če je pripenjanje zaslona vklopljeno, lahko z njim ohranite prikaz trenutnega zaslona, dokler ga ne odpnete.\n\nUporaba pripenjanja:\n\n1. Pripenjanje zaslona mora biti vklopljeno.\n\n2. Odprite pregled.\n\n3. Dotaknite se ikone aplikacije na vrhu zaslona, nato se dotaknite ikone za pripenjanje."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Pred odpenjanjem vprašaj za vzorec za odklepanje"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Zahtevaj PIN pred odpenjanjem"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Pred odpenjanjem vprašaj za geslo"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Pri odpenjanju zakleni napravo"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"Ta delovni profil upravlja:"</string>
    <string name="managing_admin" msgid="8843802210377459055">"Upravlja: <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Poskusno)"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Varni zagon"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Naprej"</string>
    <string name="encryption_interstitial_message_pin" msgid="2317181134653424679">"Napravo lahko dodatno zaščitite tako, da ob zagonu zahteva vašo kodo PIN. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi. \n\nTo je v pomoč pri zaščiti podatkov v izgubljenih ali ukradenih napravah. Ali želite nastaviti zahtevo za kodo PIN za zagon naprave?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="7081249914068568570">"Napravo lahko dodatno zaščitite tako, da ob zagonu zahteva vaš vzorec. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi. \n\nTo je v pomoč pri zaščiti podatkov v izgubljenih ali ukradenih napravah. Ali želite nastaviti zahtevo za vzorec za zagon naprave?"</string>
    <string name="encryption_interstitial_message_password" msgid="7796567133897436443">"Napravo lahko dodatno zaščitite tako, da ob zagonu zahteva vaše geslo. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi. \n\nTo je v pomoč pri zaščiti podatkov v izgubljenih ali ukradenih napravah. Ali želite nastaviti zahtevo za geslo za zagon naprave?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="4550632760119547492">"Poleg tega, da napravo odklepate s prstnim odtisom, jo lahko dodatno zaščitite tako, da ob zagonu zahteva vašo kodo PIN. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi. \n\nTo je v pomoč pri zaščiti podatkov v izgubljenih ali ukradenih napravah. Ali želite nastaviti zahtevo za kodo PIN za zagon naprave?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="932184823193006087">"Poleg tega, da napravo odklepate s prstnim odtisom, jo lahko dodatno zaščitite tako, da ob zagonu zahteva vaš vzorec. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi. \n\nTo je v pomoč pri zaščiti podatkov v izgubljenih ali ukradenih napravah. Ali želite nastaviti zahtevo za vzorec za zagon naprave?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="5560954719370251702">"Poleg tega, da napravo odklepate s prstnim odtisom, jo lahko dodatno zaščitite tako, da ob zagonu zahteva vaše geslo. Dokler se naprava ne zažene, ne more prejemati klicev, sporočil ali obvestil, vključno z alarmi.\n\nTo je v pomoč pri zaščiti podatkov v izgubljenih ali ukradenih napravah. Ali želite nastaviti zahtevo za geslo za zagon naprave?"</string>
    <string name="encryption_interstitial_yes" msgid="4439509435889513411">"Da"</string>
    <string name="encryption_interstitial_no" msgid="8935031349097025137">"Ne"</string>
    <string name="restricted_true_label" msgid="4761453839409220473">"Omejeno"</string>
    <string name="restricted_false_label" msgid="3279282180297058755">"Lahko porablja akumulator v ozadju"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"Zahtevanje kode PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"Zahtevanje vzorca?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"Zahtevanje gesla?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"Ko vnesete kodo PIN za zagon te naprave, storitve za osebe s posebnimi potrebami, kot je <xliff:g id="SERVICE">%1$s</xliff:g>, še ne bodo na voljo."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="2020083142199612743">"Ko vnesete vzorec za zagon te naprave, storitve za osebe s posebnimi potrebami, kot je <xliff:g id="SERVICE">%1$s</xliff:g>, še ne bodo na voljo."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="4155875981789127796">"Ko vnesete geslo za zagon te naprave, storitve za osebe s posebnimi potrebami, kot je <xliff:g id="SERVICE">%1$s</xliff:g>, še ne bodo na voljo."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="2433632805847985867">"Opomba: po vnovičnem zagonu telefona z nastavljenim zaklepanjem zaslona se ta aplikacija ne more zagnati, dokler ne odklenete telefona."</string>
    <string name="imei_information_title" msgid="8499085421609752290">"Podatki o IMEI"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Relativni podatki o IMEI"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Reža <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Privzeto odpiranje"</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Odpiranje povezav"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Odpiranje podprtih povezav"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Odpiranje brez vprašanj"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Podprte povezave"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Druge privzete nastavitve"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"Uporabljeno: <xliff:g id="SIZE">%1$s</xliff:g> – <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Notranja shramba"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Zunanja shramba"</string>
    <string name="app_data_usage" msgid="7942375313697452803">"Prenos podatkov aplikacije"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"Preneseno <xliff:g id="SIZE">%1$s</xliff:g> od <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Uporabljena shramba"</string>
    <string name="change" msgid="6657848623929839991">"Sprememba"</string>
    <string name="change_storage" msgid="600475265207060436">"Sprememba shrambe"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Obvestila"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Vklopljeno"</string>
    <string name="notifications_enabled_with_info" msgid="2446033696770133334">"Vklopljeno/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%1$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="1262114548434938079">"Izklopljeno"</string>
    <string name="notifications_partly_blocked" msgid="592071133950126656">"<xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g> kategorij je izklopljenih"</string>
    <string name="notifications_silenced" msgid="4728603513072110381">"Utišano"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Občutljive vsebine ne pokaži na zaklenjenem zaslonu"</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"Ne pokaži na zaklenjenem zaslonu"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"Način »ne moti« je preglašen"</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"Stopnja %d"</string>
    <string name="notification_summary_channel" msgid="5831124672372023524">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</string>
    <plurals name="notifications_categories_off" formatted="false" msgid="5583365573683409754">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> izklopljena kategorija</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g> izklopljeni kategoriji</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> izklopljene kategorije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> izklopljenih kategorij</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="6402730318075959117">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> odobreno dovoljenje</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g> odobreni dovoljenji</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> odobrena dovoljenja</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> odobrenih dovoljenj</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="1564663886246010959">
      <item quantity="one">Število odobrenih dovoljenj: <xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g></item>
      <item quantity="two">Število odobrenih dovoljenj: <xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g></item>
      <item quantity="few">Število odobrenih dovoljenj: <xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g></item>
      <item quantity="other">Število odobrenih dovoljenj: <xliff:g id="COUNT_2">%d</xliff:g> od <xliff:g id="COUNT_3">%d</xliff:g></item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="931276038884210752">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> dodatno dovoljenje</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g> dodatni dovoljenji</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> dodatna dovoljenja</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> dodatnih dovoljenj</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="1679758182657005375">"Ni odobrenih dovoljenj"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"Ni zahtevanih dovoljenj"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Vse aplikacije"</string>
    <string name="filter_enabled_apps" msgid="5395727306799456250">"Nameščene aplikacije"</string>
    <string name="filter_instant_apps" msgid="574277769963965565">"Nenamestljive aplikacije"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Osebno"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Služba"</string>
    <string name="filter_notif_all_apps" msgid="2299049859443680242">"Aplikacije: vse"</string>
    <string name="filter_notif_blocked_apps" msgid="3300375727887991342">"Aplikacije: izklopljeno"</string>
    <string name="filter_notif_urgent_channels" msgid="3972473613117159653">"Kategorije: nujna pomembnost"</string>
    <string name="filter_notif_low_channels" msgid="4128487387390004604">"Kategorije: nizka pomembnost"</string>
    <string name="filter_notif_blocked_channels" msgid="5880190882221644289">"Kategorije: izklopljeno"</string>
    <string name="filter_notif_dnd_channels" msgid="1817930848881696728">"Kategorije: preglasi »ne moti«"</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Dodatno"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Konfiguriranje aplikacij"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Neznana aplikacija"</string>
    <string name="app_permissions" msgid="4148222031991883874">"Dovoljenja za aplikacije"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Aplikacije uporabljajo: <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Dot. za prekl. iz stan. pripr."</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Za preklop naprave iz stanja pripravljenosti se dvakrat dotaknite kjer koli na zaslonu"</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Odpiranje povezav"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"Brez odpiranja podprtih povezav"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Odpre <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="3950089361819428455">"Odpiranje naslova <xliff:g id="DOMAIN">%s</xliff:g> in drugih URL-jev"</string>
    <string name="domain_urls_apps_summary_off" msgid="1833056772600031220">"Nobena aplikacija ne odpira podprtih povezav"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="240214361240709399">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikacija odpira podprte povezave</item>
      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> aplikaciji odpirata podprte povezave</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacije odpirajo podprte povezave</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacij odpira podprte povezave</item>
    </plurals>
    <string name="app_link_open_always" msgid="2474058700623948148">"Odpri v tej aplikaciji"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Vedno vprašaj"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"Ne odpri v tej aplikaciji"</string>
    <string name="fingerprint_not_recognized" msgid="1739529686957438119">"Ni prepoznano"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Privzeto"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Privzeto za delo"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Pomoč in glasovni vnos"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Aplikacija za pomoč"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"Ali želite, da je aplikacija <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> vaš pomočnik?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"Pomočnik bo lahko bral podatke o aplikacijah, ki se uporabljajo v vašem sistemu, vključno s podatki, ki so vidni na zaslonu ali do katerih je mogoče dostopati v aplikacijah."</string>
    <string name="assistant_security_warning_agree" msgid="7710290206928033908">"Strinjam se"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Ne strinjam se"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Izbira glasovnega vnosa"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Brskalnik"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"Ni privzetega brskalnika"</string>
    <string name="default_phone_title" msgid="282005908059637350">"Aplikacija za telefon"</string>
    <string name="default_app" msgid="6864503001385843060">"(Privzeto)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Sistemska)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Sistemska privzeta)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Shramba za aplikacije"</string>
    <string name="usage_access" msgid="5479504953931038165">"Dostop do podatkov o uporabi"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Dovoli dostop do podatkov o uporabi"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Nastavitve uporabe aplikacije"</string>
    <string name="time_spent_in_app_pref_title" msgid="649419747540933845">"Čas, porabljen v aplikaciji"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"Dostop do podatkov o uporabi aplikaciji omogoča, da spremlja, katere aplikacije še uporabljate in kako pogosto, ter da si ogleda podrobnosti o operaterju, nastavitvah jezika in drugem."</string>
    <string name="memory_settings_title" msgid="7490541005204254222">"Pomnilnik"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Podrobnosti pomnilnika"</string>
    <string name="always_running" msgid="6042448320077429656">"Vedno se izvaja (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"Včasih se izvaja (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Redko se izvaja (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Največ"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Povprečno"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Največ <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"Povprečno <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="3459065925679828230">"Optimizacija akumulatorja"</string>
    <string name="additional_battery_info" msgid="4754099329165411970">"Opozorila o porabi"</string>
    <string name="show_all_apps" msgid="1512506948197818534">"Prikaz vseh podatkov o uporabi naprave"</string>
    <string name="hide_extra_apps" msgid="5016497281322459633">"Prikaz uporabe aplikacij"</string>
    <string name="power_high_usage_title" msgid="6027369425057347826">"Visoka poraba energije"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="467347882627862744">
      <item quantity="one">Neobičajno delovanje <xliff:g id="NUMBER">%2$d</xliff:g> aplikacije</item>
      <item quantity="two">Neobičajno delovanje <xliff:g id="NUMBER">%2$d</xliff:g> aplikacij</item>
      <item quantity="few">Neobičajno delovanje <xliff:g id="NUMBER">%2$d</xliff:g> aplikacij</item>
      <item quantity="other">Neobičajno delovanje <xliff:g id="NUMBER">%2$d</xliff:g> aplikacij</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="3826660033363082922">
      <item quantity="one">Energijsko potratne aplikacije</item>
      <item quantity="two">Energijsko potratne aplikacije</item>
      <item quantity="few">Energijsko potratne aplikacije</item>
      <item quantity="other">Energijsko potratne aplikacije</item>
    </plurals>
    <string name="high_power_filter_on" msgid="3222265297576680099">"Ni optimizirano"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Ni optimizirano"</string>
    <string name="high_power_off" msgid="3393904131961263278">"Optimizacija uporabe akumulatorja"</string>
    <string name="high_power_system" msgid="7362862974428225301">"Optimizacija akumulatorja ni na voljo"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"Ne uporabljaj optimizacije akumulatorja. Akumulator se lahko hitreje izprazni."</string>
    <string name="high_power_prompt_title" msgid="6358673688590282655">"Želite omogočiti stalno izvajanje aplikacije v ozadju?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"Če omogočite aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> stalno izvajanje v ozadju, lahko to skrajša čas delovanja na akumulatorsko napajanje. \n\nNastavitev lahko pozneje spremenite v »Nastavitve &gt; Aplikacije in obvestila«."</string>
    <string name="battery_summary" msgid="8044042095190688654">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> uporabe od zadnje polne napolnjenosti"</string>
    <string name="battery_power_management" msgid="5571519699679107523">"Upravljanje napajanja"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"Akumulator ni bil uporabljen od zadnje polne napolnjenosti"</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Nastavitve aplikacij"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Prikaži sprejemnik upor. vmes. sistema"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Dodatna dovoljenja"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"Še <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1124840737776588602">"Želite poročilo o napakah dati v skupno rabo?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"Skrbnik za IT je zahteval poročilo o napakah za pomoč pri odpravljanju napak v tej napravi. Aplikacije in podatki bodo morda dani v skupno rabo."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="3495929560689435496">"Skrbnik za IT je zahteval poročilo o napakah za pomoč pri odpravljanju napak v tej napravi. Aplikacije in podatki bodo morda dani v skupno rabo in delovanje naprave bo morda začasno upočasnjeno."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="5859287696666024466">"To poročilo o napakah je v skupni rabi s skrbnikom za IT. Če želite več podrobnosti, se obrnite nanj."</string>
    <string name="share_remote_bugreport_action" msgid="532226159318779397">"Skupna raba"</string>
    <string name="decline_remote_bugreport_action" msgid="518720235407565134">"Zavrnitev"</string>
    <string name="usb_use_charging_only" msgid="4800495064747543954">"Brez prenosa podatkov"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Samo polnjenje akumulatorja naprave"</string>
    <string name="usb_use_power_only" msgid="3236391691786786070">"Polnjenje priključene naprave"</string>
    <string name="usb_use_file_transfers" msgid="1223134119354320726">"Prenos datotek"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Prenos datotek v drugo napravo"</string>
    <string name="usb_use_photo_transfers" msgid="8192719651229326283">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Prenos fotografij ali datotek, če MTP ni podprt (PTP)"</string>
    <string name="usb_use_tethering" msgid="3944506882789422118">"Internet prek USB-ja"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Uporaba te naprave kot vmesnik MIDI"</string>
    <string name="usb_use" msgid="3372728031108932425">"Uporaba povezave USB za"</string>
    <string name="usb_default_label" msgid="2211094045594574774">"Privzeta konfiguracija povezave USB"</string>
    <string name="usb_default_info" msgid="8864535445796200695">"Te nastavitve bodo uporabljene, ko bo telefon odklenjen in povezan z drugo napravo. Telefon povežite samo z zaupanja vrednimi napravami."</string>
    <string name="usb_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_preference" msgid="7394265019817945275">"Nastavitve povezave USB"</string>
    <string name="usb_control_title" msgid="4404322722995917160">"Povezavo USB upravlja"</string>
    <string name="usb_control_host" msgid="2276710819046647200">"Povezana naprava"</string>
    <string name="usb_control_device" msgid="5821511964163469463">"Ta naprava"</string>
    <string name="usb_switching" msgid="8995313698715545619">"Preklapljanje …"</string>
    <string name="usb_switching_failed" msgid="4156073015692409651">"Preklop ni uspel"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Polnjenje te naprave"</string>
    <string name="usb_summary_power_only" msgid="1996391096369798526">"Polnjenje akumulatorja v povezani napravi"</string>
    <string name="usb_summary_file_transfers" msgid="6925168380589489645">"Prenos datotek"</string>
    <string name="usb_summary_tether" msgid="951190049557074535">"Internet prek USB-ja"</string>
    <string name="usb_summary_photo_transfers" msgid="665584667685030007">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2399066753961085360">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="7700800611455849806">"Prenos datotek in napajanje"</string>
    <string name="usb_summary_tether_power" msgid="5825335393952752238">"Internet in napajanje prek USB-ja"</string>
    <string name="usb_summary_photo_transfers_power" msgid="6826058111908423069">"PTP in napajanje"</string>
    <string name="usb_summary_MIDI_power" msgid="3308250484012677596">"MIDI in napajanje"</string>
    <string name="background_check_pref" msgid="7550258400138010979">"Preverjanje ozadja"</string>
    <string name="background_check_title" msgid="4534254315824525593">"Poln dostop do ozadja"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Uporaba besedila na zaslonu"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Aplikaciji za pomoč dovoli dostop do vsebine na zaslonu v obliki besedila"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Uporaba posnetka zaslona"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Aplikaciji za pomoč dovoli dostop do posnetka zaslona"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Utripanje zaslona"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"Utripanje robov zaslona, ko aplikacija za pomoč dostopa do besedila z zaslona ali posnetka zaslona"</string>
    <string name="assist_footer" msgid="1982791172085896864">"Aplikacije za pomoč vam pomagajo na podlagi podatkov na zaslonu, ki si ga ogledujete. Nekatere aplikacije podpirajo storitve zaganjalnika in glasovnega vnosa pri zagotavljanju integrirane pomoči."</string>
    <string name="average_memory_use" msgid="829566450150198512">"Povprečna uporaba pomnilnika"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Največja uporaba pomnilnika"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Uporaba pomnilnika"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Uporaba aplikacije"</string>
    <string name="memory_details" msgid="5943436005716991782">"Podrobnosti"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"Povprečno <xliff:g id="SIZE">%1$s</xliff:g> uporabljenega pomnilnika v zadnjih 3 urah"</string>
    <string name="no_memory_use_summary" msgid="2016900536806235588">"V zadnjih 3 urah ni bilo uporabe pomnilnika"</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Razvrsti glede na povprečno uporabo"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Razvrsti glede na največjo uporabo"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Izvajanje"</string>
    <string name="total_memory" msgid="2017287600738630165">"Pomnilnik – skupno"</string>
    <string name="average_used" msgid="5338339266517245782">"Povprečno uporabljeno (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"Prosto"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Pomnilnik, ki ga uporabljajo aplikacije"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> aplikacija je uporabljala pomnilnik v zadnjega toliko časa: <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="two"><xliff:g id="COUNT">%1$d</xliff:g> aplikaciji sta uporabljali pomnilnik v zadnjega toliko časa: <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> aplikacije so uporabljale pomnilnik v zadnjega toliko časa: <xliff:g id="DURATION_1">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplikacij je uporabljalo pomnilnik v zadnjega toliko časa: <xliff:g id="DURATION_1">%2$s</xliff:g></item>
    </plurals>
    <string name="running_frequency" msgid="6622624669948277693">"Frekvenca"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Največja uporaba"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"Ni bilo uporabe podatkov"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"Dovolite aplikaciji <xliff:g id="APP">%1$s</xliff:g> dostop do funkcije »ne moti«?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="4015885767653010873">"Aplikacija bo lahko vklopila/izklopila način »ne moti« in spreminjala povezane nastavitve."</string>
    <string name="zen_access_disabled_package_warning" msgid="302820100078584431">"Mora biti vklopljeno, ker je vklopljen dostop do obvestil"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="558779234015793950">"Želite aplikaciji <xliff:g id="APP">%1$s</xliff:g> preklicati dostop do načina »ne moti«?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="5518216907304930148">"Vsa pravila za način »ne moti«, ki jih je ustvarila ta aplikacija, bodo odstranjena."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"Brez optimizacije"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimizacija"</string>
    <string name="ignore_optimizations_on_desc" msgid="3549930955839111652">"Akumulator se lahko hitreje izprazni. Aplikaciji ne bo več preprečena poraba energije akumulatorja v ozadju."</string>
    <string name="ignore_optimizations_off_desc" msgid="5255731062045426544">"Priporočljivo za daljši čas delovanja akumulatorja"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"Naj bo aplikaciji <xliff:g id="APP">%s</xliff:g> dovoljeno prezreti optimizacije akumulatorja?"</string>
    <string name="app_list_preference_none" msgid="108006867520327904">"Nič"</string>
    <string name="work_profile_usage_access_warning" msgid="2918050775124911939">"Če za to aplikacijo izklopite dostop do podatkov o uporabi, lahko vaš skrbnik kljub temu spremlja podatke o uporabi za aplikacije v vašem delovnem profilu."</string>
    <string name="accessibility_lock_screen_progress" msgid="2408292742980383166">"Št. uporabljenih znakov: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="draw_overlay" msgid="6564116025404257047">"Prekrivanje drugih aplikacij"</string>
    <string name="system_alert_window_settings" msgid="8466613169103527868">"Prekrivanje drugih aplikacij"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Aplikacije"</string>
    <string name="system_alert_window_access_title" msgid="6297115362542361241">"Prekrivanje drugih aplikacij"</string>
    <string name="permit_draw_overlay" msgid="7456536798718633432">"Dovoli prekrivanje drugih aplikacij"</string>
    <string name="allow_overlay_description" msgid="8961670023925421358">"Omogočite tej aplikaciji, da prekrije druge aplikacije, ki jih uporabljate. To lahko vpliva na uporabo teh aplikacij ali spremeni njihov običajen videz ali delovanje."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"vr navidezna resničnost poslušalec stereo storitev za pomoč"</string>
    <string name="keywords_system_alert_window" msgid="5049498015597864850">"sistemsko opozorilo pogovorno okno prikaz s prekrivanjem drugih aplikacij"</string>
    <string name="overlay_settings" msgid="6930854109449524280">"Prekrivanje drugih aplikacij"</string>
    <string name="system_alert_window_summary" msgid="602892301318324492">"<xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g> aplikacij, ki lahko prekrivajo druge aplikacije"</string>
    <string name="filter_overlay_apps" msgid="6965969283342557573">"Aplikacije z dovoljenjem"</string>
    <string name="app_permission_summary_allowed" msgid="1505409933012886711">"Dovoljene"</string>
    <string name="app_permission_summary_not_allowed" msgid="2592617058101882802">"Ni dovoljeno"</string>
    <string name="keywords_install_other_apps" msgid="761078076051006558">"nameščanje aplikacij neznani viri"</string>
    <string name="write_settings" msgid="4797457275727195681">"Spreminjanje sist. nastavitev"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"zapisovanje spreminjanje sistemske nastavitve"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"Aplikacije, ki lahko spreminjajo sistemske nastavitve: <xliff:g id="COUNT_0">%1$d</xliff:g> od <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="filter_install_sources_apps" msgid="3102976274848199118">"Lahko namestijo druge aplikacije"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"Lahko spreminjajo sistemske nastavitve"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"Lahko spreminjajo sistemske nastavitve"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Spreminjanje sist. nastavitev"</string>
    <string name="permit_write_settings" msgid="658555006453212691">"Dovoli spreminjanje sistemskih nastavitev"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"To dovoljenje aplikaciji dovoljuje spreminjanje sistemskih nastavitev."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Da"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"Ne"</string>
    <string name="external_source_switch_title" msgid="3621381992793251070">"Dovoli aplikacije iz tega vira"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Dvakratno sukanje za fotoaparat"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"Odprite aplikacijo za fotografiranje, tako da dvakrat zasukate zapestje"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="1651873760405034645">"Dva dotika gumba za vklop za fotoaparat"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Hitro odpre fotoaparat brez odklepanja zaslona"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Velikost prikaza"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Pomanjšava ali povečava elementov na zaslonu"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"gostota zaslona, povečava zaslona, razmerje, spreminjanje velikosti"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"Pomanjšava ali povečava elementov na zaslonu – s tem se bo morda spremenil položaj nekaterih aplikacij na zaslonu."</string>
    <string name="screen_zoom_preview_title" msgid="4680671508172336572">"Predogled"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="4622359904253364742">"Pomanjšanje"</string>
    <string name="screen_zoom_make_larger_desc" msgid="2236171043607896594">"Povečanje"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="8443032489384985820">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="998709701837681129">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="6546951024984852686">"Živijo, Peter."</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"Živijo. Bi se danes dobila na kavi?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Odlična zamisel. Poznam prijeten lokal nedaleč proč."</string>
    <string name="screen_zoom_conversation_message_4" msgid="5564676794767555447">"Super."</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="7453710416319650556">"Tor., 18.00"</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="7107225702890747588">"Tor., 18.01"</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="3785674344762707688">"Tor., 18.02"</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2511469395448561259">"Tor., 18.03"</string>
    <string name="disconnected" msgid="4836600637485526329">"Povezava ni vzpostavljena"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"Prenesenih podatkov: <xliff:g id="AMOUNT">%1$s</xliff:g>"</string>
    <string name="data_usage_wifi_format" msgid="5417296451392612860">"Uporabljeno v omrežju Wi-Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <plurals name="notification_summary" formatted="false" msgid="3941492005316143599">
      <item quantity="one">Izklopljeno za <xliff:g id="COUNT">%d</xliff:g> aplikacijo</item>
      <item quantity="two">Izklopljeno za <xliff:g id="COUNT">%d</xliff:g> aplikaciji</item>
      <item quantity="few">Izklopljeno za <xliff:g id="COUNT">%d</xliff:g> aplikacije</item>
      <item quantity="other">Izklopljeno za <xliff:g id="COUNT">%d</xliff:g> aplikacij</item>
    </plurals>
    <string name="notification_summary_none" msgid="4586376436702610">"Vklopljeno za vse aplikacije"</string>
    <string name="apps_summary" msgid="193158055537070092">"Nameščenih aplikacij: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="apps_summary_example" msgid="2118896966712746139">"Nameščenih je 24 aplikacij"</string>
    <string name="storage_summary" msgid="3801281635351732202">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> uporabljeno – <xliff:g id="FREE_SPACE">%2$s</xliff:g> prosto"</string>
    <string name="storage_summary_with_sdcard" msgid="3290457009629490121">"Notranji pomnilnik: <xliff:g id="PERCENTAGE">%1$s</xliff:g> uporabljeno – <xliff:g id="FREE_SPACE">%2$s</xliff:g> prosto"</string>
    <string name="display_summary" msgid="6737806235882127328">"Stanje pripravljenosti po <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> nedejavnosti"</string>
    <string name="display_dashboard_summary" msgid="4145888780290131488">"Ozadje, stanje pripravljenosti, velikost pisave"</string>
    <string name="display_summary_example" msgid="9102633726811090523">"Stanje pripravljenosti po 10 minutah nedejavnosti"</string>
    <string name="memory_summary" msgid="8080825904671961872">"Povprečna uporaba pomnilnika: <xliff:g id="USED_MEMORY">%1$s</xliff:g> od <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="1674864467098487328">"Prijavljeni ste kot <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="3472482669588561110">"<xliff:g id="APP_NAME">%1$s</xliff:g> je privzeta aplikacija"</string>
    <string name="location_on_summary" msgid="3637699010986988970">"Vklopljeno"</string>
    <string name="location_off_summary" msgid="7217264690673949107">"Izklopljeno"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Varnostno kopiranje je onemogočeno"</string>
    <string name="android_version_summary" msgid="2935995161657697278">"Posodobljeno na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="487831391976523090">"Na voljo je posodobljena različica"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Dejanje ni dovoljeno"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="3208724801293696486">"Spreminjanje glasnosti ni mogoče"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="7919816644946067058">"Klicanje ni omogočeno"</string>
    <string name="disabled_by_policy_title_sms" msgid="5733307423899610340">"Pošiljanje sporočil SMS ni omogočeno"</string>
    <string name="disabled_by_policy_title_camera" msgid="6225008536855644874">"Fotoaparat ni omogočen"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="4066913623298047094">"Ustvarjanje posnetka zaslona ni omogočeno"</string>
    <string name="disabled_by_policy_title_turn_off_backups" msgid="7330460584199383321">"Varnostnega kopiranja ni mogoče izklopiti"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="7872038990805477554">"Te aplikacije ni mogoče odpreti"</string>
    <string name="default_admin_support_msg" msgid="4489678214035485367">"Če imate vprašanja, se obrnite na skrbnika za IT"</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Več podrobnosti"</string>
    <string name="admin_profile_owner_message" msgid="5860816886981109626">"Skrbnik lahko nadzira in upravlja aplikacije ter podatke, povezane s tem delovnim profilom, vključno z nastavitvami, dovoljenji, dostopom za podjetje, omrežno dejavnostjo in podatki o lokaciji naprave."</string>
    <string name="admin_profile_owner_user_message" msgid="3842630535450382172">"Skrbnik lahko nadzira in upravlja aplikacije ter podatke, povezane s tem uporabnikom, vključno z nastavitvami, dovoljenji, dostopom za podjetje, omrežno dejavnostjo in podatki o lokaciji naprave."</string>
    <string name="admin_device_owner_message" msgid="6232893638259790789">"Skrbnik lahko nadzira in upravlja aplikacije ter podatke, povezane s to napravo, vključno z nastavitvami, dovoljenji, dostopom za podjetje, omrežno dejavnostjo in podatki o lokaciji naprave."</string>
    <string name="condition_turn_off" msgid="1960945836880080298">"Izklop"</string>
    <string name="condition_turn_on" msgid="9089876276117874591">"Vklop"</string>
    <string name="condition_expand_show" msgid="608202020023489939">"Prikaz"</string>
    <string name="condition_expand_hide" msgid="948507739223760667">"Skrivanje"</string>
    <string name="condition_hotspot_title" msgid="7778958849468560027">"Dostopna točka je vklopljena"</string>
    <string name="condition_hotspot_summary" msgid="3433182779269409683">"Prenosna dostopna točka Wi-Fi <xliff:g id="ID_1">%1$s</xliff:g> je aktivna, povezava Wi-Fi za to napravo je izklopljena."</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"Način za letalo je vklopljen"</string>
    <string name="condition_airplane_summary" msgid="7098837989877102577">"Ko je način za letalo vklopljen, se Wi‑Fi, Bluetooth in mobilno omrežje izklopijo. Wi-Fi in Bluetooth lahko znova vklopite."</string>
    <string name="condition_zen_title" msgid="2897779738211625">"Način »ne moti« je vklopljen"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Varč. z energijo akum. je vkl."</string>
    <string name="condition_battery_summary" msgid="507347940746895275">"Varčevanje z energijo akumulatorja izklopi nekatere funkcije naprave in omeji aplikacije"</string>
    <string name="condition_cellular_title" msgid="1327317003797575735">"Mobilni podatki so izklopljeni"</string>
    <string name="condition_cellular_summary" msgid="1818046558419658463">"Internet je na voljo samo prek omrežja Wi-Fi"</string>
    <string name="condition_bg_data_title" msgid="2483860304802846542">"Varčevanje s podatki je vklopljeno"</string>
    <string name="condition_bg_data_summary" msgid="656957852895282228">"Prenos podatkov v ozadju je na voljo samo prek omrežja Wi-Fi. To morda vpliva na nekatere aplikacije ali storitve, ko omrežje Wi-Fi ni na voljo."</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Delovni profil je izklopljen"</string>
    <string name="condition_work_summary" msgid="7543202177571590378">"Aplikacije, sinhronizacija v ozadju in druge funkcije, povezane z delovnim profilom, so izklopljeni."</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4930240942726349213">"Vklop zvoka"</string>
    <string name="condition_device_muted_title" product="tablet" msgid="3095044864508335783">"Zvok naprave je izklopljen"</string>
    <string name="condition_device_muted_title" product="default" msgid="5818278137378379647">"Zvok telefona je izklopljen"</string>
    <string name="condition_device_muted_summary" msgid="5445341185705628047">"Klici in obvestila bodo utišani"</string>
    <string name="condition_device_vibrate_title" product="tablet" msgid="1983420639621523345">"Naprava je nastavljena na vibriranje"</string>
    <string name="condition_device_vibrate_title" product="default" msgid="1087633233379991925">"Telefon je nastavljen na vibriranje"</string>
    <string name="condition_device_vibrate_summary" product="tablet" msgid="433514444618164607">"Vibriranje naprave bo vklopljeno za klice in obvestila"</string>
    <string name="condition_device_vibrate_summary" product="default" msgid="5877034997839162763">"Vibriranje telefona bo vklopljeno za klice in obvestila"</string>
    <string name="night_display_suggestion_title" msgid="6602129097059325291">"Nastavi razpored za nočno svetlobo"</string>
    <string name="night_display_suggestion_summary" msgid="228346372178218442">"Samodejno obarvanje zaslona vsak večer"</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"Nočna svetloba je vklopljena"</string>
    <string name="condition_night_display_summary" msgid="5443722724310650381">"Zaslon ima jantarni odtenek. To vam lahko pomaga prej zaspati."</string>
    <string name="suggestions_title_v2" msgid="5601181602924147569">"Predlagano za vas"</string>
    <string name="suggestions_title" msgid="7280792342273268377">"Predlogi"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"in še <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="8223690393059519879">"in še <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="1857433444865249823">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> predlog</item>
      <item quantity="two"><xliff:g id="COUNT">%1$d</xliff:g> predloga</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> predlogi</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> predlogov</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="7680263825371165461">
      <item quantity="one">in še <xliff:g id="COUNT">%1$d</xliff:g> predlog</item>
      <item quantity="two">in še <xliff:g id="COUNT">%1$d</xliff:g> predloga</item>
      <item quantity="few">in še <xliff:g id="COUNT">%1$d</xliff:g> predlogi</item>
      <item quantity="other">in še <xliff:g id="COUNT">%1$d</xliff:g> predlogov</item>
    </plurals>
    <string name="suggestion_remove" msgid="904627293892092439">"Odstrani"</string>
    <string name="color_temperature" msgid="2070126836910615605">"Hladnejša barvna temperatura"</string>
    <string name="color_temperature_desc" msgid="4793729830226404052">"Uporaba hladnejših barv zaslona"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Če želite uveljaviti spremembo barv, izklopite zaslon"</string>
    <string name="camera_laser_sensor_switch" msgid="8913588990743234440">"Lasersko tipalo fotoaparata"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Samodejne sistemske posodobitve"</string>
    <string name="ota_disable_automatic_update_summary" msgid="940729694354373087">"Namesti posodobitve ob vnovičnem zagonu naprave"</string>
    <string name="usage" msgid="2977875522080448986">"Poraba"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Poraba mobilnih podatkov"</string>
    <string name="app_cellular_data_usage" msgid="5468472735806533448">"Prenesena količina podatkov aplikacije"</string>
    <string name="wifi_data_usage" msgid="771603760674507659">"Prenesena količina podatkov v omrežju Wi-Fi"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Preneseni podatki (ethernet)"</string>
    <string name="wifi" msgid="1081550856200013637">"Wi-Fi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Ethernet"</string>
    <string name="cell_data_template" msgid="405684854174361041">"<xliff:g id="AMOUNT">^1</xliff:g> podatkov v mobilnem omrežju"</string>
    <string name="wifi_data_template" msgid="6265570748799357386">"<xliff:g id="AMOUNT">^1</xliff:g> podatkov prek omrežij Wi-Fi"</string>
    <string name="ethernet_data_template" msgid="5782476509881033590">"<xliff:g id="AMOUNT">^1</xliff:g> podatkov prek etherneta"</string>
    <string name="cell_warning_only" msgid="763147658209027140">"Opozorilo za prenos podatkov: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="cell_warning_and_limit" msgid="2273413629267437470">"Opozorilo za prenos podatkov: <xliff:g id="ID_1">%1$s</xliff:g>/omejitev prenosa podatkov: <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="billing_cycle" msgid="6614597736285325497">"Opoz. in omej. za prenos pod."</string>
    <string name="app_usage_cycle" msgid="8877223251648092131">"Cikel porabe podatkov aplikacije"</string>
    <string name="cell_data_warning" msgid="1985956818884847057">"Opozorilo ob preneseni količini podatkov <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="1578367585799358854">"Omejitev prenosa podatkov pri <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="6888825370687743208">"Opozorilo ob preneseni količini podatkov <xliff:g id="ID_1">^1</xliff:g>/omejitev prenosa podatkov pri <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="billing_cycle_fragment_summary" msgid="8231066353654583106">"Mesečno na dan <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Omejitve omrežja"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="4301618027244595839">
      <item quantity="one"><xliff:g id="COUNT">%1$d</xliff:g> omejitev</item>
      <item quantity="two"><xliff:g id="COUNT">%1$d</xliff:g> omejitvi</item>
      <item quantity="few"><xliff:g id="COUNT">%1$d</xliff:g> omejitve</item>
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> omejitev</item>
    </plurals>
    <string name="operator_warning" msgid="1862988028996859195">"Operaterjeve meritve prenosa podatkov so morda drugačne kot v napravi"</string>
    <string name="data_used_template" msgid="3245919669966296505">"Porabljeno: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="6115364758236594593">"Nastavi opozorilo za prenos podatkov"</string>
    <string name="data_warning" msgid="209133958008062117">"Opozorilo za prenos podatkov"</string>
    <string name="data_warning_footnote" msgid="776341964125603711">"Preneseno količino podatkov za opozorilo in omejitev prenosa podatkov meri vaša naprava. Ti podatki se lahko razlikujejo od podatkov operaterja."</string>
    <string name="set_data_limit" msgid="2901526323210516923">"Nastavi omej. prenosa pod."</string>
    <string name="data_limit" msgid="1885406964934590552">"Omejitev prenosa podatkov"</string>
    <string name="data_usage_template" msgid="2923744765873163859">"<xliff:g id="ID_1">%1$s</xliff:g> uporabljeno v obdobju <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1029654422228677273">"Konfiguriranje"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Druge aplikacije, vključene v prikaz porabe"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <item quantity="one">Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen <xliff:g id="COUNT">%1$d</xliff:g> aplikaciji.</item>
      <item quantity="two">Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen <xliff:g id="COUNT">%1$d</xliff:g> aplikacijama.</item>
      <item quantity="few">Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen <xliff:g id="COUNT">%1$d</xliff:g> aplikacijam.</item>
      <item quantity="other">Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen <xliff:g id="COUNT">%1$d</xliff:g> aplikacijam.</item>
    </plurals>
    <string name="data_usage_title" msgid="3659356290392241789">"Glavni podatki"</string>
    <string name="data_usage_wifi_title" msgid="7063659423081820720">"Podatki prek omrežij Wi‑Fi"</string>
    <string name="data_used" msgid="5116389957228457203">"Porabljeno: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="2989129931961311051">"Porabljeno: <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="1134445012475270295">"Prekoračeno za <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="8998091725895502181">"Preostalo: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="456503215317213651">
      <item quantity="one">Še %d dan</item>
      <item quantity="two">Še %d dneva</item>
      <item quantity="few">Še %d dnevi</item>
      <item quantity="other">Še %d dni</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="5892754995098583472">"Ni preostalega časa"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="825838050296069404">"Še manj kot 1 dan"</string>
    <string name="carrier_and_update_text" msgid="7963409972475063897">"Posodobil <xliff:g id="ID_1">^1</xliff:g> pred <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="3277403390316201982">"Posodobljeno pred <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="4057997726060106722">"Pravkar posodobil <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="1766859656868932996">"Pravkar posodobljeno"</string>
    <string name="launch_mdp_app_text" msgid="6751296320061773169">"Prikaži paket"</string>
    <string name="launch_wifi_text" msgid="2311424914664372687">"Ogled podrobnosti"</string>
    <string name="data_saver_title" msgid="8034286939200289826">"Varčevanje s podatki"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Neomejen prenos podatkov"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Prenos podatkov v ozadju je izklopljen"</string>
    <string name="data_saver_on" msgid="6774217590237934709">"Vklopljeno"</string>
    <string name="data_saver_off" msgid="6892309031162738794">"Izklopljeno"</string>
    <string name="data_saver_switch_title" msgid="836312690356005669">"Uporaba varčevanja s podatki"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Neomejen podatkovni prenos"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Dovoli neomejen podatkovni dostop, ko je vklopljeno varčevanje s podatki"</string>
    <string name="home_app" msgid="4066188520886810030">"Aplikacija na začetnem zaslonu"</string>
    <string name="no_default_home" msgid="7184117487704520238">"Ni privzetega začetnega zaslona"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="3832020101401318248">"Varni zagon"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="7873036097628404476">"Če želite zagnati napravo, morate vnesti vzorec. Ko je naprava izklopljena, ne more prejemati klicev, sporočil, obvestil ali alarmov."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="6022831284097476933">"Če želite zagnati napravo, morate vnesti kodo PIN. Ko je naprava izklopljena, ne more prejemati klicev, sporočil, obvestil ali alarmov."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="6818285221244966231">"Če želite zagnati napravo, morate vnesti geslo. Ko je naprava izklopljena, ne more prejemati klicev, sporočil, obvestil ali alarmov."</string>
    <string name="suggestion_additional_fingerprints" msgid="2214281455363797037">"Dodajte nov prstni odtis"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Odklepanje z drugim prstom"</string>
    <string name="battery_saver_on_summary" msgid="7722791295871319534">"Vklopljeno"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="3953785517002197881">"Vklop pri <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="784360321235698247">"Izklopljeno"</string>
    <string name="battery_saver_button_turn_on" msgid="3699954061337848832">"Vklopi zdaj"</string>
    <string name="battery_saver_button_turn_off" msgid="5916996792004611890">"Izklopi zdaj"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"Ne uporablja optimizacije akumulatorja"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Če je naprava zaklenjena, prepreči vnašanje odgovorov ali drugega besedila v obvestilih"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Privzeti črkovalnik"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Izbira črkovalnika"</string>
    <string name="spell_checker_master_switch_title" msgid="8763132750954344372">"Uporaba črkovalnika"</string>
    <string name="spell_checker_not_selected" msgid="8871083796179200696">"Ni izbrano"</string>
    <string name="notification_log_no_title" msgid="5678029849672024215">"(brez)"</string>
    <string name="notification_log_details_delimiter" msgid="3116559361552416747">": "</string>
    <string name="notification_log_details_package" msgid="2596495677039100284">"pkg"</string>
    <string name="notification_log_details_key" msgid="2995791937075862968">"ključ"</string>
    <string name="notification_log_details_group" msgid="2430467015200368698">"skupina"</string>
    <string name="notification_log_details_group_summary" msgid="7945543958255585829">"(povzetek)"</string>
    <string name="notification_log_details_visibility" msgid="2552873780715930971">"vidnost"</string>
    <string name="notification_log_details_public_version" msgid="4247242364605495240">"različica za javnost"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"prednost"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"pomembnost"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"razlaga"</string>
    <string name="notification_log_details_badge" msgid="3258183328267662285">"lahko pokaže značko"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"namen"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"izbris namena"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"namen za celozaslonski način"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"dejanja"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"naziv"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"oddaljeni vhodi"</string>
    <string name="notification_log_details_content_view" msgid="6638731378278561786">"pogled po meri"</string>
    <string name="notification_log_details_extras" msgid="4188418723779942047">"dodatki"</string>
    <string name="notification_log_details_icon" msgid="8939114059726188218">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="243148037601903212">"velikost paketa"</string>
    <string name="notification_log_details_ashmem" msgid="7241814108477320636">"ashmem"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"zvok"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"vibriranje"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"privzeto"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"brez"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"Manjka predmet za uvrščanje."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"Predmet za uvrščanje ne vsebuje tega ključa."</string>
    <string name="display_cutout_emulation" msgid="7466869822418376317">"Zareza zaslona"</string>
    <string name="display_cutout_emulation_keywords" msgid="4495418317471622562">"izrez prikaza"</string>
    <string name="display_cutout_emulation_device_default" msgid="7957250558326167503">"Privzeta nastavitev naprave"</string>
    <string name="special_access" msgid="3458780842491881155">"Poseb. dostop za aplik."</string>
    <plurals name="special_access_summary" formatted="false" msgid="260765309935675867">
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> aplikaciji je dovoljen neomejen prenos podatkov</item>
      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> aplikacijama je dovoljen neomejen prenos podatkov</item>
      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> aplikacijam je dovoljen neomejen prenos podatkov</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> aplikacijam je dovoljen neomejen prenos podatkov</item>
    </plurals>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"Ali želite res izbrisati uporabniške podatke in preklopiti na šifriranje podatkov?"</string>
    <string name="button_confirm_convert_fbe" msgid="7101855374850373091">"Izbriši in preklopi"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Ponastavitev omejevanja hitrosti za ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Omejevanje hitrosti za ShortcutManager je ponastavljeno"</string>
    <string name="notification_suggestion_title" msgid="387052719462473500">"Upravljanje podatkov na zaklenjenem zaslonu"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Prikaz ali skrivanje vsebine obvestil"</string>
    <string name="page_tab_title_summary" msgid="4070309266374993258">"Vse"</string>
    <string name="page_tab_title_support" msgid="4407600495101788249">"Nasveti in podpora"</string>
    <string name="developer_smallest_width" msgid="7516950434587313360">"Najmanjša širina"</string>
    <string name="premium_sms_none" msgid="8268105565738040566">"Nobena nameščena aplikacija ni zahtevala dostopa za plačljiva sporočila SMS."</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"Plačljiva sporočila SMS vam lahko povzročijo stroške in povečajo račun za mobilno telefonijo. Če za aplikacijo omogočite dovoljenje, boste lahko s tisto aplikacijo pošiljali plačljiva sporočila SMS."</string>
    <string name="premium_sms_access" msgid="4660047004791638305">"Dostop za plačljiva sporočila SMS"</string>
    <string name="bluetooth_disabled" msgid="6244000672828617410">"Izklopljeno"</string>
    <string name="bluetooth_connected_summary" msgid="7672528674593152862">"Povezan z napravo <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="9173661896296663932">"Povezan z več napravami"</string>
    <string name="demo_mode" msgid="2798762752209330277">"Predstavitveni način uporabniškega vmesnika sistema"</string>
    <string name="dark_ui_mode" msgid="2112241426441807273">"Nočni način"</string>
    <string name="dark_ui_mode_title" msgid="975299966259850992">"Nastavitev nočnega načina"</string>
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Ploščice razvijalcev za hitre nastavitve"</string>
    <string name="winscope_trace_quick_settings_title" msgid="1294290008255732032">"Sledenje z apl. Winscope"</string>
    <string name="support_country_format" msgid="4502523713489559595">"<xliff:g id="COUNTRY">%1$s</xliff:g> – <xliff:g id="LANGUAGE">%2$s</xliff:g>"</string>
    <string name="managed_profile_settings_title" msgid="2729481936758125054">"Nastavitve delovnega profila"</string>
    <string name="managed_profile_contact_search_title" msgid="6034734926815544221">"Iskanje po stikih"</string>
    <string name="managed_profile_contact_search_summary" msgid="5431253552272970512">"Organizaciji dovoli iskanje po stikih zaradi prepoznavanja klicateljev in stikov"</string>
    <plurals name="hours" formatted="false" msgid="7020844602875333472">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> ura</item>
      <item quantity="two"><xliff:g id="NUMBER">%s</xliff:g> uri</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> ure</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> ur</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="4666832442068789413">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> minuta</item>
      <item quantity="two"><xliff:g id="NUMBER">%s</xliff:g> minuti</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> minute</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minut</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="3876307354560025025">
      <item quantity="one"><xliff:g id="NUMBER">%s</xliff:g> sekunda</item>
      <item quantity="two"><xliff:g id="NUMBER">%s</xliff:g> sekundi</item>
      <item quantity="few"><xliff:g id="NUMBER">%s</xliff:g> sekunde</item>
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> sekund</item>
    </plurals>
    <string name="automatic_storage_manager_settings" msgid="7819434542155181607">"Upravljanje shrambe"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"Upravitelj shrambe vam pomaga sprostiti prostor za shranjevanje, tako da iz naprave odstrani varnostno kopirane fotografije in videoposnetke."</string>
    <string name="automatic_storage_manager_days_title" msgid="2017913896160914647">"Odstranjevanje fotografij in videoposnetkov"</string>
    <string name="automatic_storage_manager_preference_title" msgid="5753702798151073383">"Upravitelj shrambe"</string>
    <string name="automatic_storage_manager_master_switch_title" msgid="6792996736190821417">"Uporaba upravitelja shrambe"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Samodejno"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Ročno"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Sprostitev prostora"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Poteze"</string>
    <string name="gesture_preference_summary" product="default" msgid="8627850388011956901">"Hitre poteze za upravljanje telefona"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4717535378272065510">"Hitre poteze za upravljanje tabličnega računalnika"</string>
    <string name="gesture_preference_summary" product="device" msgid="4205941452664950852">"Hitre poteze za upravljanje naprave"</string>
    <string name="double_tap_power_for_camera_title" msgid="64716226816032800">"Preklop na fotoaparat"</string>
    <string name="double_tap_power_for_camera_summary" msgid="242037150983277829">"Če želite hitro odpreti fotoaparat, dvakrat pritisnite gumb za vklop. Deluje na vsakem zaslonu."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="6500405261202883589">"Hitro odpiranje fotoaparata"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Obrat fotoaparata"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="4689410222517954869">"Hitrejši vklop načina za sebke"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="2513907834903543667">"Vlečenje navzgor po gumbu za začetni zaslon"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="5367798220225997418">"Če želite preklopiti med aplikacijami, povlecite navzgor po gumbu za začetni zaslon. Znova povlecite navzgor, da prikažete vse aplikacije. To deluje na katerem koli zaslonu. Gumb »Pregled« ne bo več prikazan v spodnjem desnem delu zaslona."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="1465200107913259595">"Preskus novega gumba za začetni zaslon"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="4825314186907812743">"Vklop nove poteze za preklop aplikacij"</string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Preverjanje telefona z dvojnim dotikom"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Dvakratni dotik za preverjanje tabličnega računalnika"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Dvakratni dotik za preverjanje naprave"</string>
    <string name="ambient_display_summary" msgid="525662960806416373">"Če želite preveriti uro, ikone obvestil in druge informacije, se dvakrat dotaknite zaslona."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="818688002837687268">"Preverjanje telefona z dvigom"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="4455864282995698097">"Primite tablični računalnik, da ga preverite"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="5380534405773531175">"Primite napravo, da jo preverite"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="4567020486787561873">"Če želite preveriti uro, ikone obvestil in druge informacije, dvignite telefon."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="5435283849947236648">"Če želite preveriti uro, ikone obvestil in druge informacije, primite tablični računalnik."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="8256669101643381568">"Če želite preveriti uro, ikone obvestil in druge informacije, primite napravo."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Poteg s prstom po tipalu prstnih odtisov za prikaz obvestil"</string>
    <string name="fingerprint_gesture_screen_title" msgid="8562169633234041196">"Poteg po prstnem tipalu"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="1770661868393713922">"Če želite preveriti obvestila, povlecite navzdol po tipalu prstnih odtisov na hrbtni strani telefona."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="902719947767712895">"Če želite preveriti obvestila, povlecite navzdol po tipalu prstnih odtisov na hrbtni strani tabličnega računalnika."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="5372926094116306647">"Če želite preveriti obvestila, povlecite navzdol po tipalu prstnih odtisov na hrbtni strani naprave."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="1677291167470357802">"Hiter ogled obvestil"</string>
    <string name="gesture_setting_on" msgid="3455094265233870280">"Vklopljeno"</string>
    <string name="gesture_setting_off" msgid="5230169535435881894">"Izklopljeno"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4265541229765635629">"Nalagalnik zagona je že odklenjen"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="3361344735430813695">"Najprej vzpostavite povezavo z internetom"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="2479038689567925511">"Povežite se z internetom ali se obrnite na operaterja"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"Ni na voljo v napravah, zaklenjenih na operaterja"</string>
    <string name="oem_lock_info_message" msgid="9218313722236417510">"Znova zaženite napravo, da omogočite funkcijo zaščite naprave."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"Skupaj sproščeno: <xliff:g id="SIZE">%1$s</xliff:g>\n\nNazadnje zagnano: <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="4051513950976670853">"Nenamestljive aplikacije"</string>
    <string name="web_action_enable_summary" msgid="3108127559723396382">"Odpri povezave v aplikacijah, tudi če niso nameščene"</string>
    <string name="web_action_section_title" msgid="7364647086538399136">"Nenamestljive aplikacije"</string>
    <string name="instant_apps_settings" msgid="8827777916518348213">"Nastavitve nenamestljivih aplikacij"</string>
    <string name="domain_url_section_title" msgid="7046835219056428883">"Nameščene aplikacije"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="6353100011690933254">"Shrambo zdaj upravlja upravitelj shrambe"</string>
    <string name="account_for_section_header" msgid="5356566418548737121">"Računi uporabnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="7391183586410814450">"Konfiguriranje"</string>
    <string name="auto_sync_account_title" msgid="898796354710116383">"Samodejno sinhroniziranje podatkov"</string>
    <string name="auto_sync_personal_account_title" msgid="8496263182646100610">"Samodejno sinhroniziranje osebnih podatkov"</string>
    <string name="auto_sync_work_account_title" msgid="4489172450037434152">"Samodejno sinhroniziranje delovnih podatkov"</string>
    <string name="auto_sync_account_summary" msgid="692499211629185107">"Omogoči, da aplikacije samodejno osvežijo podatke"</string>
    <string name="account_sync_title" msgid="7214747784136106491">"Sinhronizacija računa"</string>
    <string name="account_sync_summary_some_on" msgid="3375930757891381175">"Sinhronizacija je vklopljena za <xliff:g id="ID_1">%1$d</xliff:g> od <xliff:g id="ID_2">%2$d</xliff:g> elementov"</string>
    <string name="account_sync_summary_all_on" msgid="570431636622254156">"Sinhronizacija je vklopljena za vse elemente"</string>
    <string name="account_sync_summary_all_off" msgid="8782409931761182734">"Sinhronizacija je izklopljena za vse elemente"</string>
    <string name="enterprise_privacy_settings" msgid="1177106810374146496">"Podatki o upravljani napravi"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5853292305730761128">"Spremembe in nastavitve, ki jih upravlja vaša organizacija"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="4266234968317996188">"Spremembe in nastavitve, ki jih upravlja <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="7402406406883832509">"Vaša organizacija lahko spremeni nastavitve in v napravo namesti programsko opremo, da bi zagotovila dostop do delovnih podatkov. \n\nZa več informacij se obrnite na skrbnika organizacije."</string>
    <string name="enterprise_privacy_exposure_category" msgid="7313392680107938517">"Vrste podatkov, ki jih vidi vaša organizacija"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="9079283547182933771">"Spremembe, ki jih je izvedel skrbnik vaše organizacije"</string>
    <string name="enterprise_privacy_device_access_category" msgid="5423434164248819058">"Vaš dostop do vsebin te naprave"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="2773968662865848413">"Podatke, povezane z delovnim računom, npr. e-pošto in koledar"</string>
    <string name="enterprise_privacy_installed_packages" msgid="2313698828178764590">"Seznam aplikacij v napravi"</string>
    <string name="enterprise_privacy_usage_stats" msgid="4398411405572759370">"Trajanje uporabe in količina prenesenih podatkov za vsako od aplikacij"</string>
    <string name="enterprise_privacy_network_logs" msgid="161722817268849590">"Najnovejši dnevnik omrežnega prometa"</string>
    <string name="enterprise_privacy_bug_reports" msgid="843225086779037863">"Najnovejše poročilo o napakah"</string>
    <string name="enterprise_privacy_security_logs" msgid="5377362481617301074">"Najnovejši varnostni dnevnik"</string>
    <string name="enterprise_privacy_none" msgid="7706621148858381189">"Brez"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="6353757812144878828">"Nameščene aplikacije"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7433213592572082606">"To je ocena števila aplikacij. Morda ne vključuje aplikacij, nameščenih zunaj Trgovine Play."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="3005116533873542976">
      <item quantity="one">Najmanj <xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
      <item quantity="two">Najmanj <xliff:g id="COUNT_1">%d</xliff:g> aplikaciji</item>
      <item quantity="few">Najmanj <xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other">Najmanj <xliff:g id="COUNT_1">%d</xliff:g> aplikacij</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="4158197200885270634">"Dovoljenja za lokacijo"</string>
    <string name="enterprise_privacy_microphone_access" msgid="5717375623568864441">"Dovoljenja za mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="4858146118537519375">"Dovoljenja za fotoaparat"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="3288495615791128724">"Privzete aplikacije"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="2765037387436064893">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> aplikacija</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g> aplikaciji</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> aplikacije</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> aplikacij</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="6531350246850814920">"Privzeta tipkovnica"</string>
    <string name="enterprise_privacy_input_method_name" msgid="4941106433683067953">"Nastavljeno na <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="4409098287763221215">"Stalno vklopljen VPN je vklopljen"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="9217774730260037434">"Stalno vklopljen VPN je vklopljen v vašem osebnem profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="7244472958208315814">"Stalno vklopljen VPN je vklopljen v vašem delovnem profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="7936664553416257333">"Globalni strežnik proxy za HTTP je nastavljen"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="2019652712782510262">"Zaupanja vredne poverilnice"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="2279084820904076599">"Zaupanja vredne poverilnice v vašem osebnem profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="6187377647815301809">"Zaupanja vredne poverilnice v vašem delovnem profilu"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="526375234629534165">
      <item quantity="one">Najmanj <xliff:g id="COUNT_1">%d</xliff:g> potrdilo overitelja potrdil</item>
      <item quantity="two">Najmanj <xliff:g id="COUNT_1">%d</xliff:g> potrdili overitelja potrdil</item>
      <item quantity="few">Najmanj <xliff:g id="COUNT_1">%d</xliff:g> potrdila overitelja potrdil</item>
      <item quantity="other">Najmanj <xliff:g id="COUNT_1">%d</xliff:g> potrdil overitelja potrdil</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="8791656477097208540">"Skrbnik lahko zaklene napravo in ponastavi geslo"</string>
    <string name="enterprise_privacy_wipe_device" msgid="2821960015797241790">"Skrbnik lahko izbriše vse podatke v napravi"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="1001255609345002878">"Število neuspešnih poskusov vpisa gesla, preden se izbrišejo vsi podatki v napravi"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="4040565826652951057">"Število neuspešnih poskusov vpisa gesla, preden se izbrišejo podatki delovnega profila"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="5279099270351036696">
      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> poskus</item>
      <item quantity="two"><xliff:g id="COUNT_1">%d</xliff:g> poskusa</item>
      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> poskusi</item>
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> poskusov</item>
    </plurals>
    <string name="enterprise_privacy_backups_enabled" msgid="8186700798406539053">"Podatki te naprave se varnostno kopirajo"</string>
    <string name="do_disclosure_generic" msgid="8653670456990823307">"To napravo upravlja vaša organizacija."</string>
    <string name="do_disclosure_with_name" msgid="1141081465968481380">"To napravo upravlja <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="3558079393757238670">" "</string>
    <string name="learn_more" msgid="2623878455042103404">"Več o tem"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="1134677050353971363">
      <item quantity="one">Fotografske aplikacije</item>
      <item quantity="two">Fotografske aplikacije</item>
      <item quantity="few">Fotografske aplikacije</item>
      <item quantity="other">Fotografske aplikacije</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="3545972964391065220">"Aplikacija za koledar"</string>
    <string name="default_contacts_app_title" msgid="3497370557378660098">"Aplikacija za stike"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="42826975161049245">
      <item quantity="one">E-poštni odjemalci</item>
      <item quantity="two">E-poštni odjemalci</item>
      <item quantity="few">E-poštni odjemalci</item>
      <item quantity="other">E-poštni odjemalci</item>
    </plurals>
    <string name="default_map_app_title" msgid="7560143381633608567">"Aplikacija za zemljevide"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="6714041230953195024">
      <item quantity="one">Aplikacije za klicanje</item>
      <item quantity="two">Aplikacije za klicanje</item>
      <item quantity="few">Aplikacije za klicanje</item>
      <item quantity="other">Aplikacije za klicanje</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="4309216198909946380">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="8949045544491604376">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_photos_videos" msgid="319854636702241898">"Fotografije in videoposnetki"</string>
    <string name="storage_music_audio" msgid="789779084825206838">"Glasba in zvok"</string>
    <string name="storage_games" msgid="7703159201697117621">"Igre"</string>
    <string name="storage_other_apps" msgid="5524321740031718083">"Druge aplikacije"</string>
    <string name="storage_files" msgid="8581083146777364063">"Datoteke"</string>
    <string name="storage_size_large_alternate" msgid="3395208658399637645">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></small>""</string>
    <string name="storage_volume_total" msgid="3499221850532701342">"uporabljeno od <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="6095012055875077036">"uporab."</string>
    <string name="clear_instant_app_data" msgid="2004222610585890909">"Počisti aplikacijo"</string>
    <string name="clear_instant_app_confirmation" msgid="7451671214898856857">"Ali želite odstraniti to nenamestljivo aplikacijo?"</string>
    <string name="launch_instant_app" msgid="391581144859010499">"Odpri"</string>
    <string name="game_storage_settings" msgid="3410689937046696557">"Igre"</string>
    <string name="audio_files_title" msgid="4777048870657911307">"Zvočne datoteke"</string>
    <string name="app_info_storage_title" msgid="5554719444625611987">"Uporabljen prostor"</string>
    <string name="webview_uninstalled_for_user" msgid="1819903169194420983">"(odstranjeno za uporabnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="1216426047631256825">"(onemogočeno za uporabnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7338387238377914374">"Storitev samodejnega izpolnjevanja"</string>
    <string name="autofill_keywords" msgid="7485591824120812710">"samodejno, izpolnjevanje, samoizpolnjevanje"</string>
    <string name="autofill_confirmation_message" msgid="2784869528908005194">"&lt;b&gt;Prepričajte se, ali zaupate tej aplikaciji&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Samodejno izpolnjevanje&gt;%1$s&lt;/xliff:g&gt; iz elementov na zaslonu ugotovi, kaj je mogoče samodejno izpolniti."</string>
    <string name="color_theme" msgid="1535685696756738324">"Barvna tema"</string>
    <string name="default_theme" msgid="7085644992078579076">"Privzeto"</string>
    <string name="device_theme" msgid="4571803018917608588">"Tema naprave"</string>
    <string name="systemui_theme_wallpaper" msgid="5658521610680281172">"Samodejna (na podlagi ozadja)"</string>
    <string name="systemui_theme_light" msgid="7519689709659152866">"Svetla"</string>
    <string name="systemui_theme_dark" msgid="8708733503912628456">"Temna"</string>
    <string name="show_operator_name_title" msgid="805135053530442951">"Ime omrežja"</string>
    <string name="show_operator_name_summary" msgid="5962567590205757550">"Prikaži ime omrežja v vrstici stanja"</string>
    <string name="storage_manager_indicator" msgid="1516810749625915020">"Upravitelj shrambe: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="7488057587180724388">"Izklopljeno"</string>
    <string name="storage_manager_indicator_on" msgid="8625551710194584733">"Vklopljeno"</string>
    <string name="install_type_instant" msgid="3174425974536078647">"Nenamestljiva aplikacija"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="5605210730828410482">"Želite izklopiti upravitelja shrambe?"</string>
    <string name="storage_movies_tv" msgid="5498394447562086890">"Aplikacije za filme in TV"</string>
    <string name="carrier_provisioning" msgid="4398683675591893169">"Podatki o omogočanju uporabe operaterja"</string>
    <string name="trigger_carrier_provisioning" msgid="3434865918009286187">"Sproži omogočanje uporabe operaterja"</string>
    <string name="zen_suggestion_title" msgid="798067603460192693">"Posodobitev načina »ne moti«"</string>
    <string name="zen_suggestion_summary" msgid="5928686804697233014">"Začasno zaustavite prikazovanje obvestil, da ostanete osredotočeni"</string>
    <string name="new_device_suggestion_title" msgid="698847081680980774">"Odkrijte zanimive novosti"</string>
    <string name="new_device_suggestion_summary" product="default" msgid="206396571522515855">"Oglejte si predstavitev novega telefona"</string>
    <string name="new_device_suggestion_summary" product="tablet" msgid="393751455688210956">"Oglejte si predstavitev novega tabličnega računalnika"</string>
    <string name="new_device_suggestion_summary" product="device" msgid="2939870049868336652">"Oglejte si predstavitev nove naprave"</string>
    <string name="disabled_low_ram_device" msgid="3751578499721173344">"Ta funkcija ni na voljo v tej napravi."</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1294470289520660584">"Vsili popolne meritve GNSS"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="496344699046454200">"Spremljaj vse razmestitve in frekvence GNSS brez ciklov"</string>
    <string name="show_first_crash_dialog" msgid="8889957119867262599">"Vedno pokaži pogovorno okno zrušitve"</string>
    <string name="show_first_crash_dialog_summary" msgid="703224456285060428">"Pokaži pogovorno okno ob vsaki zrušitvi aplikacije"</string>
    <string name="directory_access" msgid="4722237210725864244">"Dostop do imenika"</string>
    <string name="keywords_directory_access" msgid="360557532842445280">"dostop do imenika"</string>
    <string name="directory_on_volume" msgid="1246959267814974387">"<xliff:g id="VOLUME">%1$s</xliff:g> (<xliff:g id="DIRECTORY">%2$s</xliff:g>)"</string>
    <string name="unsupported_setting_summary" product="default" msgid="11246953620654225">"Telefon ne podpira nastavitve"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="6328431665635673717">"Tablični računalnik ne podpira nastavitve"</string>
    <string name="unsupported_setting_summary" product="device" msgid="2348970994972110886">"Naprava ne podpira nastavitve"</string>
    <string name="disabled_for_user_setting_summary" msgid="3388525317680711262">"Trenutni uporabnik ne sme spremeniti nastavitve"</string>
    <string name="disabled_dependent_setting_summary" msgid="8291322239940946902">"Ta nastavitev je odvisna od druge nastavitve"</string>
    <string name="unknown_unavailability_setting_summary" msgid="4589584678033059435">"Nastavitev ni na voljo"</string>
    <string name="my_device_info_account_preference_title" msgid="342933638925781861">"Račun"</string>
    <string name="my_device_info_device_name_preference_title" msgid="7104085224684165324">"Ime naprave"</string>
    <string name="bluetooth_on_while_driving_pref" msgid="2460847604498343330">"Uporaba Bluetootha med vožnjo"</string>
    <string name="bluetooth_on_while_driving_summary" msgid="3196190732516898541">"Samodejni vklop vmesnika Bluetooth med vožnjo"</string>
    <string name="change_wifi_state_title" msgid="3261945855372885427">"Upravljanje povezave Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="7942268646980694224">"Tej aplikaciji omogočite, da upravlja povezavo Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8434262633905502679">"Tej aplikacij omogočite, da vklopi ali izklopi povezavo Wi-Fi, išče omrežja Wi-Fi in se z njimi poveže, doda ali odstrani omrežja ali pa zažene lokalno dostopno točko"</string>
    <string name="media_output_title" msgid="115223550977351699">"Predvajaj predstavnost v"</string>
    <string name="media_output_default_summary" msgid="8115153381240348279">"ta naprava"</string>
    <string name="media_output_summary" product="default" msgid="6839458453831567167">"Telefon"</string>
    <string name="media_output_summary" product="tablet" msgid="7217221078578554515">"Tablični računalnik"</string>
    <string name="media_output_summary" product="device" msgid="5677420090811068649">"Naprava"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="3533731701018680693">"Ni na voljo med klici"</string>
    <string name="media_output_summary_unavailable" msgid="7970304720507697019">"Ni na voljo"</string>
    <string name="take_call_on_title" msgid="6066362463436122655">"Sprejemanje klicev je vklopljeno"</string>
    <string name="cannot_change_apn_toast" msgid="4652498125702594916">"Tega APN-ja ni mogoče spremeniti."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="752439050748267917">"Izboljšajte čas delovanja akumulatorja tablice"</string>
    <string name="battery_suggestion_title" product="device" msgid="1507272328369733005">"Izboljšajte čas delovanja akumulatorja naprave"</string>
    <string name="battery_suggestion_title" product="default" msgid="4038053023336285165">"Izboljšajte čas delovanja akumulatorja telefona"</string>
    <string name="battery_suggestion_summary" msgid="4585677159811722359"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="7840226017975251549">"Preprečevanje zvonjenja"</string>
    <string name="gesture_prevent_ringing_title" msgid="2483159069038138740">"Sočasni pritisk gumbov za vklop in povečanje glasnosti"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="5724512060316688779">"Bližnjica za preprečevanje zvonjenja"</string>
    <string name="prevent_ringing_option_vibrate" msgid="7286821846542822661">"Vibriranje"</string>
    <string name="prevent_ringing_option_mute" msgid="7551545579059879853">"Izklop zvoka"</string>
    <string name="prevent_ringing_option_none" msgid="4656046650769569175">"Ne naredi ničesar"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="1157524435626890116">"Vklopljeno (vibriranje)"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="4472465110708640980">"Vklopljeno (utišano)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="5013718946609276137">"Izklopljeno"</string>
    <string name="pref_title_network_details" msgid="7186418845727358964">"O omrežju"</string>
    <string name="about_phone_device_name_warning" msgid="8885670415541365348">"Ime naprave je vidno aplikacijam v telefonu. Ko vzpostavite povezavo z napravami Bluetooth ali nastavite dostopno točko Wi-Fi, ga bodo morda videle tudi druge osebe."</string>
    <string name="devices_title" msgid="7701726109334110391">"Naprave"</string>
    <string name="wfc_disclaimer_title_text" msgid="6164569741719679613">"Pomembne informacije"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="1405773141236165542">"NADALJUJ"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="2700358281438736674">"NE, HVALA"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="6658735446562619865">"Lokacija"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="3096546236221656018">"Ponudnik storitev lahko za zagotavljanje te storitve zbira podatke o vaši lokaciji.\n\nPreglejte pravilnik o zasebnosti za tega ponudnika storitev."</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="3354031536141983602">"Klici v sili"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="6068582272230311464">"Vaš operater ne podpira klicev v sili, opravljenih s funkcijo Klicanje prek Wi-Fi-ja.\nNaprava samodejno preklopi na mobilno omrežje, da opravi klic v sili.\nKlici v sili so mogoči samo na območjih, ki so pokrita z mobilnim signalom."</string>
</resources>
