<?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">"Vzorec besedila"</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="6026705382020027966">"Želite prekiniti povezavo?"</string>
    <string name="bluetooth_disconnect_all_profiles" msgid="9148530542956217908">"S tem bo prekinjena povezava z napravo:&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"Nimate dovoljenja za spreminjanje nastavitev za Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="4601203665214962983">"Seznanjanje 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" msgid="7829164289195116782">"Naslov MAC za Bluetooth: <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="5164787486105868895">"Pokaži 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="4418784300859596202">"Drugim napravam vidno kot <xliff:g id="DEVICE_NAME">^1</xliff:g>"</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Vaše naprave"</string>
    <string name="bluetooth_pairing_page_title" msgid="5218444163161190061">"Seznanjanje naprave Bluetooth"</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_signal_location_label" msgid="3242990404410530456">"Podatki o lokaciji celice (zastarelo):"</string>
    <string name="radio_info_neighboring_location_label" msgid="5766020323342985397">"Podatki o sosednji celici (zastarelo):"</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_dcrtinfo_label" msgid="4062076024399431876">"Sprotni podatki za podatkovno povezavo:"</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="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="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_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">"Čas"</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="zone_list_menu_sort_alphabetically" msgid="5683377702671088588">"Razvrsti po abecedi"</string>
    <string name="zone_list_menu_sort_by_timezone" msgid="2720190443744884114">"Razvrsti po časovnem pasu"</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="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="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="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Naprava je š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="4193477159493347679">"Odobrite nakupe ali se prijavite v aplikacije samo z dotikom tipala prstnih odtisov. Pazite, čigave prstne odtise boste dodali, saj ta dejanja lahko izvaja že en sam dodan prstni odtis.\n\nOpomba: prstnega odtisa ne morete uporabiti za odklepanje naprave. Za več informacij se obrnite na skrbnika v organizaciji."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="3635924459027832861">"Dotaknite se tipala prstnih odtisov, če želite odkleniti telefon, odobriti nakupe ali se prijaviti v aplikacije. Ta dejanja bo mogoče izvesti že z enim dodanim prstnim odtisom, zato pazite, čigave prstne odtise boste dodali.\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="8386444182056861429">"Dodaj prstni odtis"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="7234486440384881699">"Zaščitne funkcije naprave ne bodo aktivirane. V primeru izgube ali kraje tabličnega računalnika oziroma izbrisa vseh podatkov v njem ne boste mogli preprečiti drugim, da ga uporabljajo."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="3519190003101280912">"Zaščitne funkcije naprave ne bodo aktivirane. V primeru izgube ali kraje naprave oziroma izbrisa vseh podatkov v njej ne boste mogli preprečiti drugim, da jo uporabljajo."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="417315011140961">"Zaščitne funkcije naprave ne bodo aktivirane. V primeru izgube ali kraje telefona oziroma izbrisa vseh podatkov v njem ne boste mogli preprečiti drugim, da ga uporabljajo."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="8783499872534165700">"Funkcije za zaščito naprave ne bodo aktivirane. V primeru izgube ali kraje tabličnega računalnika drugim ne boste mogli preprečiti njegove uporabe."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="3120512940873907578">"Funkcije za zaščito naprave ne bodo aktivirane. V primeru izgube ali kraje naprave drugim ne boste mogli preprečiti njene uporabe."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="3589945558504439395">"Funkcije za zaščito naprave ne bodo aktivirane. V primeru izgube ali kraje telefona drugim 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="5877265753699187149">"Iskanje tipala"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="1959655161889313661">"Poiščite tipalo prstnih odtisov na hrbtni strani telefona."</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="951888937749663602">"Začnimo"</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="8556556992897619044">"Kar tako naprej"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="4232813847507193627">"Rahlo premaknite prst, da dodate vse različne dele prstnega odtisa"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="4798692662828257300">"Prstni odtis dodan."</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="835496875787664316">"Ko vidite to ikono, lahko za preverjanje istovetnosti ali odobritev nakupa uporabite prstni odtis."</string>
    <string name="setup_fingerprint_enroll_finish_message" msgid="7234264291957984004">"Dotaknite se tipala za prstne odtise, da preklopite napravo iz stanja pripravljenosti in jo odklenete."</string>
    <string name="setup_fingerprint_enroll_finish_message_secondary" msgid="7104778933406207968">"Ko je prikazana ta ikona, lahko prav tako odobrite nakupe ali se prijavite v aplikacije."</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="5053971232594165142">"Uporabite tipalo prstnih odtisov na napravi."</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_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="8971630898700461034">"Nastavitev zaklepanja zaslona"</string>
    <string name="suggested_lock_settings_summary" msgid="8778462376012231110">"Zaščitite napravo"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3655973509619012084">"Uporaba prstnega odtisa"</string>
    <string name="suggested_fingerprint_lock_settings_summary" msgid="2149569133725273864">"Odklepanje s prstnim odtisom"</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="setup_lock_settings_picker_fingerprint_message" msgid="5585650064305600578">"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>
    <!-- no translation found for setup_lock_settings_options_dialog_title (5058207955455973917) -->
    <skip />
    <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="8212242533942400457">"Funkcije za zaščito naprave ne bodo delovale brez vzorca.<xliff:g id="EMPTY_LINE">

</xliff:g>Shranjeni prstni odtisi bodo prav tako odstranjeni iz te naprave in z njimi ne boste mogli odkleniti telefona, omogočiti 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="875669051899437197">"Funkcije za zaščito naprave ne bodo delovale brez kode PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Shranjeni prstni odtisi bodo prav tako odstranjeni iz te naprave in z njimi ne boste mogli odkleniti telefona, omogočiti 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="2228159168587170445">"Funkcije za zaščito naprave ne bodo delovale brez gesla.<xliff:g id="EMPTY_LINE">

</xliff:g>Shranjeni prstni odtisi bodo prav tako odstranjeni iz te naprave in z njimi ne boste mogli odkleniti telefona, omogočiti 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="6363091330281670692">"Funkcije za zaščito naprave ne bodo delovale brez zaklepanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>Shranjeni prstni odtisi bodo prav tako odstranjeni iz te naprave in z njimi ne boste mogli odkleniti telefona, omogočiti 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="3675154828957224316">"Funkcije za zaščito profila ne bodo delovale brez vzorca.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz profila bodo izbrisani tudi shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti profila, dovoliti 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="4879321153584598940">"Funkcije za zaščito profila ne bodo delovale brez kode PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz profila bodo izbrisani tudi shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti profila, dovoliti 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="3527188316958917839">"Funkcije za zaščito profila ne bodo delovale brez gesla.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz profila bodo izbrisani tudi shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti profila, dovoliti 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="1962204059377724158">"Funkcije za zaščito profila ne bodo delovale brez zaklepanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>Iz profila bodo izbrisani tudi shranjeni prstni odtisi, tako da z njimi ne boste mogli odkleniti profila, dovoliti 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>
    <!-- no translation found for lock_failed_attempts_before_wipe (2219711062197089783) -->
    <skip />
    <!-- no translation found for lock_last_attempt_before_wipe_warning_title (4277765862798876826) -->
    <skip />
    <!-- no translation found for lock_last_pattern_attempt_before_wipe_device (4999108263936246210) -->
    <skip />
    <!-- no translation found for lock_last_pin_attempt_before_wipe_device (2191214314973933300) -->
    <skip />
    <!-- no translation found for lock_last_password_attempt_before_wipe_device (6526655065466746563) -->
    <skip />
    <!-- no translation found for lock_last_pattern_attempt_before_wipe_user (7851504071368235547) -->
    <skip />
    <!-- no translation found for lock_last_pin_attempt_before_wipe_user (4049024921333961715) -->
    <skip />
    <!-- no translation found for lock_last_password_attempt_before_wipe_user (4660886542496781672) -->
    <skip />
    <!-- no translation found for lock_last_pattern_attempt_before_wipe_profile (2437716252059050291) -->
    <skip />
    <!-- no translation found for lock_last_pin_attempt_before_wipe_profile (5799931839127476913) -->
    <skip />
    <!-- no translation found for lock_last_password_attempt_before_wipe_profile (6786586046975042158) -->
    <skip />
    <!-- no translation found for lock_failed_attempts_now_wiping_device (1951676829299522277) -->
    <skip />
    <!-- no translation found for lock_failed_attempts_now_wiping_user (6188180643494518001) -->
    <skip />
    <!-- no translation found for lock_failed_attempts_now_wiping_profile (1745475043685915442) -->
    <skip />
    <!-- no translation found for lock_failed_attempts_now_wiping_dialog_dismiss (8246716090548717312) -->
    <skip />
    <string name="lockpassword_password_too_short" msgid="2726090378672764986">"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_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_pin_no_sequential_digits" msgid="680765285206990584">"Naraščajoč, padajoč ali ponavljajoč se niz števk je prepovedan."</string>
    <string name="lockpassword_ok_label" msgid="313822574062553672">"V redu"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Preklič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="2277931851483023208">"Dovolite napravi <xliff:g id="DEVICE_NAME">%1$s</xliff:g>, da dostopa do vaših 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_devices" msgid="1647983835063249680">"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="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_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="1262792320446274407">"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="5700332050175684571">"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="4602294638909590612">"Povezava z napravo za internetni dostop"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1561383706411975199">"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="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="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_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_scanning_disabled" msgid="7247227922074840445">"Ni na voljo, ker je iskanje omrežij Wi‑Fi izklopljeno"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Izogni se slabim povezavam"</string>
    <string name="wifi_poor_network_detection_summary" msgid="2784135142239546291">"Omrežje Wi-Fi uporabi samo, če je na voljo dobra internetna povezava"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4674423884870027498">"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="wifi_install_credentials" msgid="3551143317298272860">"Namestitev potrdil"</string>
    <string name="wifi_scan_notify_text" msgid="5593805423071186757">"Zaradi večje natančnosti ugotavljanja lokacije lahko sistemske aplikacije in storitve še vedno iščejo omrežja Wi-Fi. 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="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="1707247692180853058">"Preklopi na prenos podatkov v mobilnih omrežjih, če povezava Wi‑Fi nima več internetnega dostopa."</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="6375399280719867214">"Uporaba prenosa podatkov v mobilnih omrežjih, če 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_wps_pbc" msgid="2668564692207863017">"Gumb za WPS"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Več možnosti"</string>
    <string name="wifi_menu_wps_pin" msgid="6426448256268695933">"Vnos kode PIN za WPS"</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_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_wps_setup_title" msgid="8207552222481570175">"Wi‑Fi Protected Setup"</string>
    <string name="wifi_wps_setup_msg" msgid="315174329121275092">"Zagon nastavitve WPS ..."</string>
    <string name="wifi_wps_onstart_pbc" msgid="817003360936932340">"Pritisnite gumb »Wi‑Fi Protected Setup« na usmerjevalniku. Morda se imenuje »WPS« ali je označen s tem simbolom:"</string>
    <string name="wifi_wps_onstart_pin" msgid="223344506445335358">"Vnesite PIN <xliff:g id="NUMBER">%1$s</xliff:g> za usmerjevalnik Wi‑Fi. Namestitev lahko traja do dve minuti."</string>
    <string name="wifi_wps_complete" msgid="2388138550456729134">"Nastavitev WPS je uspela. Povezovanje z omrežjem ..."</string>
    <string name="wifi_wps_connected" msgid="7153432445748931183">"Vzpostavljena povezava z omrežjem Wi‑Fi <xliff:g id="NETWORK_NAME">%s</xliff:g>"</string>
    <string name="wifi_wps_in_progress" msgid="3372311348221357944">"Nastavitev WPS že poteka in lahko traja največ dve minuti"</string>
    <string name="wifi_wps_failed_generic" msgid="5668775022238832527">"Nastavitev WPS ni uspela. Poskusite znova čez nekaj minut."</string>
    <string name="wifi_wps_failed_wep" msgid="2702820087105284461">"Varnostna nastavitev brezžičnega usmerjevalnika (WEP) ni podprta"</string>
    <string name="wifi_wps_failed_tkip" msgid="4282401586860713349">"Varnostna nastavitev brezžičnega usmerjevalnika (TKIP) ni podprta"</string>
    <string name="wifi_wps_failed_auth" msgid="1174614355181181958">"Preverjanje pristnosti ni uspelo. Poskusite znova."</string>
    <string name="wifi_wps_failed_overlap" msgid="5159533685596844778">"Zaznana je druga seja WPS. Poskusite znova čez nekaj minut."</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_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_2G" msgid="8724267386885036210">"2,4-GHz pas"</string>
    <string name="wifi_ap_choose_5G" msgid="8137061170937978040">"5-GHz pas"</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_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_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="7133561752896706392">"To omrežje nima dostopa do interneta. Ali želite ostati povezani?"</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="6228530645663584505">"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_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_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_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_tether_checkbox_text" msgid="1847167643625779136">"Prenosna dostopna točka Wi-Fi"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Dostopna točka Wi-Fi"</string>
    <string name="wifi_hotspot_checkbox_text_summary" msgid="5347703013899354452">"Uporaba mobilne povezave za omrežje Wi‑Fi"</string>
    <string name="wifi_hotspot_off_subtext" product="tablet" msgid="2745508221200463254">"Brez skupne rabe internetne povezave tega tabličnega računalnika prek dostopne točke"</string>
    <string name="wifi_hotspot_off_subtext" product="default" msgid="7746761268472599794">"Brez skupne rabe internetne povezave tega telefona prek dostopne točke"</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_subtext" msgid="2050196439900426456">"Dostopna točka <xliff:g id="NETWORK_SSID">%1$s</xliff:g> <xliff:g id="NETWORK_SECURITY">%2$s</xliff:g>"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"AndroidHotspot"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Klicanje prek Wi-Fi-ja"</string>
    <string name="wifi_calling_suggestion_title" msgid="9008010480466359578">"Vklop klicanja prek Wi-Fi-ja"</string>
    <string name="wifi_calling_suggestion_summary" msgid="3765923249566552233">"Uporaba Wi-Fi-ja namesto mobilnega omrežja"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Nastavitev klicanja"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="8149690312199253909">"Način klicanja prek Wi-Fi-ja"</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="2124257075906188844">"Prednostno – Wi-Fi"</item>
    <item msgid="1335127656328817518">"Prednostno mobilno"</item>
    <item msgid="3132912693346866895">"Samo Wi-Fi"</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="5782108782860004851">"Prednostno – Wi-Fi"</item>
    <item msgid="5074515506087318555">"Prednostno mobilno"</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_off_explanation" msgid="2597566001655908391">"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."</string>
    <string name="wifi_calling_off_explanation_2" msgid="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="3571902448699714454">"Posodobitev naslova za nujne primere"</string>
    <string name="emergency_address_summary" msgid="306028701568728126">"Naslov, ki ga službe za ukrepanje v sili uporabljajo kot vaš naslov, če prek Wi-Fi-ja pokličete na številko 911"</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="search_settings_summary" msgid="9205656546570654169">"Upravljaj nastavitve iskanja in zgodovine"</string>
    <string name="search_settings_no_results" msgid="8799027492641230999">"Ni rezultatov"</string>
    <string name="display_settings" msgid="7965901687241669598">"Zaslon"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Samodejno zasukaj zaslon"</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="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_category_schedule" msgid="2044072617637348966">"Razpored"</string>
    <string name="night_display_category_status" msgid="1952928783124400330">"Stanje"</string>
    <string name="night_display_auto_mode_title" msgid="8046314360381608455">"Samodejni vklop"</string>
    <string name="night_display_auto_mode_never" msgid="6723636142053240947">"Nikoli"</string>
    <string name="night_display_auto_mode_custom" msgid="6012300346981608242">"Razpored po meri"</string>
    <string name="night_display_auto_mode_twilight" msgid="2123345097508167094">"Od sončnega 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_temperature_title" msgid="1435292789272017136">"Intenzivnost"</string>
    <string name="night_display_summary_off" msgid="7009821232380000786">"Izklopljeno. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="2305501561697289620">"Brez samodejnega vklopa."</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="1548073080728058384">"Samodejni vklop ob <xliff:g id="ID_1">%1$s</xliff:g>."</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="2737328390752018845">"Samodejni vklop ob sončnem zahodu."</string>
    <string name="night_display_summary_on" msgid="6626224414971753417">"Vklopljeno. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="5217396859715040056">"Brez samodejnega izklopa."</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="887702685252504739">"Samodejni izklop ob <xliff:g id="ID_1">%1$s</xliff:g>."</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8574989770628425398">"Samodejni izklop ob sončnem vzhodu."</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 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">"Spreminjanje ozadja"</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 napajanjem"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"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 zagnati"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Trenutni ohranjevalnik zaslona"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Začnite 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="doze_title" msgid="2259176504273878294">"Prikaz na podlagi okolja"</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="1254238982577776475">"Pokaži čas, ikone obvestil in druge informacije"</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 kartice 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_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="security_patch" msgid="8438384045870296634">"Raven popravkov za varnost v Androidu"</string>
    <string name="model_info" msgid="1952009518045740889">"Model"</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="selinux_status" msgid="6212165375172061672">"Stanje za SELinux"</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">"Pomnilnik"</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="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5123197324870153205">"Moja telefonska številka"</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="status_meid_number" msgid="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_network_type" msgid="3279383550222116235">"Vrsta mobilnega omrežja"</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_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_unavailable" msgid="7862009036663793314">"Ni na voljo"</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="8907101974576694793">"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="4445041233802828430">"Med formatiranjem ne odstranite shrambe <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="5381632402953258267">"Shramba <xliff:g id="NAME">^1</xliff:g> je nared"</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_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="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>
    <!-- no translation found for error_adding_apn_type (4181334016628549645) -->
    <skip />
    <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="4412694650600342973">"Ponastavi"</string>
    <string name="reset_network_title" msgid="4557113742173895074">"Ponastavitev omr. nast."</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_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>
    <string name="master_clear_title" msgid="5907939616087039756">"Pon. na tovarniške nast."</string>
    <plurals name="master_clear_with_account_summary" formatted="false" msgid="5911377203778818712">
      <item quantity="one"><xliff:g id="ACCOUNT_COUNT">%1$d</xliff:g> račun bo ponastavljen</item>
      <item quantity="two"><xliff:g id="ACCOUNT_COUNT">%1$d</xliff:g> računa bosta ponastavljena</item>
      <item quantity="few"><xliff:g id="ACCOUNT_COUNT">%1$d</xliff:g> računi bodo ponastavljeni</item>
      <item quantity="other"><xliff:g id="ACCOUNT_COUNT">%1$d</xliff:g> računov bo ponastavljenih</item>
    </plurals>
    <string name="master_clear_summary" msgid="6902443944660426951">"Notranji pomnilnik in vsi podatki bodo ponastavljeni"</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>"Podatke 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_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="1886761972867390123">"Izbriši kartice 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_available_subtext" msgid="156779271296152605">"Povezava USB je vzpostavljena, označite za internetno povezavo prek telefona"</string>
    <string name="usb_tethering_active_subtext" msgid="8916210851136467042">"Uporablja se internetna povezava prek telefona"</string>
    <string name="usb_tethering_storage_active_subtext" msgid="8427089411146908205">"Internetna povezava prek telefona ni mogoča, kadar se uporablja pomnilnik USB"</string>
    <string name="usb_tethering_unavailable_subtext" msgid="1044622421184007254">"Povezava USB ni vzpostavljena"</string>
    <string name="usb_tethering_turnon_subtext" msgid="4748616058219273033">"Za vklop se povežite"</string>
    <string name="usb_tethering_errored_subtext" msgid="1377574819427841992">"Zaradi povezave USB je prišlo do napake internetne povezave prek telefona"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Internet prek Bluetootha"</string>
    <string name="bluetooth_tethering_available_subtext" product="tablet" msgid="2092766774943506688">"Deljenje internetne povezave tabličnega računalnika prek Bluetootha"</string>
    <string name="bluetooth_tethering_available_subtext" product="default" msgid="313873759999970236">"Deljenje internetne povezave telefona prek Bluetootha"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet" msgid="6388191062495199481">"Deljenje internetne povezave tabličnega računalnika z 1 napravo prek Bluetootha"</string>
    <string name="bluetooth_tethering_device_connected_subtext" product="default" msgid="5970460338828861091">"Deljenje internetne povezave telefona z 1 napravo prek Bluetootha"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet" msgid="3253150865825199632">"Deljenje internetne povezave tabličnega računalnika z več (<xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>) napravami prek Bluetootha"</string>
    <string name="bluetooth_tethering_devices_connected_subtext" product="default" msgid="8268867745495039177">"Deljenje internetne povezave telefona z več (<xliff:g id="CONNECTEDDEVICECOUNT">%1$d</xliff:g>) napravami prek Bluetootha"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6326877798974938021">"Deljenje internetne poezave naprave <xliff:g id="DEVICE_NAME">%1$d</xliff:g> prek Bluetootha"</string>
    <string name="bluetooth_tethering_off_subtext" product="tablet" msgid="1889565070769307732">"Brez deljenja internetne povezave tabličnega računalnika prek Bluetootha"</string>
    <string name="bluetooth_tethering_off_subtext" product="default" msgid="1838503633450298902">"Brez deljenja internetne povezave telefona prek Bluetootha"</string>
    <string name="bluetooth_tethering_errored_subtext" msgid="4926566308991142264">"Ni povezave"</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="7287131664937054043">"Uporabite dostopno točko in povezavo z internetom prek mobilnega telefona, da zagotovite internet drugim napravam prek svoje mobilne podatkovne povezave."</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_mode_title" msgid="3982009713118421689">"Način"</string>
    <string name="location_mode_high_accuracy_title" msgid="8241802585110932849">"Visoka natančnost"</string>
    <string name="location_mode_battery_saving_title" msgid="711273645208158637">"Varč. z energijo akumulatorja"</string>
    <string name="location_mode_sensors_only_title" msgid="3040366132175435160">"Samo v napravi"</string>
    <string name="location_mode_location_off_title" msgid="2829713015012529465">"Lokacija je izklopljena"</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_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_mode_screen_title" msgid="4528716772270246542">"Način ugotavljanja lokacije"</string>
    <string name="location_mode_high_accuracy_description" msgid="3453010562265338113">"Uporaba GPS-ja, Bluetootha, Wi-Fi-ja in mobilnih omrežij za določanje lokacije"</string>
    <string name="location_mode_battery_saving_description" msgid="2365298246603348985">"Uporaba Wi-Fi-ja, Bluetootha in mobilnih omrežij za določanje lokacije"</string>
    <string name="location_mode_sensors_only_description" msgid="7247994752324805202">"Uporaba GPS-a in tipal naprave za določanje lokacije"</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="8036382029606868081">"Izboljšajte natančnost lokacijskih podatkov, tako da sistemskim aplikacijam in storitvam omogočite, da kadar koli zaznajo omrežja Wi-Fi."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="5444989508204520019">"Iskanje naprav Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="8602726521250591852">"Izboljšajte natančnost lokacijskih podatkov, tako da sistemskim aplikacijam in storitvam omogočite, da kadar koli zaznajo naprave Bluetooth."</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="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="250674109915859456">"Nimate podatkovne povezave. Če si želite te podatke ogledati zdaj, odprite %s iz katerega koli računalnika z internetno povezavo."</string>
    <string name="settings_safetylegal_activity_loading" msgid="8059022597639516348">"Nalaganje …"</string>
    <string name="lockpassword_choose_your_password_header" msgid="8624900666929394990">"Izberite geslo"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="6949761069941694050">"Izberite vzorec"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7598849519816138302">"Izberite kodo PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6308478184889846633">"Potrdite geslo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Potrdite vzorec"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="49038294648213197">"Potrdite 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_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_reason_restart_device_pattern" msgid="8548464672947477043">"Če želite nadaljevati, vnesite vzorec naprave. Obvezno po vnovičnem zagonu."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_device_pin" msgid="8048122891934295280">"Če želite nadaljevati, vnesite PIN naprave. Obvezno po vnovičnem zagonu."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_device_password" msgid="9007679426540259125">"Če želite nadaljevati, vnesite geslo naprave. Obvezno po vnovičnem zagonu."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_pattern" msgid="7462071286473121099">"Če želite nadaljevati, vnesite vzorec za službo. Obvezno po vnovičnem zagonu."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_pin" msgid="809763184419127790">"Če želite nadaljevati, vnesite PIN za službo. Obvezno po vnovičnem zagonu."</string>
    <string name="lockpassword_strong_auth_required_reason_restart_work_password" msgid="8923861444535970646">"Če želite nadaljevati, vnesite geslo za službo. Obvezno po vnovičnem zagonu."</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>
    <!-- no translation found for recent_app_category_title (7212519567652392872) -->
    <skip />
    <!-- no translation found for see_all_apps_title (2428036869072119705) -->
    <skip />
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"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="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="5597622864770098388">"Počisti podatke"</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="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">"Ponastavitev nastavitev 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="disabled" msgid="9206776641295849915">"Onemogočeno"</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_data_failed" msgid="7214074331627422248">"Podatkov aplikacije ni bilo mogoče izbrisati."</string>
    <string name="clear_failed_dlg_title" msgid="2387060805294783175">"Počisti podatke"</string>
    <string name="clear_failed_dlg_text" msgid="5464475937929941008">"Podatkov za aplikacijo ni bilo mogoče izbrisati."</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="5925635036718502724">"<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_settings" msgid="5108481883575527511">"Delovanje aplikacij"</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_settings" msgid="8758655933029560944">"Jeziki in vnos"</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">"Ohrani na zaslonu, dokler 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="2599591466928793082">"Uporaba vibriranja"</string>
    <string name="vibrate_input_devices_summary" msgid="4595570516865299153">"Preusmeritev 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="battery_history_days" msgid="7110262897769622564">"<xliff:g id="DAYS">%1$d</xliff:g>d <xliff:g id="HOURS">%2$d</xliff:g>h <xliff:g id="MINUTES">%3$d</xliff:g>m <xliff:g id="SECONDS">%4$d</xliff:g>s"</string>
    <string name="battery_history_hours" msgid="7525170329826274999">"<xliff:g id="HOURS">%1$d</xliff:g>h <xliff:g id="MINUTES">%2$d</xliff:g>m <xliff:g id="SECONDS">%3$d</xliff:g>s"</string>
    <string name="battery_history_minutes" msgid="1467775596084148610">"<xliff:g id="MINUTES">%1$d</xliff:g>m <xliff:g id="SECONDS">%2$d</xliff:g>s"</string>
    <string name="battery_history_seconds" msgid="4283492130945761685">"<xliff:g id="SECONDS">%1$d</xliff:g> s"</string>
    <string name="battery_history_days_no_seconds" msgid="703063770554334710">"<xliff:g id="DAYS">%1$d</xliff:g> d <xliff:g id="HOURS">%2$d</xliff:g> h <xliff:g id="MINUTES">%3$d</xliff:g> min"</string>
    <string name="battery_history_hours_no_seconds" msgid="663342892615646712">"<xliff:g id="HOURS">%1$d</xliff:g> h <xliff:g id="MINUTES">%2$d</xliff:g> min"</string>
    <string name="battery_history_minutes_no_seconds" msgid="7780294302606853082">"<xliff:g id="MINUTES">%1$d</xliff:g> min"</string>
    <string name="usage_stats_label" msgid="5890846333487083609">"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">"Pripomočki za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Nastavitve pripomočkov za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_settings_summary" msgid="981260486011624939">"Kontrolniki za bralnike zaslona, prikaz in interakcije"</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="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="6752037184140789970">"Bližnj. za ljudi s pos. potrebami"</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="6488524140219209763">"Ko je bližnjica vklopljena, lahko funkcijo za ljudi s posebnimi potrebami zaženete tako, da pritisnete gumba 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_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="7014499339068449623">"Klik, ko se kazalec ustavi"</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Zakasnitev pred klikom"</string>
    <string name="accessibility_summary_default_combination" msgid="90096949592817459">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="accessibility_summary_state_enabled" msgid="8359913912320966304">"VKLOPLJENO"</string>
    <string name="accessibility_summary_state_disabled" msgid="2241315620132005595">"IZKLOPLJENO"</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_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_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="8618384801540759730">"Dejavnost v ozadju"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Dovoli, da se aplikacija izvaja v ozadju"</string>
    <string name="background_activity_summary_on" msgid="649282072540085599">"Ko aplikacija ni v uporabi, se lahko izvaja v ozadju"</string>
    <string name="background_activity_summary_off" msgid="7666330699090632040">"Ko aplikacija ni v uporabi, je njena dejavnost v ozadju omejena"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"Aplikaciji ni dovoljeno izvajanje v ozadju"</string>
    <string name="device_screen_usage" msgid="3386088035570409683">"Poraba 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_last_full_charge_summary" msgid="532845389094620657">"pred <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="power_usage_list_summary" msgid="6775339745194635000">"Poraba aplik. od napol. akumul. (pred <xliff:g id="TIME">^1</xliff:g>)"</string>
    <string name="power_usage_list_summary_device" msgid="7036566616386864302">"Uporaba naprave od polne napolnjenosti akumulatorja (pred <xliff:g id="TIME">^1</xliff:g>)"</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="2068039111517508622">"Napreden prikaz porabe 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="7803612642167433678">"Neobičajno delovanje aplikacije"</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">"Telefon je nedejaven"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Razno"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Preveč šteto"</string>
    <string name="power_apps" msgid="2043554781293951327">"Aplikacije"</string>
    <string name="power_service" msgid="1599661212370831780">"Storitve"</string>
    <string name="power_system" msgid="8290455327965307383">"Sistem"</string>
    <string name="power_user" msgid="1889728099253018005">"Uporabnik"</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_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> uporablja <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 napol. akumulatorja"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Zadnja polna napolnjenost akumulatorja"</string>
    <string name="battery_footer_summary" msgid="4701358808575132647">"Preostali čas delovanja akumulatorja je približen, ker je odvisen od uporabe in se lahko spremeni."</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_power_percentage" msgid="8064814503316094497">"<xliff:g id="PERCENT">%1$s</xliff:g> od skupne porabe aplikacij (<xliff:g id="POWER">%2$d</xliff:g> mAh)"</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="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="1426682272004907982">"Varčevanje 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="mem_state_subtitle" msgid="2407238869781011933">"Stanja pomnilnika"</string>
    <string name="mem_use_subtitle" msgid="7319468770222422412">"Uporaba pomnilnika"</string>
    <string name="mem_use_kernel_type" msgid="8698327165935012484">"Jedro"</string>
    <string name="mem_use_native_type" msgid="5976704902328347400">"Izvorno"</string>
    <string name="mem_use_kernel_cache_type" msgid="6411475064463957513">"Predpomnjeno v jedru"</string>
    <string name="mem_use_zram_type" msgid="9087217476795358232">"Zamenjava pomnilnika ZRam"</string>
    <string name="mem_use_free_type" msgid="717708548454880840">"Prosto"</string>
    <string name="mem_use_total" msgid="6308786055749777934">"Skupaj"</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">"Prikaz sistemskih procesov"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Skrivanje sistemskih procesov"</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">"Namesti 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">"Namesti potrdila 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">"Odstrani vsa potrdila"</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_password_too_short" msgid="7502749986405522663">"Geslo mora imeti vsaj 8 znakov."</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="6757119179588664966">"Preden lahko uporabite shrambo poverilnic, morate nastaviti kodo PIN ali geslo za zaklepanje zaslona."</string>
    <string name="usage_access_title" msgid="332333405495457839">"Apl. z dost. do pod. o uporabi"</string>
    <string name="emergency_tone_title" msgid="1055954530111587114">"Ton 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="untitled_apn" msgid="1230060359198685513">"Brez naslova"</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="5794470908668593961">"Način za delo"</string>
    <string name="work_mode_summary" msgid="1620246003886940776">"Omogočanje, da delovni profil deluje, vključno z aplikacijami, sinhronizacijo v ozadju in povezanimi funkcijami"</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="remove_account_failed" msgid="3901397272647112455">"Skrbnik ne dovoli te spremembe"</string>
    <string name="provider_label" msgid="7724593781904508866">"Potisne naročnine"</string>
    <!-- no translation found for sync_item_title (4782834606909853006) -->
    <skip />
    <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="wimax_settings" msgid="2655139497028469039">"4G"</string>
    <string name="status_wimax_mac_address" msgid="8390791848661413416">"Naslov 4G MAC"</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_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 vsakega meseca:"</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">"Nastavitev omejitve 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_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="3025322109743675467">"Če vklopite to nastavitev, 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="2577928591361606641">"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="selinux_status_disabled" msgid="924551035552323327">"Onemogočeno"</string>
    <string name="selinux_status_permissive" msgid="6004965534713398778">"Dopuščajoče"</string>
    <string name="selinux_status_enforcing" msgid="2252703756208463329">"Uveljavljajoče"</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="6151874007858148344">"Uporabniki"</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="8562152293752222985">"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."</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 v napravi"</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="global_change_warning" product="tablet" msgid="8045013389464294039">"Nastavitev vpliva na vse uporabnike v tem tabličnem računalniku."</string>
    <string name="global_change_warning" product="default" msgid="2461264421590324675">"Nastavitev vpliva na vse uporabnike v tem telefonu."</string>
    <string name="global_locale_change_title" msgid="5956281361384221451">"Spremenjen jezik"</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="8276116616493882830">"Članki s pomočjo, podpora prek telefona in klepeta"</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="2451014351355183338">"Oddaje v sili"</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_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="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="network_dashboard_title" msgid="4771589228992391573">"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="2390582103384791904">"Bluetooth, Cast, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="9106040742715366495">"Bluetooth, Cast"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Aplikacije in obvestila"</string>
    <string name="app_and_notification_dashboard_summary" msgid="2363314178802548682">"Dovoljenja, privzete aplikacije"</string>
    <string name="account_dashboard_title" msgid="4936890821712178853">"Uporabniki in računi"</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">"Nastavitve iskanja"</string>
    <string name="query_hint_text" msgid="3350700807437473939">"Nastavitve iskanja"</string>
    <string name="keywords_wifi" msgid="1395786161993828719">"wifi, wi-fi, omrežna povezava"</string>
    <string name="keywords_more_default_sms_app" msgid="2265154063220360784">"sporočilo SMS, pošiljanje sporočil SMS, sporočila SMS, izmenjava sporočil SMS"</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="3626170808219458848">"zaganjalnik"</string>
    <string name="keywords_display" msgid="8910345814565493016">"zaslon, zaslon na dotik"</string>
    <string name="keywords_display_brightness_level" msgid="3891383826236015854">"zatemnitev zaslona, zaslon na dotik, akumulator"</string>
    <string name="keywords_display_auto_brightness" msgid="3325150824507953765">"zatemnitev zaslona, zaslon na dotik, akumulator"</string>
    <string name="keywords_display_night_display" msgid="7630169927425425754">"zatemnitev zaslona, noč, obarvanje"</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="5894970373671252165">"brisanje, izbris, obnovitev, čiščenje, odstranjevanje"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"tiskalnik"</string>
    <string name="keywords_sounds" msgid="7146245090127541167">"pisk zvočnika"</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_location_mode" msgid="8584992704568356084">"natančnost"</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, znak emoji, 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="2688947724153266364">"barvna temperatura D65 D73 bela rumena modra toplo hladno"</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="5696040361482126337">"poteza"</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="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="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="5388579924689395023">"Vibriranje ob dotiku"</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="1067515631635824291">"Tiho"</string>
    <string name="emergency_tone_alert" msgid="8941852695428130667">"Opozorilo"</string>
    <string name="emergency_tone_vibrate" msgid="8281126443204950847">"Vibriranje"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Zvoki ob zagonu"</string>
    <string name="zen_mode_settings_summary_off" msgid="1857165567766351925">"Ni vklopljenih samodejnih pravil"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="1216562765753405784">
      <item quantity="one"><xliff:g id="ON_COUNT">%d</xliff:g> samodejno pravilo je vklopljeno</item>
      <item quantity="two"><xliff:g id="ON_COUNT">%d</xliff:g> samodejni pravili sta vklopljeni</item>
      <item quantity="few"><xliff:g id="ON_COUNT">%d</xliff:g> samodejna pravila so vklopljena</item>
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> samodejnih pravil je vklopljenih</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="842308776768942600">"Nastavitve načina »ne moti«"</string>
    <string name="zen_mode_priority_settings_title" msgid="2623117023031824309">"»Samo predn.« dovoljuje"</string>
    <string name="zen_mode_automation_settings_title" msgid="4228995740594063774">"Samodejna pravila"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="5105443455143476201">"Nastavi pravila za »ne moti«"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="4732808039946935657">"Omeji zvoke in vibriranja od določenih urah"</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="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="advanced_section_header" msgid="8833934850242546903">"Dodatno"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Obvestila za delovni profil"</string>
    <!-- no translation found for notification_badging_title (5938709971403474078) -->
    <skip />
    <string name="notification_pulse_title" msgid="1905382958860387030">"Utripajoča lučka"</string>
    <string name="lock_screen_notifications_title" msgid="6173076173408887213">"Na zaklenjenem zaslonu"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Pokaži vso vsebino obvestil"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7891552853357258782">"Skrij občutljivo vsebino obvestil"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"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="256116258285695645">"Skrij občutljivo vsebino obvest. za delovni profil"</string>
    <string name="lock_screen_notifications_summary_disable_profile" msgid="4080720698960233358">"Ne prikazuj obvestil 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="app_notifications_title" msgid="139788604658984593">"Obvestila"</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Kategorija obvestil"</string>
    <string name="notification_importance_title" msgid="848692592679312666">"Pomembnost"</string>
    <string name="notification_importance_unspecified" msgid="2196023702875112081">"Dovoli, da se aplikacija sama odloči"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"Nikoli ne pokaži obvestil"</string>
    <string name="notification_importance_min" msgid="5455049524984686275">"Brez zvočne ali vizualne prekinitve"</string>
    <string name="notification_importance_low" msgid="8881468429453766553">"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_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_sound" msgid="1820188704793497324">"Omogoči zvok"</string>
    <string name="show_silently_summary" msgid="7616604629123146565">"Na trenutnem zaslonu ne predvajaj zvoka, vibriraj ali na hitro prikazuj teh obvestil."</string>
    <string name="default_notification_assistant" msgid="7631945224761430146">"Pomočnik za obvestila"</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="7942592478427522244">"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="4882445501376722969">"Prikazovanje obvestil te aplikacije je izklopljeno v tej napravi Android."</string>
    <string name="channel_notifications_off_desc" msgid="5899225298718840635">"Prikazovanje obvestil te kategorije je izklopljeno v tej napravi Android."</string>
    <string name="notification_channels" msgid="5346841743182627500">"Kategorije"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Drugo"</string>
    <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="6482582965081108108">"Vklopljeno za vse aplikacije"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="5668835155965827890">
      <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>
    <!-- no translation found for notification_badge_title (6370122441168519809) -->
    <skip />
    <!-- no translation found for notification_channel_badge_title (2240827899882847087) -->
    <skip />
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Preglasitev načina »Ne moti«"</string>
    <string name="app_notification_override_dnd_summary" msgid="3516007157020189746">"Naj se ta obvestila prikazujejo tudi, ko je način »Ne moti« nastavljen na »Samo prednostno«"</string>
    <string name="app_notification_visibility_override_title" msgid="2187232730902430718">"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="7459154136384467057">"Dodaj več"</string>
    <string name="zen_mode_delete_rule" msgid="2985902330199039533">"Izbris pravila"</string>
    <string name="zen_mode_choose_rule_type" msgid="5423746638871953459">"Izbira vrste 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" msgid="2289413469580142888">"Vrsta pravila"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"Neznano"</string>
    <string name="zen_mode_configure_rule" msgid="8865785428056490305">"Konfiguriranje pravila"</string>
    <string name="zen_schedule_rule_type_name" msgid="142936744435271449">"Pravilo za č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="2645981990973086797">"Pravilo za 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_messages" msgid="5886440273537510894">"Sporočila"</string>
    <string name="zen_mode_all_messages" msgid="6449223378976743208">"Vsa sporočila"</string>
    <string name="zen_mode_selected_messages" msgid="8245990149599142281">"Izbrana 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, označenih z zvezdico"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"Brez"</string>
    <string name="zen_mode_alarms" msgid="2165302777886552926">"Alarmi"</string>
    <string name="zen_mode_reminders" msgid="5458502056440485730">"Opomniki"</string>
    <string name="zen_mode_events" msgid="7914446030988618264">"Dogodki"</string>
    <string name="zen_mode_all_callers" msgid="584186167367236922">"Vsi klicatelji"</string>
    <string name="zen_mode_selected_callers" msgid="3127598874060615742">"Izbrani klicatelji"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Klicatelji, ki večkrat kličejo"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="7192713032364140137">"Dovoljeno, če ista oseba kliče že drugič v <xliff:g id="MINUTES">%d</xliff:g> min."</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="7712038508173845101">"Blokiraj, ko je zaslon vklopljen"</string>
    <string name="zen_mode_screen_on_summary" msgid="6444425984146305149">"Prepreči, da bi obvestila, utišana z načinom »ne moti«, prikazala hiter predogled ali se pojavila na zaslonu"</string>
    <string name="zen_mode_screen_off" msgid="5026854939192419879">"Blokiraj, ko je zaslon izklopljen"</string>
    <string name="zen_mode_screen_off_summary" msgid="6490932947651798094">"Prepreči, da bi obvestila, utišana z načinom »ne moti«, vklopila zaslon ali povzročila utripanje obvestilne lučke"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="3758698381956461866">"Prepreči, da bi obvestila, utišana z načinom »ne moti«, vklopila zaslon"</string>
    <string name="zen_mode_all_visual_interruptions" msgid="2851308980832487411">"Izklopljeno"</string>
    <string name="zen_mode_screen_on_visual_interruptions" msgid="7373348148129140528">"Ko je zaslon vklopljen"</string>
    <string name="zen_mode_screen_off_visual_interruptions" msgid="4850792880144382633">"Ko je zaslon izklopljen"</string>
    <string name="zen_mode_no_visual_interruptions" msgid="8742776003822778472">"Ko je zaslon vklopljen ali izklopljen"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Nastavitve obvestil"</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="3360904523688769289">"Č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 zaslon, ki ga želite pripeti.\n\n3. Dotaknite se tipke za pregled.\n\n4. Povlecite navzgor in se dotaknite ikone žebljička."</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="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="7870273558547549125">"Opomba: po vnovičnem zagonu te aplikacije ni mogoče zagnati, če 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">"Porabljeno <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="8543457911148619898">"Obvestila aplikacij"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Vklopljeno"</string>
    <string name="notifications_disabled" msgid="334416731283131597">"Vse 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="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 aplik."</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 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="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>
    <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, da se aplikacija neprekinjeno izvaja v ozadju?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"Če omogočite, da se <xliff:g id="APP_NAME">%1$s</xliff:g> neprekinjeno izvaja v ozadju, to lahko skrajša čas delovanja akumulatorja. \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="2180443097365214467">"Polnjenje akumulatorja te naprave"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Samo polnjenje akumulatorja naprave"</string>
    <string name="usb_use_power_only" msgid="6426550616883919530">"Napajanje"</string>
    <string name="usb_use_power_only_desc" msgid="3461232831015575152">"Napolni povezano napravo. Deluje samo z napravami, ki podpirajo polnjenje prek USB-ja."</string>
    <string name="usb_use_file_transfers" msgid="7409600791007250137">"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="7794775645350330454">"Prenos fotografij (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_MIDI" msgid="870922185938298263">"Uporaba naprave kot vmesnik MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Uporaba te naprave kot vmesnik MIDI"</string>
    <string name="usb_use" msgid="3256040963685055320">"Uporaba povezave USB za:"</string>
    <string name="usb_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Polnjenje te naprave"</string>
    <string name="usb_summary_power_only" msgid="3629517713817003738">"Napajanje"</string>
    <string name="usb_summary_file_transfers" msgid="6435943692610175111">"Prenašanje datotek"</string>
    <string name="usb_summary_photo_transfers" msgid="8440204169576585250">"Prenašanje fotografij (PTP)"</string>
    <string name="usb_summary_MIDI" msgid="5687906612187885908">"Uporaba naprave kot vmesnika MIDI"</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">"Želite aplikaciji <xliff:g id="APP">%1$s</xliff:g> dovoliti dostop do načina »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="2321398930330555815">"Akumulator se lahko hitreje izprazni"</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="app_overlay_permission_preference" msgid="9039432222453006038">"Dovoljenje za prikaz aplikacije čez druge"</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">"Nedovoljene"</string>
    <string name="install_other_apps" msgid="6986686991775883017">"Nameščanje neznanih aplikacij"</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="write_settings_preference" msgid="3407383041273067448">"Dovoljenje aplikacijam za sprem. sistem. nastavitev"</string>
    <string name="permit_write_settings" msgid="6393779336656870080">"Dovoli spreminjanje sistemskih nastavitev"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"To dovoljenje aplikaciji dovoljuje spreminjanje sistemskih nastavitev."</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>
    <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_and_accounts_summary" msgid="245282689646897882">"Trenutni uporabnik: <xliff:g id="USER_NAME">%1$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="5127631544018313587">"VKLOPLJENO/<xliff:g id="LOCATION_MODE">%1$s</xliff:g>"</string>
    <string name="location_off_summary" msgid="6474350053215707957">"IZKLOPLJENO"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Varnostno kopiranje je onemogočeno"</string>
    <string name="about_summary" msgid="924181828102801010">"Posodobljeno na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Dejanje ni dovoljeno"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="7399450998356045023">"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="default_admin_support_msg" msgid="2853684309779513863">"To dejanje je onemogočeno. Če želite izvedeti več, se obrnite na skrbnika organizacije."</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="5561586417832393666">"Wi-Fi, Bluetooth in mobilno omrežje so izklopljeni. Ne morete opravljati klicev ali se povezati v internet."</string>
    <string name="condition_zen_title" msgid="2679168532600816392">"Način »ne moti« vklopljen (<xliff:g id="ID_1">%1$s</xliff:g>)"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Varč. z energijo akum. je vkl."</string>
    <string name="condition_battery_summary" msgid="4418839236027977450">"Delovanje je omejeno. Lokacijske storitve in prenos podatkov v ozadju so izklopljeni."</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_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" msgid="7280792342273268377">"Predlogi"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"in še <xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <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="telephony_monitor_toast" msgid="7003764250271195384">"Če želite uveljaviti spremembo nadziranja telefonije, znova zaženite napravo"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Samodejne sistemske posodobitve"</string>
    <string name="usage" msgid="2977875522080448986">"Poraba"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Poraba mobilnih podatkov"</string>
    <string name="wifi_data_usage" msgid="686754111095324306">"Preneseni podatki (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="5169909190811133499">"Obračunsko obdobje"</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="set_data_limit" msgid="2901526323210516923">"Nastavitev omej. prenosa pod."</string>
    <string name="data_limit" msgid="1885406964934590552">"Omejitev prenosa podatkov"</string>
    <string name="data_usage_template" msgid="392191945602400904">"Porabljeno: <xliff:g id="ID_1">%1$s</xliff:g> 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_saver_title" msgid="398458827917495765">"Varčevanje s podatki"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Neomejen podatkovni dostop"</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="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="9072203872401530722">"Vklopljeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="8309471955051162327">"Izklopljeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="battery_saver_desc_turn_on_auto_never" msgid="6715896635178578813">"Brez samodejnega vklopa"</string>
    <string name="battery_saver_desc_turn_on_auto_pct" msgid="7472323223085636533">"Samodejni vklop pri toliko odstotkih akumulatorja: %1$s"</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_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="special_access" msgid="3458780842491881155">"Posebni dostop do aplikacije"</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="4506524937307816475">"Nadzor obvestil 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="6330657582897417458">"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="2456198532288640046">"Ni vidno drugim napravam"</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="quick_settings_developer_tiles" msgid="5947788063262762448">"Ploščice razvijalcev za hitre nastavitve"</string>
    <string name="support_escalation_title" msgid="4111071371281023145">"Tu smo, da vam pomagamo"</string>
    <string name="support_escalation_24_7_title" msgid="8118369197749832074">"Na voljo smo vam 24 ur na dan vse dni v tednu"</string>
    <string name="support_escalation_24_7_content_description" msgid="3772776213036994533">"Na voljo smo vam 24 ur na dan vse dni v tednu."</string>
    <string name="support_escalation_summary" msgid="8473084168776014405">"Skupina za podporo je na voljo, da se posveti morebitnim težavam"</string>
    <string name="support_escalation_24_7_summary" msgid="2802773279262547187">"Skupina za podporo je na voljo vsak dan ob vsaki uri"</string>
    <string name="support_escalation_closed_summary" msgid="2240967274380168303">"Iščite po pomoči ali se vrnite med delovnim časom podpore (lokalni čas):&lt;br&gt;&lt;b&gt;<xliff:g id="OPERATION_HOURS">%s</xliff:g>&lt;/b&gt;"</string>
    <string name="support_escalation_no_internet_summary" msgid="2526082812336597989">"Delovni čas telefonske podpore (lokalni čas)&lt;br&gt;&lt;b&gt;<xliff:g id="OPERATION_HOURS">%s</xliff:g>&lt;/b&gt;"</string>
    <string name="support_escalation_unavailable_summary" msgid="5208552975245211898">"Iskanje po pomoči ali raziskovanje nasvetov in zvijač"</string>
    <string name="support_country_list_title" msgid="823853371280534111">"Podpora za:"</string>
    <string name="support_country_format" msgid="4502523713489559595">"<xliff:g id="COUNTRY">%1$s</xliff:g> – <xliff:g id="LANGUAGE">%2$s</xliff:g>"</string>
    <string name="support_phone_international_format" msgid="2143528744844720829">"<xliff:g id="LANGUAGE">%1$s</xliff:g> (<xliff:g id="PHONE">%2$s</xliff:g>)"</string>
    <string name="support_international_phone_title" msgid="1308334014138718455">"Potujete po tujini?"</string>
    <string name="support_international_phone_summary" msgid="208231793637026927">"Morda boste morali plačati stroške mednarodnih klicev"</string>
    <string name="support_escalation_by_phone" msgid="4843223043487058711">"Telefon"</string>
    <string name="support_escalation_by_chat" msgid="977019859110763749">"Klepet"</string>
    <string name="support_tips_and_tricks_title" msgid="4153466795695447828">"Raziskovanje nasvetov in zvijač"</string>
    <string name="support_help_feedback_title" msgid="693440287222186718">"Iskanje po pomoči in pošiljanje povratnih informacij"</string>
    <string name="support_sign_in_required_title" msgid="1367187789121480440">"Stik s podporo"</string>
    <string name="support_sign_in_button_text" msgid="3054769428620671241">"Prijava"</string>
    <string name="support_sign_in_required_help" msgid="5200654782405538114">"Se ne morete prijaviti?"</string>
    <string name="support_disclaimer_title" msgid="4825302018208770031">"Pošiljanje podatkov o sistemu"</string>
    <string name="support_disclaimer_do_not_show" msgid="3378367075323727539">"Ne prikaži več"</string>
    <string name="support_account_request_prefix" msgid="6387847874661861650">"Zahteva uporabnik"</string>
    <string name="support_account_picker_add_account" msgid="5076277544846506214">"Dodajanje računa"</string>
    <string name="support_system_information_title" msgid="3439905790018934773">"Podatki o sistemu"</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="support_estimated_wait_time" msgid="6523081420029378051">"Približna čakalna doba: <xliff:g id="ESTIMATE">%1$s</xliff:g>"</string>
    <string name="bluetooth_talkback_computer" msgid="4875089335641234463">"Računalnik"</string>
    <string name="bluetooth_talkback_headset" msgid="5140152177885220949">"Slušalke z mikrofonom"</string>
    <string name="bluetooth_talkback_phone" msgid="4260255181240622896">"Telefon"</string>
    <string name="bluetooth_talkback_imaging" msgid="551146170554589119">"Naprava za zajem slik"</string>
    <string name="bluetooth_talkback_headphone" msgid="26580326066627664">"Slušalka"</string>
    <string name="bluetooth_talkback_input_peripheral" msgid="5165842622743212268">"Zunanja dodatna oprema"</string>
    <string name="bluetooth_talkback_bluetooth" msgid="5615463912185280812">"Bluetooth"</string>
    <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="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="4033736910560673690">"Bližnjice za 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_twist_for_camera_mode_title" msgid="4877834147983530479">"Obrat fotoaparata"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Dvakrat se dotaknite, da preverite telefon"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Dvakrat se dotaknite, da preverite tablični računalnik"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Dvakrat se dotaknite, da preverite napravo"</string>
    <string name="ambient_display_summary" msgid="2521630136233865893">"Če želite hitro preveriti obvestila, se dvakrat dotaknite zaslona."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="818688002837687268">"Primite telefon, da ga preverite"</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="8696432220086951466">"Če želite hitro preveriti obvestila, primite telefon."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="2442551819015699120">"Če želite hitro preveriti obvestila, primite tablični računalnik."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="2369325441608811599">"Če želite hitro preveriti obvestila, 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_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="camera_lift_trigger_title" msgid="2758206307949942951">"Odpiranje fotoaparata z dvigom"</string>
    <string name="camera_lift_trigger_summary" msgid="8580625412416846375">"Fotoaparat se odpre samodejno, ko telefon dvignete in nastavite v položaj za fotografiranje (pokončno ali ležeče). Telefon je lahko v stanju pripravljenosti ali zaklenjen."</string>
    <!-- no translation found for camera_lift_trigger_suggestion_summary (7209899898244722404) -->
    <skip />
    <string name="assist_gesture_title" msgid="7746563137898655539">"Poteza za pomoč"</string>
    <string name="assist_gesture_summary" msgid="7575773425455374300"></string>
    <string name="assist_gesture_sensitivity_title" msgid="8424299091547331080">"Občutljivost"</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="415954951226204461">"Najprej vzpostavite povezavo z internetom"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="5884723935668892613">"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="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_account" msgid="1433620209791992528">"Račun za nenamestljive aplikacije"</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="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" msgid="5885892204903688909">"Preverjene poverilnice"</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="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="do_disclosure_learn_more" msgid="2416766240581561009">"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="3550744227788333060">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" <xliff:g id="UNIT">^2</xliff:g>"</small>""</string>
    <string name="storage_volume_total" msgid="3499221850532701342">"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="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="device_theme" msgid="4571803018917608588">"Tema naprave"</string>
    <string name="default_theme" msgid="7085644992078579076">"Privzeto"</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>
</resources>
