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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Da"</string>
    <string name="no" msgid="5541738710521607130">"Ne"</string>
    <string name="create" msgid="986997212165228751">"Ustvari"</string>
    <string name="allow" msgid="3763244945363657722">"Dovoli"</string>
    <string name="deny" msgid="7326117222944479942">"Zavrni"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Vklopi"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Neznano"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Dotaknite se za prikaz podatkov"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{# korak vas loči od tega, da postanete razvijalec.}one{# korak vas loči od tega, da postanete razvijalec.}two{# koraka vas ločita od tega, da postanete razvijalec.}few{# koraki vas ločijo od tega, da postanete razvijalec.}other{# korakov vas loči od tega, da postanete razvijalec.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Zdaj ste razvijalec"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Ni treba, ker ste že razvijalec."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Najprej omogočite možnosti za razvijalce."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"V uporabi"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Ne deluje"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio je izklopljen"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Gostovanje"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Ni gostovanja"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Prekinjena povezava"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Vzpostavljanje povezave"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Povezava je vzpostavljena"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Začasno ustavljeno"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Neznano"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Predogled"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Pomanjšanje"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Povečanje"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Uporabi samodejni zasuk"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Zaznavanje obraza uporablja sprednji fotoaparat za izboljšanje natančnosti samodejnega zasuka. Slike se nikoli ne shranijo in ne pošljejo Googlu."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"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="8122823110652921674">"Vidno vsem napravam Bluetooth v bližini"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Ni vidno drugim napravam Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Vidno samo seznanjenim napravam"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Naprave Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Ime naprave"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Preimenujte to napravo"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Preimenuj"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Prekinitev povezave z napravo?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Seznanitev nove naprave"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Seznani desno uho"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Seznani levo uho"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Seznanite drugo uho"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="7936892941892347102">"Povezava z levim slušnim aparatom je vzpostavljena.\n\nČe želite seznaniti desnega, se prepričajte, da je vklopljen in pripravljen za seznanjanje."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="8242208936062915941">"Povezava z desnim slušnim aparatom je vzpostavljena.\n\nČe želite seznaniti levega, se prepričajte, da je vklopljen in pripravljen za seznanjanje."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Seznani desno uho"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Seznani levo uho"</string>
    <!-- no translation found for bluetooth_device_controls_general (1399214835599665488) -->
    <skip />
    <!-- no translation found for bluetooth_device_controls_title (4293399064818086587) -->
    <skip />
    <!-- no translation found for bluetooth_device_controls_specific (7706863288754077107) -->
    <skip />
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Zvočni izhod"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"O zvočnem izhodu"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Zvoke usmerite v slušni aparat ali zvočnik telefona."</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Sorodno"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Zvonjenje in alarmi"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Zvok med klici"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Predstavnost"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Obvestila in drugi zvoki sistema"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Zvočni izhod privzeto določajo posamezne aplikacije."</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Neimenovana naprava Bluetooth"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Iskanje"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"V bližini ni naprav Bluetooth."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Zahteva za seznanitev Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Zahteva za seznanitev"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Dotaknite se, če želite opraviti seznanitev z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth je izklopljen"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Dotaknite se, če ga želite vklopiti"</string>
    <string name="device_picker" msgid="2427027896389445414">"Izberite napravo Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi vklopiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> želi izklopiti Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Aplikacija želi vklopiti Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Aplikacija želi izklopiti Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Vklop Bluetootha…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Izklop Bluetootha…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Zahteva za povezavo Bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Zahteva za dostop do telefonskega imenika"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Zahteva za dostop do sporočil"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Drugim napravam vidno kot »<xliff:g id="DEVICE_NAME">^1</xliff:g>«."</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Za povezavo z drugimi napravami vklopite Bluetooth."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Vaše naprave"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Seznanitev nove naprave"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Onemogoči prelaganje s strojne opreme za A2DP za Bluetooth"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Onemogoči prelaganje na strojno opremo za Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Vnovični zagon?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Če želite spremeniti to nastavitev, znova zaženite napravo."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Zaženi znova"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Prekliči"</string>
    <string name="bluetooth_enable_leaudio" msgid="1245004820628723136">"Omogoči funkcijo Bluetooth LE Audio"</string>
    <string name="bluetooth_enable_leaudio_summary" msgid="8066117764037123479">"Omogoči funkcijo Bluetooth LE Audio, če naprava podpira strojne zmogljivosti za zvok z majhno porabo energije."</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Omogoči seznam dovoljenih za Bluetooth LE zvok"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Omogočanje funkcije seznama dovoljenih za Bluetooth LE zvok"</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Predstavnostne naprave"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Klicne naprave"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Druge naprave"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Shranjene naprave"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth bo vklopljen, da bo omogočeno seznanjanje."</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Nastavitve povezave"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Predhodno povezane naprave"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth je vklopljen"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Pokaži vse"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Pisalo"</string>
    <string name="stylus_default_notes_app" msgid="3896158797687806941">"Privzeta aplikacija za zapiske"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Pisanje v besedilnih poljih"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Prezri vse pritiske gumbov pisala"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Pisalo"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum in ura"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Strežnik proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Počisti"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Vrata strežnika proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Obidi strežnik proxy za"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Ponastavi na privzeto"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Končano"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Gostiteljsko ime strežnika proxy"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Pozor"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"V redu"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Ime gostitelja, ki ste ga vtipkali, ni veljavno."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"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="4250295137005082992">"Izpolniti morate polje vrat."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Če je polje za gostitelja prazno, mora biti prazno tudi polje za vrata."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Vtipkana številka vrat je neveljavna."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Proxy za HTTP lahko uporablja brskalnik, druge aplikacije pa ne."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL datoteke PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Preverjanje imena gostitelja (www.google.com) za IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Preskus odjemalca HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Izvedba preskusa ping"</string>
    <string name="skip_label" msgid="6380034601349015895">"Preskoči"</string>
    <string name="next_label" msgid="1248293387735652187">"Naprej"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Jeziki"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Vrstni red želenih jezikov"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Sistemski jezik"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Odstrani"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Dodaj jezik"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Jezik"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Želeni jezik"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Jeziki aplikacij"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Nastavite jezik za posamezno aplikacijo."</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Jezik aplikacije"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Predlagani jeziki"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Vsi jeziki"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Sistemski jezik"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Sistemsko privzeto"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"V nastavitvah ni na voljo izbire jezika za to aplikacijo."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Jezik se morda razlikuje od jezikov, ki so na voljo v aplikaciji. Nekatere aplikacije morda ne podpirajo te nastavitve."</string>
    <string name="desc_app_locale_selection_supported" msgid="6149467826636295127">"Tukaj so prikazane samo aplikacije, ki podpirajo izbiro jezika."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Sistem, aplikacije in spletna mesta uporabijo prvi podprti jezik izmed želenih jezikov."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Če želite izbrati jezik za posamezno aplikacijo, odprite nastavitve jezika aplikacije."</string>
    <string name="desc_locale_helper_footer_general" msgid="6967183342596405116">"Več informacij o jezikih"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Želite sistemski jezik spremeniti v jezik »%s«?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Nastavitve naprave in nastavitve regije se bodo spremenile."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Spremeni"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"Jezik »%s« ni na voljo"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Tega jezika ni mogoče uporabiti kot sistemski jezik, vendar smo aplikacijam in spletnim stranem javili, da je to vaš želeni jezik."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Nastavitve regije"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Določite nastavitve za enote in številke."</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"V aplikacijah izberite svoje nastavitve regije, da vam bodo lahko prilagodile izkušnjo."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Aplikacije bodo uporabile vaše nastavitve regije povsod, kjer bo to mogoče."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatura"</string>
    <string name="calendar_preferences_title" msgid="8312485828206542600">"Koledar"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Prvi dan v tednu"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Nastavitve številk"</string>
    <string name="default_string_of_regional_preference" msgid="7662581547334113719">"Uporaba privzete nastavitve aplikacije"</string>
    <string name="celsius_temperature_unit" msgid="6118523647432383132">"Celzij (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="4622209814782318725">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"nedelja"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"ponedeljek"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"torek"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"sreda"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"četrtek"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"petek"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"sobota"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Želite odstraniti izbrani jezik?}one{Želite odstraniti izbrane jezike?}two{Želite odstraniti izbrane jezike?}few{Želite odstraniti izbrane jezike?}other{Želite odstraniti izbrane jezike?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Besedilo bo prikazano v drugem jeziku."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Vseh jezikov ni mogoče odstraniti"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Ohranite vsaj en želeni jezik"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Ni na voljo kot sistemski jezik"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Premakni navzgor"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Premakni navzdol"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Premakni na vrh"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Premakni na dno"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Odstrani jezik"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Izberite dejavnost"</string>
    <string name="cancel" msgid="5780102414089664898">"Prekliči"</string>
    <string name="okay" msgid="4827099303045669054">"V redu"</string>
    <string name="forget" msgid="3754013654135912783">"Pozabi"</string>
    <string name="save" msgid="3125033126936493822">"Shrani"</string>
    <string name="done" msgid="7497982645646431310">"Končano"</string>
    <string name="apply" msgid="7834684883190163536">"Uporabi"</string>
    <string name="share" msgid="8502235338607613795">"Deli"</string>
    <string name="add" msgid="8335206931421683426">"Dodaj"</string>
    <string name="remove" msgid="1028414219245072102">"Odstrani"</string>
    <string name="settings_label" msgid="943294133671632976">"Nastavitve"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Nastavitve"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Bližnjica do nastavitev"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Način za letalo"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Brezžično in omrežja"</string>
    <string name="roaming" msgid="3055365654530847985">"Gostovanje"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Med gostovanjem vzpostavi povezavo s podatkovnimi storitvami."</string>
    <string name="roaming_disable" msgid="729512894708689604">"Med gostovanjem vzpostavi povezavo s podatkovnimi storitvami."</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Morda boste morali plačati stroške gostovanja."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Samodejna nastavitev ure"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Nastavi samodejno"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Ko je ta preklopnik vklopljen, bo lokacija uporabljena za nastavitev časovnega pasu."</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Uporabi privzete območne nastavitve"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Uporabi 24-urni zapis časa"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Ura"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Oblika zapisa ure"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Časovni pas"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Izberite časovni pas"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Poiščite regijo"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Regija"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Izbira zamika glede na čas UTC"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Uporablja <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> se začne dne <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Uporabljen bo časovni pas <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Brez preklapljanja med zimskim in poletnim časom."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Poletni čas"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standardni čas"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Izberi po regiji"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Izbira po zamiku glede na UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Zaklepanje zaslona po poteku časa"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po pre teku časovne omejitve"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Takoj po preteku časovne omejitve, 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="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> po preteku časovne omejitve, razen ko <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> poskrbi, da ostane odklenjen."</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Besedilo na zaklenjenem zaslonu"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Brez"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Npr. Janezov Android"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Lokacija"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Uporabi lokacijo"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Izklopljeno"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{Vklopljeno – dostop do lokacije ima # aplikacija}one{Vklopljeno – dostop do lokacije ima # aplikacija}two{Vklopljeno – dostop do lokacije imata # aplikaciji}few{Vklopljeno – dostop do lokacije imajo # aplikacije}other{Vklopljeno – dostop do lokacije ima # aplikacij}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Nalaganje …"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Aplikacije z dovoljenjem za naprave v bližini lahko določijo relativno lokacijo povezanih naprav."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Dostop do lokacije je izklopljen za aplikacije in storitve. Lokacija naprave bo morda kljub temu poslana službam za nujne primere, ko pokličete številko za klic v sili ali nanjo pošljete sporočilo SMS."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Preberite več o nastavitvah lokacije."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Računi"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Varnost"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifriranje in poverilnice"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Zaklenjen zaslon"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Kaj naj bo prikazano"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Ni na voljo"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Stanje varnosti"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Zaklepanje zaslona, Poišči mojo napravo, varnost aplikacij"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Varnost in zasebnost"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Varnost aplikacij, zaklepanje naprave, dovoljenja"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Obraz je dodan."</string>
    <string name="security_settings_face_preference_summary_none" msgid="5952752252122581846">"Za nastavitev obraza se dotaknite."</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Odklepanje z obrazom"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Odklepanje z obrazom za službo"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Kako nastaviti odklepanje z obrazom"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Nastavitev odklepanja z obrazom"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Preverjanje pristnosti z obrazom"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Začni"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Če je odklepanje z obrazom za ljudi s posebnimi potrebami izklopljeno, nekateri koraki nastavitve morda ne bodo dobro delovali s funkcijo TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Nazaj"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Nadaljuj nastavitev"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Uporabi nastavitev dostopnosti"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Prekliči"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Ne, hvala"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Strinjam se"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Več"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Odklepanje z obrazom"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Omogočanje odklepanja z obrazom"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Preverjanje pristnosti z obrazom"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Z obrazom odklenite telefon ali odobrite nakupe.\n\nOpomba: obraza ne morete uporabiti za odklepanje te naprave. Za več informacij se obrnite na skrbnika v organizaciji."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Uporabljajte obraz za odklepanje telefona, odobritev nakupov ali prijavo v aplikacije"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Obraz poravnajte s krogom"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Preskoči"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Dodali ste največje dovoljeno število obrazov"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Obrazov ni več mogoče dodati"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registracija ni bila dokončana."</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"V redu"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Dosežena je bila časovna omejitev za registracijo obraza. Poskusite znova."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Registracija obraza ni uspela."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Vse je pravilno nastavljeno."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Končano"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Izboljšanje učinkovitosti odklepanja z obrazom"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Vnovična nastavitev odklepanja z obrazom"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Vnovična nastavitev odklepanja z obrazom"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Izboljšajte varnost in učinkovitost"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Nastavitev odklepanja z obrazom"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Če želite znova nastaviti odklepanje z obrazom, izbrišite trenutni model obraza.\n\nModel obraza bo trajno in varno izbrisan.\n\nPo izbrisu boste za odklepanje telefona ali preverjanje pristnosti v aplikacijah morali uporabiti kodo PIN, vzorec ali geslo."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Če želite znova nastaviti odklepanje z obrazom, izbrišite trenutni model obraza.\n\nModel obraza bo trajno in varno izbrisan.\n\nPo izbrisu boste za odklepanje telefona ali preverjanje pristnosti v aplikacijah morali uporabiti prstni odtis, kodo PIN, vzorec ali geslo."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Uporaba odklepanja z obrazom za"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Ob uporabi odklepanja z obrazom"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Oči morajo biti odprte"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Če želite odkleniti telefon, morate imeti odprte oči."</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Vedno zahtevaj potrditev"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Pri odklepanju z obrazom v aplikacijah vedno zahtevaj potrditev."</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Izbriši model obraza"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Nastavite odklepanje z obrazom"</string>
    <string name="security_settings_face_settings_footer" msgid="625696606490947189">"Z obrazom odklenite telefon ali preverite pristnost, na primer ob prijavi v aplikacije ali za odobritev nakupa.\n\nUpoštevajte:\nNaenkrat je lahko nastavljen le en obraz. Če želite dodati nov obraz, morate obstoječega izbrisati.\n\nČe pogledate proti telefonu, ga boste morda nenamerno odklenili.\n\nVaš telefon lahko odklene tudi nekdo drug, če ga podrži pred vašim obrazom.\n\nPrav tako lahko telefon odklene nekdo, ki vam je zelo podoben, na primer vaš enojajčni dvojček."</string>
    <string name="security_settings_face_settings_footer_attention_not_supported" msgid="2071065435536235622">"Z obrazom odklenite telefon ali preverite pristnost, na primer ob prijavi v aplikacije ali za odobritev nakupa.\n\nUpoštevajte:\nNaenkrat je lahko nastavljen le en obraz. Če želite dodati nov obraz, morate obstoječega izbrisati.\n\nČe pogledate proti telefonu, ga boste morda nenamerno odklenili.\n\nTelefon lahko odklene tudi nekdo drug, če ga podrži pred vašim obrazom – celo kadar imate oči zaprte.\n\nPrav tako lahko telefon odklene nekdo, ki vam je zelo podoben, na primer vaš enojajčni dvojček."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Želite izbrisati model obraza?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Model obraza bo trajno in varno izbrisan.\n\nPo izbrisu boste za odklepanje telefona ali preverjanje pristnosti v aplikacijah morali uporabiti kodo PIN, vzorec ali geslo."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Model obraza bo trajno in varno izbrisan.\n\nPo izbrisu boste za odklepanje telefona morali uporabiti kodo PIN, vzorec ali geslo."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Za odklepanje telefona uporabite obraz"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Prstni odtis"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Pri uporabi odklepanja s prstnim odtisom"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Prstni odtis za službo"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Dodajte prstni odtis"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Prstni odtis je dodan.}one{# prstni odtis je dodan.}two{# prstna odtisa sta dodana.}few{# prstni odtisi so dodani.}other{# prstnih odtisov je dodanih.}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1044059475710838504"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Nastavitev prstnega odtisa"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Omogočanje odklepanja s prstnim odtisom"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Uporaba prstnega odtisa"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Več o odklepanju s prstnim odtisom"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Vse imate pod nadzorom"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Vi in otrok imate nadzor"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Upoštevajte"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"S prstnim odtisom odklenite telefon ali odobrite nakupe.\n\nOpomba: prstnega odtisa ne morete uporabiti za odklepanje te naprave. Za več informacij se obrnite na skrbnika v organizaciji."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Prekliči"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Ne, hvala"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Strinjam se"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Brez prstnega odtisa?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Nastavitev prstnega odtisa vam bo vzela le minuto ali dve. Če nastavitev preskočite, lahko prstni odtis dodate pozneje v nastavitvah."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Ko vidite to ikono, uporabite prstni odtis za preverjanje pristnosti, na primer ob prijavi v aplikacije ali da odobrite nakup."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Upoštevajte"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Delovanje"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Odklepanje s prstnim odtisom ustvari edinstven model vašega prstnega odtisa, s katerim potrdite svojo identiteto. Za ustvarjanje modela prstnega odtisa med postopkom nastavitve morate posneti svoj prstni odtis v različnih položajih."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Odklepanje s prstnim odtisom ustvari edinstven model otrokovega prstnega odtisa, s katerim potrdi svojo identiteto. Za ustvarjanje modela prstnega odtisa med postopkom nastavitve mora posneti svoj prstni odtis v različnih položajih."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Za najboljše rezultate uporabljajte zaščito zaslona, ki ima potrdilo »Narejeno za Google«. Če uporabljate druge zaščite zaslona, prstni odtis morda ne bo deloval."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Za najboljše rezultate uporabljajte zaščito zaslona, ki ima potrdilo »Narejeno za Google«. Če uporabljate druge zaščite zaslona, otrokov prstni odtis morda ne bo deloval."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Odklepanje z uro"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Če nastavite odklepanje z obrazom in prstnim odtisom, telefon zahteva prstni odtis, ko nosite masko ali ko ste nekje, kjer je temno.\n\nČe obraz ali prstni odtis ni prepoznan, lahko telefon odklenete z uro."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Če prstni odtis ni prepoznan, lahko odklenete z uro."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Če obraz ni prepoznan, lahko odklenete z uro."</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Uporaba obraza ali ure"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Uporaba prstnega odtisa ali ure"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Uporaba obraza, prstnega odtisa ali ure"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Uporaba ure"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Nastavite odklepanje z obrazom ali prstnim odtisom"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Če obraz ali prstni odtis ni prepoznan, lahko odklenete z uro."</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Najprej nastavite odklepanje s prstnim odtisom"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Če prstni odtis ni prepoznan, lahko odklenete z uro."</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Najprej nastavite odklepanje z obrazom"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Če obraz ni prepoznan, lahko odklenete z uro."</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Nastavitev"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Prstni odtis in <xliff:g id="WATCH">%s</xliff:g> sta dodana"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Prstni odtisi in <xliff:g id="WATCH">%s</xliff:g> so dodani"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Obraz in <xliff:g id="WATCH">%s</xliff:g> sta dodana"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Obraz, prstni odtis in <xliff:g id="WATCH">%s</xliff:g> so dodani"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Obraz, prstni odtisi in <xliff:g id="WATCH">%s</xliff:g> so dodani"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Odklepanje z obrazom in prstnim odtisom"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Odklepanje z obrazom in prstnim odtisom za službo"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="6941188982863819389">"Dotaknite se za nastavitev."</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Obraz in prstni odtisi so dodani."</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Obraz in prstni odtis sta dodana."</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Če nastavite odklepanje z obrazom in prstnim odtisom, telefon zahteva prstni odtis, ko nosite masko ali ko ste nekje, kjer je temno."</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Načini odklepanja"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Uporaba obraza ali prstnega odtisa za"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Odklepanje telefona"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Preverjanje identitete v aplikacijah"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Uporaba obraza"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Uporaba prstnega odtisa"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Uporaba obraza ali prstnega odtisa"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"V redu"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Preskok zaklepanja zaslona?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Vseeno preskoči"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Nazaj"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Preskoči"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Prekliči"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Dotaknite se tipala"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Dotaknite se gumba za vklop, ne da bi ga pritisnili"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Navodila za nastavitev prstnega odtisa"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Je na hrbtni strani telefona. Uporabite kazalec."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Tipalo prstnih odtisov je na zaslonu. Zajem prstnega odtisa boste izvedli na naslednjem zaslonu."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Začnite"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Tipalo najdete tako, da prst premaknete po zaslonu. Dotaknite se tipala prstnih odtisov in ga pridržite."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustracija z napravo in lokacijo tipala prstnih odtisov"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Ime"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"V redu"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Poskusite znova"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Izbriši"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Dotaknite se tipala"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Prst položite na tipalo in ga dvignite, ko začutite vibriranje."</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Držite prst plosko na tipalu, dokler ne začutite vibriranja."</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Ne da bi pritisnili gumb, držite prst na tipalu, dokler ne začutite vibriranja.\n\nVsakič nekoliko premaknite prst. Tako bo sistem lahko zajel večji del prstnega odtisa."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Dotaknite se tipala prstnih odtisov in ga pridržite"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Dvignite in se spet dotaknite"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Še enkrat"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Sledite ikoni prstnega odtisa"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Še naprej privzdigujte prst, da dodate različne dele prstnega odtisa."</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Dotaknite se in pridržite vsakič, ko se ikona prstnega odtisa premakne. Tako bo sistem lahko zajel večji del prstnega odtisa."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Položite konico prsta na tipalo"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Položite levi rob prsta"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Položite desni rob prsta"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Položite sredino prsta na tipalo"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Položite konico prsta na tipalo"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Položite levi rob prsta na tipalo"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Nazadnje položite desni rob prsta na tipalo"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Stranski del prstnega odtisa položite na tipalo prstnih odtisov in ga pridržite, nato zamenjajte stran."</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Tako bo sistem lahko zajel večji del prstnega odtisa."</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Prijavljanje prstnega odtisa <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Napredek prijave: <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Prijavljanje prstnega odtisa <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Prstni odtis je dodan"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Dotik za odklepanje kadar koli"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Z dotikom tipala lahko odklenete napravo, tudi ko je zaslon izklopljen. To poveča verjetnost nenamernega odklepanja."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Zaslon, odklepanje"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Pozneje"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Dvignite in se spet dotaknite"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Stranski del prstnega odtisa položite na tipalo prstnih odtisov in ga pridržite, nato zamenjajte stran."</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Želite preskočiti nast. prstnega odtisa?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"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="lock_screen_pin_skip_title" msgid="6853866579893458111">"Ne želite nastaviti kode PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Želite preskočiti nastavitev kode PIN in obraza?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Želite preskočiti nastavitev kode PIN in prstnega odtisa?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Želite preskočiti nastavitev kode PIN, obraza in prstnega odtisa?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Ne želite nastaviti gesla?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Preskok nastavitve gesla in obraza?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Preskok nastavitve gesla in prstnega odtisa?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Preskok nastavitve gesla, obraza in prs. odtisa?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Ne želite nastaviti vzorca?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Preskok nastavitve vzorca in obraza?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Preskok nastavitve vzorca in prstnega odtisa?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Preskok nastavitve vzorca, obraza in odtisa?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Nastavi zaklepanje zaslona"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Končano"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ups, to ni tipalo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"S kazalcem se dotaknite tipala na hrbtni strani telefona."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="5796228438604723279">"Registracija ni bila dokončana."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Čas za nastavitev prstnega odtisa je potekel."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="467965101751652156">"Poskusite znova zdaj ali nastavite prstni odtis pozneje v nastavitvah."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"Registracija prstnega odtisa ni uspela. Poskusite znova ali uporabite drug prst."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Dodaj še enega"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Naprej"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Ta možnost zaklepanja zaslona je onemogočena. Za več informacij se obrnite na skrbnika organizacije."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"S prstnim odtisom lahko še vedno odobrite nakupe in dostop do aplikacij."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Dvignite prst in se znova dotaknite tipala."</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="598502302101068608">"Tipala prstnih odtisov ni mogoče uporabiti. Obiščite ponudnika popravil."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Več varnostnih nastavitev"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Zaklepanje delovnega profila, šifriranje in drugo"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Šifriranje, poverilnice in drugo"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"varnost, več varnostnih nastavitev, več nastavitev, dodatne varnostne nastavitve"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Več nastavitev zasebnosti"</string>
    <string name="more_security_privacy_settings" msgid="977191087706506398">"Več nastavitev"</string>
    <string name="security_header" msgid="961514795852103424">"Varnost"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Zasebnost"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Delovni profil"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Dodate lahko do toliko prstnih odtisov: <xliff:g id="COUNT">%d</xliff:g>"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Dodali ste največje dovoljeno število prstnih odtisov"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Prstnih odtisov ni več mogoče dodati"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Brisanje prstnega odtisa »<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>«"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Za odklepanje delovnega profila, odobritev nakupov ali prijavo v delovne aplikacije ne boste mogli uporabljati prstnega odtisa."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Šifriranje"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Šifrirano"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Nastavitev zaklepanja zaslona"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Za večjo varnost nastavite kodo PIN, vzorec ali geslo za to napravo."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Nastavite zaklepanje zaslona"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="5718363966239208505">"Naprava nima nastavljenega zaklepanja zaslona"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Za večjo varnost nastavite kodo PIN, vzorec ali geslo za to napravo."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Zaščitite telefon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Dodajanje prstnega odtisa za odklepanje"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Izberite zaklepanje zaslona"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Izberite zaklepanje zaslona"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Izbira novega zaklepanja zaslona"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Izbira zaklepanja za delovne aplikacije"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Izbira novega zaklepanja za službo"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Zaradi večje varnosti nastavite nadomestni način zaklepanja zaslona."</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Izberite nadomestni način zaklepanja zaslona."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Če način odklepanja zaslona pozabite, ga skrbnik za IT ne more ponastaviti."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Nastavite ločeno zaklepanje za delovni profil."</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Če ta način odklepanja pozabite, naj vam ga skrbnik za IT ponastavi."</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Možnosti zaklepanja zaslona"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Možnosti zaklepanja zaslona"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Samodejna potrditev odklepanja"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Samodejno se odklene ob vnosu pravilne šest- ali večmestne kode PIN. To je nekoliko manj varno od potrditve z dotikom tipke Enter."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Samodejna potrditev pravilne kode PIN"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Potrditev kode PIN z dotikom tipke Enter je varnejša od uporabe samodejne potrditve."</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Zaklepanje zaslona"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Zaklep. del. profila"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Brez"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Vlečenje"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Vzorec"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"Koda PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Geslo"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ne zdaj"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Trenutno zaklepanje zaslona"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"Prstni odtis in vzorec"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"Prstni odtis in PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"Prstni odtis in geslo"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Nadaljevanje brez prstnega odtisa"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="3117316407679805330">"Odklepanje z obrazom + vzorec"</string>
    <string name="face_unlock_set_unlock_pin" msgid="5300188327595503657">"Odklepanje z obrazom + koda PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="8395722611524617956">"Odklepanje z obrazom + geslo"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Nadaljevanje brez odklepanja z obrazom"</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Vzorec • Obraz • Prstni odtis"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"Koda PIN • Obraz • Prstni odtis"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Geslo • Obraz • Prstni odtis"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Nadaljujte brez obraza ali prstnega odtisa"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Brez"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Vlečenje"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Vzorec"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"Koda PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Geslo"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Želite izbrisati zaklepanje zaslona?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Želite odstraniti zaščito profila?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Vzorec ščiti telefon, če ga izgubite ali vam ga ukradejo."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Vzorec ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>S tem boste izbrisali tudi model prstnega odtisa, ki je shranjen v napravi. Prstnega odtisa ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Vzorec ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>Trajno in varno bo izbrisan tudi model obraza. Obraza ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Vzorec ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>S tem boste izbrisali model prstnega odtisa, ki je shranjen v napravi. Trajno in varno bo izbrisan tudi model obraza. Obraza in prstnega odtisa ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"Koda PIN ščiti telefon, če ga izgubite ali vam ga ukradejo."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"Koda PIN ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>S tem boste izbrisali tudi model prstnega odtisa, ki je shranjen v napravi. Prstnega odtisa ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"Koda PIN ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>Trajno in varno bo izbrisan tudi model obraza. Obraza ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"Koda PIN ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>S tem boste izbrisali model prstnega odtisa, ki je shranjen v napravi. Trajno in varno bo izbrisan tudi model obraza. Obraza in prstnega odtisa ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Geslo ščiti telefon, če ga izgubite ali vam ga ukradejo."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Geslo ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>S tem boste izbrisali tudi model prstnega odtisa, ki je shranjen v napravi. Prstnega odtisa ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Geslo ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>Trajno in varno bo izbrisan tudi model obraza. Obraza ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Geslo ščiti telefon, če ga izgubite ali vam ga ukradejo.<xliff:g id="EMPTY_LINE">

</xliff:g>S tem boste izbrisali model prstnega odtisa, ki je shranjen v napravi. Trajno in varno bo izbrisan tudi model obraza. Obraza in prstnega odtisa ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Funkcije za zaščito naprave ne bodo delovale brez zaklepanja zaslona."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Funkcije za zaščito naprave ne bodo delovale brez zaklepanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>S tem boste izbrisali tudi model prstnega odtisa, ki je shranjen v napravi. Prstnega odtisa ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Funkcije za zaščito naprave ne bodo delovale brez zaklepanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>Trajno in varno bo izbrisan tudi model obraza. Obraza ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Funkcije za zaščito naprave ne bodo delovale brez zaklepanja zaslona.<xliff:g id="EMPTY_LINE">

</xliff:g>S tem boste izbrisali model prstnega odtisa, ki je shranjen v napravi. Trajno in varno bo izbrisan tudi model obraza. Obraza in prstnega odtisa ne boste več mogli uporabljati za preverjanje pristnosti v aplikacijah."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Izbriši"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> priporoča močno kodo PIN ali geslo, sicer morda ne bo delovala, kot je pričakovano"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> priporoča novo kodo PIN ali geslo, sicer morda ne bo delovala, kot je pričakovano"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> priporoča nov vzorec, kodo PIN ali geslo, sicer morda ne bo delovala, kot je pričakovano"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> priporoča novo zaklepanje zaslona."</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Poskusite znova. Poskus <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> od <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Vaši podatki bodo izbrisani"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Če pri naslednjem poskusu vnesete napačen vzorec, bodo podatki v napravi izbrisani."</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Če pri naslednjem poskusu vnesete napačno kodo PIN, bodo podatki v napravi izbrisani."</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Če pri naslednjem poskusu vnesete napačno geslo, bodo podatki v napravi izbrisani."</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Če pri naslednjem poskusu vnesete napačen vzorec, bo uporabnik izbrisan"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Če pri naslednjem poskusu vnesete napačno kodo PIN, bo uporabnik izbrisan"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Če pri naslednjem poskusu vnesete napačno geslo, bo uporabnik izbrisan"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Če pri naslednjem poskusu vnesete napačen vzorec, bodo delovni profil in podatki v njem izbrisani"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Če pri naslednjem poskusu vnesete napačno kodo PIN, bodo delovni profil in podatki v njem izbrisani"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Če pri naslednjem poskusu vnesete napačno geslo, bodo delovni profil in podatki v njem izbrisani"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Vsebovati mora vsaj # znak}one{Vsebovati mora vsaj # znak.}two{Vsebovati mora vsaj # znaka.}few{Vsebovati mora vsaj # znake.}other{Vsebovati mora vsaj # znakov.}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Če je samo številsko, mora vsebovati vsaj 1 števko.}one{Če je samo številsko, mora vsebovati vsaj # števko.}two{Če je samo številsko, mora vsebovati vsaj # števki.}few{Če je samo številsko, mora vsebovati vsaj # števke.}other{Če je samo številsko, mora vsebovati vsaj # števk.}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{Koda PIN mora vsebovati vsaj # števko}one{Koda PIN mora vsebovati vsaj # števko}two{Koda PIN mora vsebovati vsaj # števki}few{Koda PIN mora vsebovati vsaj # števke}other{Koda PIN mora vsebovati vsaj # števk}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{Koda PIN mora vsebovati vsaj # števko, vendar je za večjo varnost priporočljiva uporaba {minAutoConfirmLen}-mestne kode PIN.}one{Koda PIN mora vsebovati vsaj # števko, vendar je za večjo varnost priporočljiva uporaba {minAutoConfirmLen}-mestne kode PIN.}two{Koda PIN mora vsebovati vsaj # števki, vendar je za večjo varnost priporočljiva uporaba {minAutoConfirmLen}-mestne kode PIN.}few{Koda PIN mora vsebovati vsaj # števke, vendar je za večjo varnost priporočljiva uporaba {minAutoConfirmLen}-mestne kode PIN.}other{Koda PIN mora vsebovati vsaj # števk, vendar je za večjo varnost priporočljiva uporaba {minAutoConfirmLen}-mestne kode PIN.}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Vsebovati mora manj kot # znak}one{Vsebovati mora manj kot # znak}two{Vsebovati mora manj kot # znaka}few{Vsebovati mora manj kot # znake}other{Vsebovati mora manj kot # znakov}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Vsebovati mora manj kot # števko}one{Vsebovati mora manj kot # števko}two{Vsebovati mora manj kot # števki}few{Vsebovati mora manj kot # števke}other{Vsebovati mora manj kot # števk}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Skrbnik naprave ne dovoli uporabe nedavne kode PIN."</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Ne sme vsebovati neveljavnih znakov."</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Vsebovati mora vsaj eno črko}one{Vsebovati mora vsaj # črko}two{Vsebovati mora vsaj # črki}few{Vsebovati mora vsaj # črke}other{Vsebovati mora vsaj # črk}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Vsebovati mora vsaj eno malo črko}one{Vsebovati mora vsaj # malo črko}two{Vsebovati mora vsaj # mali črki}few{Vsebovati mora vsaj # male črke}other{Vsebovati mora vsaj # malih črk}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Vsebovati mora vsaj eno veliko črko}one{Vsebovati mora vsaj # veliko črko}two{Vsebovati mora vsaj # veliki črki}few{Vsebovati mora vsaj # velike črke}other{Vsebovati mora vsaj # velikih črk}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Vsebovati mora vsaj eno števko}one{Vsebovati mora vsaj # števko}two{Vsebovati mora vsaj # števki}few{Vsebovati mora vsaj # števke}other{Vsebovati mora vsaj # števk}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Vsebovati mora vsaj en posebni znak}one{Vsebovati mora vsaj # posebni znak}two{Vsebovati mora vsaj # posebna znaka}few{Vsebovati mora vsaj # posebne znake}other{Vsebovati mora vsaj # posebnih znakov}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Vsebovati mora vsaj en znak, ki ni črka}one{Vsebovati mora vsaj # znak, ki ni črka}two{Vsebovati mora vsaj # znaka, ki nista črki}few{Vsebovati mora vsaj # znake, ki niso črke}other{Vsebovati mora vsaj # znakov, ki niso črke}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Vsebovati mora vsaj en znak, ki ni števka}one{Vsebovati mora vsaj # znak, ki ni števka}two{Vsebovati mora vsaj # znaka, ki nista števki}few{Vsebovati mora vsaj # znake, ki niso števke}other{Vsebovati mora vsaj # znakov, ki niso števke}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Skrbnik naprave ne dovoli uporabe nedavnega gesla."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Naraščajoč, padajoč ali ponavljajoč se niz števk je prepovedan."</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Potrdi"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Izbriši"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Zaklepanje zaslona je že bilo spremenjeno. Poskusite znova z novim zaklepanjem zaslona."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Prekliči"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Naprej"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Skrbniške aplikacije naprave"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Ni aktivnih aplikacij"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktivna aplikacija}one{# aktivna aplikacija}two{# aktivni aplikaciji}few{# aktivne aplikacije}other{# aktivnih aplikacij}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Posredniki zaupanja"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Za uporabo najprej nastavite zaklepanje zaslona."</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Brez"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktiven posrednik zaupanja}one{# aktiven posrednik zaupanja}two{# aktivna posrednika zaupanja}few{# aktivni posredniki zaupanja}other{# aktivnih posrednikov zaupanja}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Želite opraviti seznanitev z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Koda Bluetooth za seznanitev"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Vnesite kodo za seznanjanje in nato pritisnite Return ali Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN vsebuje črke ali simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Običajno 0000 ali 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Biti mora 16-mestno število"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Ta PIN boste morda morali vnesti tudi v drugi napravi."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Geslo boste morda morali vnesti tudi v drugi napravi."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Potrdite seznanjanje s kompletom naprav"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Dovoli dostop do stikov in zgodovine klicev"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Povezave z napravo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ni bilo mogoče vzpostaviti."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Razpoložljive naprave"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Vzpostavi povezavo"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Prekini povezavo"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Seznanitev in povezava"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Kadar je Bluetooth vklopljen, lahko vaša naprava komunicira z drugimi napravami Bluetooth v bližini."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Ko je Bluetooth vklopljen, lahko vaša naprava komunicira z drugimi napravami Bluetooth v bližini.\n\nZa izboljšano izkušnjo pri uporabi naprave lahko aplikacije in storitve še vedno kadar koli iščejo naprave v bližini, tudi ko je Bluetooth izklopljen. To se na primer uporablja za izboljšanje funkcij in storitev, ki pri delovanju uporabljajo lokacijo. Izbiro lahko spremenite v nastavitvah iskanja naprav Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Spremeni"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Podrobnosti o napravi"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Nastavitve tipkovnice"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Naslov Bluetooth naprave: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Naslov Bluetooth naprave:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Želite, da vaša naprava pozabi seznanjeno napravo?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Odstrani povezavo"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Želite prekiniti povezavo z aplikacijo?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> se ne bo več povezala z napravo <xliff:g id="DEVICE_NAME">%2$s</xliff:g>."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Pozabi napravo"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Prekini povezavo z aplikacijo"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Največje dovoljeno število povezanih zvočnih naprav Bluetooth"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Izberite največje dovoljeno število povezanih zvočnih naprav Bluetooth"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Dnevnik odpravljanja napak sklada NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Povečaj raven zapisovanja dnevnika za sklad NFC."</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Podroben dnevnik odpravljanja napak NFC za ponudnika"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Vključi dodatne dnevnike ponudnika, odvisne od posamezne naprave, v poročila o napakah, ki morda vsebujejo zasebne podatke."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Nefiltriran dnevnik vmesnika NCI za NFC"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Zajemanje podrobnih paketov NFC, ki morda vsebujejo zasebne podatke."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Vnovični zagon?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Podrobno zapisovanje dnevnika za NFC je namenjeno samo za razvoj. Dodatni podatki NFC so vključeni v poročilih o napakah, ki morda vsebujejo zasebne podatke. Če želite spremeniti to nastavitev, znova zaženite napravo."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Zaženi znova"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Predvajanje"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"zrcaljenje"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Omogočanje brezžičnega zaslona"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"V bližini ni naprav."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Povezovanje"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Povezane"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"V uporabi"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Ni na voljo"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Možnosti prikaza brezžičnih naprav"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Pozabi"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Končano"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Ime"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Prijava"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Odpri spletno mesto"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Še <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Poteče <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mb/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"Aplikacija <xliff:g id="REQUESTER">%s</xliff:g> želi vklopiti Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"Aplikacija <xliff:g id="REQUESTER">%s</xliff:g> želi izklopiti Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Preveri bitno kodo aplikacij z možnostjo odpravljanja napak"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Preverjevalniku ART dovoli preverjanje bitne kode aplikacij, ki podpirajo odpravljanje napak."</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Pokaži hitrost osveževanja"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Prikaži trenutno hitrost osveževanja zaslona."</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Zahtevaj odklep naprave pred uporabo NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Pripravljen za prenos vsebine aplikacije prek NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Izklopljeno"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Ni na voljo, ker je NFC izklopljen."</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"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_settings" msgid="8313301946393559700">"Wi‑Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Uporabi Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Nastavitve za Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Izberi Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Vklapljanje povezave Wi‑Fi …"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Izklapljanje povezave Wi‑Fi …"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Napaka"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5-GHz pas ni na voljo v tej državi"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"V načinu za letalo"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Obvesti, če so na voljo javna omrežja"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Obvesti me, ko je na voljo zanesljivo javno omrežje."</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Samodejno vklopi Wi‑Fi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi‑Fi se bo samodejno znova vklopil v bližini zanesljivih shranjenih omrežij, na primer vašega domačega omrežja."</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Ni na voljo, ker je lokacija izklopljena. Vklopite "<annotation id="link">"lokacijo"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Namesti potrdila"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Za večjo natančnost določanja lokacije lahko aplikacije in storitve še vedno kadar koli iščejo omrežja Wi-Fi, tudi ko je Wi-Fi izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo. To lahko kadar koli spremenite v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavitvah iskanja omrežij Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Če želite izboljšati natančnost ugotavljanja lokacije, v <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>nastavitvah iskanja omrežij Wi‑Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g> vklopite iskanje omrežij Wi-Fi."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Samodejno preklopi na prenos podatkov v mobilnih omrežjih"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Uporaba prenosa podatkov v mobilnih omrežjih, če omrežje Wi-Fi nima dostopa do interneta. Pri tem bodo morda nastali stroški prenosa podatkov v mobilnih omrežjih."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Dodajte omrežje"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Nastavitve za Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi se samodejno znova vklopi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi se ne vklopi znova samodejno"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi‑Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Za prikaz razpoložljivih omrežij vklopite Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Iskanje omrežij …"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nimate dovoljenja za spreminjanje omrežja Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Želite vklopiti iskanje omrežij Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Če želite samodejno vklopiti Wi-Fi, morate najprej vklopiti iskanje omrežij Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Iskanje omrežij Wi-Fi aplikacijam in storitvam omogoči, da kadar koli iščejo omrežja Wi-Fi, tudi ko je Wi-Fi izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Vklopi"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Iskanje omrežij Wi‑Fi je vklopljeno"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Dodatne možnosti"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Dodatne možnosti spustnega seznama"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"razširi"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Ime omrežja"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Vnesite SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Varnost"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skrito omrežje"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Če vaš usmerjevalnik ne oddaja omrežnega ID-ja, vendar se želite povezati z njim v prihodnosti, lahko omrežje nastavite kot skrito.\n\nTo lahko povzroči varnostno tveganje, ker bo telefon redno oddajal svoj signal, da najde omrežje.\n\nČe omrežje nastavite kot skrito, to ne bo spremenilo nastavitev usmerjevalnika."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Moč signala"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Stanje"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Hitrost povezave za pošiljanje"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Hitrost povezave za prejemanje"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Hitrost povezave"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekvenca"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Naslov IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Shranjeno prek:"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Poverilnice za <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Način EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Preverjanje pristnosti v fazi 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Overjeno potrdilo"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Najnižja različica protokola TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Stanje spletnega potrdila"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domena"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Uporabniško potrdilo"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identiteta"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonimna identiteta"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Geslo"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Pokaži geslo"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4-GHz pas"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"5,0-GHz pas (prednostno)"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Nastavitve naslova IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Zasebnost"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Naročnina"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Ogled ali sprememba naročnine"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Naključno izbran MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Dodajte napravo"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Kodo QR spodaj nastavite na sredino, če želite napravo dodati v omrežje »<xliff:g id="SSID">%1$s</xliff:g>«."</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Optično preberite kodo QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Kodo QR spodaj nastavite na sredino, da vzpostavite povezavo z omrežjem »<xliff:g id="SSID">%1$s</xliff:g>«."</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Če se želite pridružiti omrežju Wi‑Fi, preberite kodo QR."</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Delite omrežje Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Če se želite pridružiti omrežju »<xliff:g id="SSID">%1$s</xliff:g>«, kodo QR preberite z drugo napravo."</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Če želite vzpostaviti povezavo z omrežjem »<xliff:g id="SSID">%1$s</xliff:g>«, preberite to kodo QR"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Poskusite znova. Če se težava ponavlja, se obrnite na proizvajalca naprave."</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Prišlo je do težave"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Prepričajte se, da je naprava priključena, napolnjena in vklopljena"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Prepričajte se, da je naprava priključena, napolnjena in vklopljena. Če se težava ponavlja, se obrnite na proizvajalca naprave."</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Naprava ne podpira dodajanja oznake »<xliff:g id="SSID">%1$s</xliff:g>«"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Poskusite napravo premakniti bliže dostopni točki/usmerjevalniku Wi-Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Preverite geslo in poskusite znova"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Obrnite se na proizvajalca naprave"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Preverite povezavo in poskusite znova"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Izbira omrežja"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Če želite povezati napravo, izberite omrežje"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Želite to napravo dodati v omrežje »<xliff:g id="SSID">%1$s</xliff:g>«?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Omrežje Wi‑Fi je deljeno z napravo"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Dodaj novo napravo"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Izberi drugo omrežje"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Naprave ni bilo mogoče dodati"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Najdena je bila naprava"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Deljenje povezave Wi‑Fi s to napravo …"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Povezovanje …"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Delite dostopno točko"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Potrdite, da ste res vi"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Geslo za Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Geslo za dostopno točko: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Samodejna povezava"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Dovoli povezavo s tem omrežjem, ko je v dosegu."</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Dodajte napravo"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Če želite dodati napravo v to omrežje, uporabite kodo QR."</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Koda QR nima pravilne oblike zapisa"</string>
    <string name="retry" msgid="7542103800274026915">"Poskusi znova"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Deljenje z drugimi uporabniki naprave"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nespremenjeno)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Izberite"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Dodanih je bilo več potrdil)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Uporabi sistemska potrdila"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Ne posreduj"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Zaupaj ob prvi uporabi"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Ime omrežja je predolgo."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Določiti morate domeno."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Potrdilo je obvezno."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"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_turn_on_message_unknown" msgid="4903345360745717385">"Za izboljšanje natančnosti lokacijskih podatkov in druge namene želi neznana aplikacija vklopiti iskanje omrežij, tudi ko je Wi-Fi izklopljen.\n\nDovolite to vsem aplikacijam, ki želijo iskati?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Dovoli"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Zavrni"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"To omrežje nima dostopa do interneta. Ali želite ostati povezani?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Nekatere aplik./storitve morda ne bodo delovale zaradi omej. povezljivosti. Želite vseeno uporabiti?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ne sprašuj več za to omrežje"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Omrežje Wi-Fi ni povezano z internetom"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"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="7935665847081706202">"Preklopi na mobilno"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Ostani v omrežju Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Tega ne prikaži nikoli več"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Vzpostavi povezavo"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi je vklopljen"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Povezano z omrežjem <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Vzpostavljanje povezave z omrežjem <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Povezovanje …"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Vzpostavljanje povezave z omrežjem ni uspelo"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Omrežje ni v dosegu"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Pozabi"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Spremeni"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Pozabljanje omrežja ni uspelo"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Shrani"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Shranjevanje omrežja ni uspelo"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Prekliči"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Želite, da naprava pozabi omrežje?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 omrežje}one{# omrežje}two{# omrežji}few{# omrežja}other{# omrežij}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 naročnina}one{# naročnina}two{# naročnini}few{# naročnine}other{# naročnin}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 omrežje in naročnina}one{# omrežje in naročnina}two{# omrežji in naročnini}few{# omrežja in naročnine}other{# omrežij in naročnin}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Naslov MAC naprave"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Naključno izbran naslov MAC"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Naključen naslov MAC (nazadnje uporabljen)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Podatki o omrežju"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Maska podomrežja"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Vrsta"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Naslovi IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Shranjena omrežja"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Naročnine"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Druga omrežja"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Vnesite veljaven naslov IP."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Vnesite veljaven naslov prehoda."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Vnesite veljaven naslov DNS."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Vnesite predpono omrežja, dolgo med 0 in 32 znaki."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (razen v primeru preglasitve z zasebnim strežnikom DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (razen v primeru preglasitve z zasebnim strežnikom DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Prehod"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Dolžina predpone omrežja"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi‑Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Išči naprave"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Iskanje …"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Preimenujte napravo"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Enakovredne naprave"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Shranjene skupine"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Povezava ni mogoča."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Naprave ni bilo mogoče preimenovati."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Želite prekiniti povezavo?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Č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="4490648217799144078">"Č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="8476985132989357041">"Želite preklicati povabilo?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"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="4880242270742385699">"Želite pozabiti to skupino?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Dostopna točka Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Internetna povezava ali vsebina ni deljena z drugimi napravami"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Geslo ni nastavljeno"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Ime dostopne točke"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Geslo za dostopno točko"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Pas dostopne točke"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Samodejni izklop dostopne točke"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kadar ni povezana nobena naprava"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Razširjena združljivost"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Drugim napravam pomaga najti to dostopno točko. Zmanjša hitrost povezave dostopne točke."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Drugim napravam pomaga najti to dostopno točko. Poveča porabo energije baterije."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Hitrost in združljivost"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6727230647098551051">"2,4 GHz / Poljubna naprava se lahko poveže"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="5009644494425227175">"5 GHz / Večina naprav se lahko poveže"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="1504496768686645945">"6 GHz / Nekatere naprave se lahko povežejo"</string>
    <string name="wifi_hotspot_speed_2g_and_5g_summary" msgid="2392283008301109037">"2,4 in 5 GHz / Poljubna naprava se lahko poveže"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Vklop dostopne točke  ..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Izklop dostopne točke ..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Internetna povezava prek mobilnega telefona ni na voljo"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Za podrobnejše informacije se obrnite na operaterja."</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"Povezava <xliff:g id="NETWORK_SSID">%1$s</xliff:g> je aktivna"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Želite shraniti to omrežje?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Shranjevanje …"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Shranjeno"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Ni mogoče shraniti. Poskusite znova."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Želite shraniti omrežja?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Shranjevanje toliko omrežij: <xliff:g id="NUMBER">%d</xliff:g> …"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Shranjena omrežja"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Klicanje prek Wi-Fi-ja"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Razširite območje klicanja s povezavo Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Vklopite klicanje prek Wi‑Fi-ja, da povečate pokritost"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Nastavitev klicanja"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Nastavitev klicanja"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Prednostna izbira za gostovanje"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Prednostna izbira za gostovanje"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mobilno"</item>
    <item msgid="3027927219952052398">"Samo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Mobilno"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Uporaba mobilnega omrežja, če omrežje Wi-Fi ni dosegljivo"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Uporaba omrežja Wi-Fi, če mobilno omrežje ni dosegljivo"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Klic prek omrežja Wi-Fi. Če izgubite povezavo Wi-Fi, bo klic končan."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Ko je vklopljeno klicanje prek omrežja Wi-Fi, lahko telefon preusmeri klice prek omrežij Wi-Fi ali omrežja operaterja na podlagi vaše nastavitve in moči signala. Pred vklopom te funkcije pri operaterju preverite cene in druge podrobnosti.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Naslov za nujne primere"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Uporabljen je kot vaš naslov, ko opravite klic v sili prek Wi‑Fi-ja"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Preberite več"</annotation>" o funkcijah zasebnega strežnika DNS."</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Vklopljeno"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivirajte klicanje prek Wi-Fi-ja"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Vklopite klicanje prek Wi-Fi-ja"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Povezava z omrežjem <xliff:g id="SSID">%1$s</xliff:g> je prekinjena"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Zvok in vibriranje"</string>
    <string name="account_settings" msgid="255404935489127404">"Računi"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Računi za delovne profile – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Računi za osebne profile"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Delovni račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Osebni račun – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Iskanje"</string>
    <string name="display_settings" msgid="7197750639709493852">"Zaslon"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Samodejni zasuk zaslona"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Izklopljeno"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Vklopljeno"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Vklopljeno – na podlagi obraza"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Zaznavanje obraza"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Več o samodejnem zasuku"</string>
    <string name="auto_rotate_summary_a11y" msgid="1505094100328581685">"Ko telefon obrnete iz navpičnega v vodoravni položaj ali obratno."</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Ločljivost zaslona"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Visoka ločljivost"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Polna ločljivost"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Za polno ločljivost se porablja več energije baterije. Ob spremembi ločljivosti se bodo morda nekatere aplikacije znova zagnale."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Izbrano"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Barve"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Naravne"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Poudarjene"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Nasičene"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Prilagodljive"</string>
    <string name="brightness" msgid="6216871641021779698">"Raven svetlosti"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Prilagodljiva svetlost"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Svetlost zaslona se bo samodejno prilagajala glede na okolje in dejavnosti. Če želite, da funkcija za prilagodljivo svetlost hitreje spozna vaše želje, lahko ročno premaknete drsnik."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Vklopljeno"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Izklopljeno"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Prikaz ravnovesja beline"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Tekoč prikaz"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Samodejno povečanje hitrosti osveževanja s 60 na <xliff:g id="ID_1">%1$s</xliff:g> Hz za nekatere vsebine. Poveča porabo energije baterije."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Vsili največjo hitrost osveževanja"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Višja hitrost osveževanja za izboljšano odzivnost na dotik in kakovost animacij. Povečana poraba energije baterije."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Zaznavanje pogleda na zaslon"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Potreben je dostop do fotoaparata"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Za zaznavanje pogleda na zaslon je potreben dostop do fotoaparata. Dotaknite se, če želite upravljati dovoljenja za storitve osebnega prilagajanja naprave."</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Upravljanje dovoljenj"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Preprečuje, da bi se zaslon izklopil, če ga gledate."</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Funkcija zaznavanja pogleda na zaslon uporablja sprednji fotoaparat, da zazna, ali kdo gleda zaslon. Funkcija se izvaja v napravi, slike pa se v nobenem primeru ne shranijo in ne pošiljajo Googlu."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Vklop zaznavanja pogleda na zaslon"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Ko gledate zaslon, naj ostane vklopljen"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Fotoaparat je zaklenjen."</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Za zaznavanje obraza mora biti fotoaparat odklenjen."</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Za zaznavanje pogleda na zaslon mora biti fotoaparat odklenjen."</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Za zaznavanje obraza je potreben dostop do fotoaparata. Dotaknite se, če želite upravljati dovoljenja za storitve osebnega prilagajanja naprave."</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Upravljanje dovoljenj"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nočna svetloba"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Nočna svetloba zaslon obarva z jantarnim odtenkom. To olajša gledanje na zaslon ali branje pri šibki svetlobi in vam lahko pomaga prej zaspati."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Razpored"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Brez"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Vklop ob poljubni uri"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Vklop od sončn. zahoda do vzhoda"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Začetni čas"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Končni čas"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intenzivnost"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Brez samodejnega vklopa"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Samodejni vklop ob <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Samodejni vklop ob sončnem zahodu"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Brez samodejnega izklopa"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Samodejni izklop ob <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Samodejni izklop ob sončnem vzhodu"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nočna svetloba je izklopljena"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Lokacija naprave je potrebna za določanje časa sončnega zahoda in vzhoda na vaši lokaciji."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Nastavitve lokacije"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Vklopi zdaj"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Izklopi zdaj"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Vklopi do sončnega vzhoda"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Izklopi do sončnega zahoda"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Temni način"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Razpored"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Brez"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Vklop od sončn. zahoda do vzhoda"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Vklop ob poljubni uri"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Vklopi se ob času za spanje"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Stanje"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Brez samodejnega vklopa"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Samodejni vklop ob sončnem zahodu"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Samodejni vklop ob <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Samodejno se vklopi ob času za spanje."</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Brez samodejnega izklopa"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Samodejni izklop ob sončnem vzhodu"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Samodejni izklop ob <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Samodejno se izklopi po času za spanje."</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Temna tema s črnim ozadjem podaljša čas delovanja baterije na nekaterih zaslonih. Razporedi temne teme z vklopom počakajo, dokler se zaslon ne izklopi."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Temna tema trenutno sledi razporedu načina za spanje."</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Nastavitve načina za spanje"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Časovna omejitev za zaslon"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Po toliko časa nedejavnosti: <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g>"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Ni nastavljeno"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Ozadje"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Zaslonsko ozadje in slog"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Začetni zaslon, zaklenjen zaslon"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Spremenite ozadje"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Prilagajanje zaslona"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Izberite ozadje iz"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Prilagajanje telefona"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Preizkusite različne sloge, ozadja in drugo"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Ohranjevalnik zaslona"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"ohranjevalnik zaslona"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Ni na voljo, ker je vklopljen način za spanje."</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Uporabi ohranjevalnik zaslona"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Med polnjenjem ali v stojalu"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"V stojalu in med polnjenjem"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Med polnjenjem"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Ko je v stojalu"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nikoli"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Vklopljeno/<xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Izklopljeno"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Kdaj naj se zažene"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Preklop iz stanja pripravlj. z dviganjem"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Prikaz na podlagi okolja"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kdaj naj se prikaže"</string>
    <string name="doze_title" msgid="1523090408230862316">"Prebudi zaslon ob obvestilih"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Ko zaslon ni osvetljen, se vklopi ob novih obvestilih."</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Vedno pokaži uro in informacije"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Poveča porabo baterije"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Krepko besedilo"</string>
    <string name="title_font_size" msgid="570613010306330622">"Velikost pisave"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Povečava ali pomanjšava besedila"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Nastavitve zaklepanja kartice SIM"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Zaklepanje kartice SIM"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Zakleni kartico SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Spremeni kodo PIN kartice SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"Koda PIN za kartico SIM"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Zakleni kartico SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Odkleni kartico SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Stara koda PIN za kartico SIM"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nova koda PIN za kartico SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Znova vnesite novi PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"Koda PIN za kartico SIM"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Vnesite od 4- do 8-mestno kodo PIN."</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Kodi PIN se ne ujemata"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"Sprememba kode PIN za kartico SIM je uspela"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Kode PIN ni mogoče onemogočiti."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Kode PIN ni mogoče omogočiti."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"V redu"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Prekliči"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Želite za mobilne podatke uporabiti <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Za prenos podatkov v mobilnem omrežju uporabljate operaterja <xliff:g id="CARRIER2_0">%2$s</xliff:g>. Če preklopite na operaterja <xliff:g id="CARRIER1">%1$s</xliff:g>, operaterja <xliff:g id="CARRIER2_1">%2$s</xliff:g> ne boste več uporabljali za prenos podatkov v mobilnem omrežju."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Uporabi operaterja <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Želite posodobiti prednostno kartico SIM?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<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="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Izboljšava prenosa mobilnih podatkov?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Napravi dovolite, da za prenos podatkov v mobilnem omrežju samodejno preklopi na operaterja <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g>, kadar ima ta boljšo razpoložljivost."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Klici, sporočila in omrežni promet so lahko vidni vaši organizaciji."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Napačna koda PIN kartice SIM. Zdaj se boste morali za odklenitev naprave obrniti na operaterja."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Napačna koda PIN kartice SIM. Na voljo imate še # poskus. Nato se boste morali za odklepanje naprave obrniti na operaterja.}one{Napačna koda PIN kartice SIM. Na voljo imate še # poskus.}two{Napačna koda PIN kartice SIM. Na voljo imate še # poskusa.}few{Napačna koda PIN kartice SIM. Na voljo imate še # poskuse.}other{Napačna koda PIN kartice SIM. Na voljo imate še # poskusov.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Napačna koda PIN kartice SIM. Na voljo imate še en poskus. Nato se boste morali za odklepanje naprave obrniti na operaterja."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Postopek za odklepanje s kodo PIN kartice SIM ni uspel."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Sistemske posodobitve"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Različica sistema Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Varnostna posodobitev za Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Različica strojne opreme"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID opreme"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Različica radijske programske opreme"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Različica jedra"</string>
    <string name="build_number" msgid="9009733242117579826">"Delovna različica"</string>
    <string name="module_version" msgid="1787518340082046658">"Posodobitev sistema prek Googla Play"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Ni na voljo"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Shramba"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Shramba in predpomnilnik"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Nastavitve shrambe"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (reža za kartico SIM <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (reža za kartico SIM <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (reža za kartico SIM <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (glavna)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Za ogled izberite shranjeno omrežje."</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Različica seznama prednostnih omrežij za gostovanje"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (reža za kartico SIM <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (reža za kartico SIM <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (glavna)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Vklopljeno"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Izklopljeno"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Vrsta mobilnega omrežja za prenos podatkov"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Vrsta mobilnega omrežja za glasovni klic"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Podatki operaterja"</string>
    <string name="status_data_state" msgid="525196229491743487">"Stanje mobilnega omrežja"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Stanje storitve"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Moč signala"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Gostovanje"</string>
    <string name="status_operator" msgid="4335640583552058491">"Omrežje"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Naslov MAC vmesnika Wi‑Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Naslov MAC vmesnika Wi‑Fi naprave"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Naslov Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Serijska številka"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Čas delovanja"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Izračunavanje ..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Preimenuj"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Vpenjanje"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Izvrzi"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatiraj kartico SD kot prenosno shrambo"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatiraj kartico"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatiraj kot prenosno shram."</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatiraj"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Preseli podatke"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Pozabi"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Nastavi"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Sprostitev prostora"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Upravljanje shrambe"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Sprostite prostor"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Pojdite v aplikacijo Datoteke in sprostite prostor."</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Drugi uporabniki"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"Vpeto: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Tega ni bilo mogoče vpeti: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"To je varno izvrženo: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Tega ni bilo mogoče varno izvreči: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Preimenovanje shrambe"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"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_internal_format_details" msgid="2399034372813686846">"To kartico SD lahko formatirate, da boste lahko nanjo shranjevali fotografije, videoposnetke, glasbo in drugo vsebino ter do nje dostopali v drugih napravah. \n\n"<b>"Vsi podatki na tej kartici SD bodo izbrisani."</b>" \n\n"<b>"Pred formatiranjem"</b>" \n\n"<b>"Varnostno kopirajte fotografije in drugo predstavnost."</b>" \nPredstavnostne datoteke premaknite v drugo shrambo v tej napravi ali pa jih prek kabla USB prenesite v računalnik. \n\n"<b>"Varnostno kopirajte aplikacije."</b>" \nVse aplikacije, shranjene v tej shrambi <xliff:g id="NAME">^1</xliff:g>, bodo odmeščene, njihovi podatki pa bodo izbrisani. Če želite obdržati te aplikacije, jih premaknite v drugo shrambo v tej napravi."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><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="5606507270046186691">"Č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="379238668153099015">"Opustitev naprave za shr. <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"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_dialog_system" msgid="7461009051858709479">"Sistem vključuje datoteke, ki se uporabljajo za izvajanje Androida različice <xliff:g id="VERSION">%s</xliff:g>."</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Uporabniki načina za goste ne morejo formatirati kartic SD."</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formatiranje shrambe <xliff:g id="NAME">^1</xliff:g> …"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Med formatiranjem ne odstranite nosilca <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"Shramba <xliff:g id="NAME">^1</xliff:g> je bila formatirana"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Premik aplikacije <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Premik aplikacije <xliff:g id="APP">^1</xliff:g> in njenih podatkov v shrambo <xliff:g id="NAME_0">^2</xliff:g> bo trajal samo nekaj trenutkov. Dokler premik ne bo dokončan, aplikacije ne bo mogoče uporabljati. \n\nShrambe <xliff:g id="NAME_1">^2</xliff:g> med premikanjem ne odstranite."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Če želite premakniti podatke, morate odkleniti uporabnika <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Premikanje aplikacije <xliff:g id="APP">^1</xliff:g> …"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"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_init_v2_title" msgid="2538630338392381113">"Kako želite uporabljati nosilec <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"ali"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formatiranje kartice SD kot prenosne shrambe"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Shranite fotografije, videoposnetke, glasbo in drugo vsebino ter dostopajte do nje iz drugih naprav. &lt;a href=https://support.google.com/android/answer/12153449&gt;Preberite več o nastavljanju kartice SD.&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatiraj"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Nastavi pozneje"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Želite formatirati to shrambo <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Če želite shranjevati aplikacije, datoteke in predstavnost, morate shrambo <xliff:g id="NAME_0">^1</xliff:g> formatirati. \n\nS formatiranjem boste izbrisali obstoječo vsebino v shrambi <xliff:g id="NAME_1">^2</xliff:g>. Da bi se izognili izgubi vsebine, jo varnostno kopirajte v drugo shrambo <xliff:g id="NAME_2">^3</xliff:g> ali napravo."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"To shrambo <xliff:g id="NAME_0">^1</xliff:g> je treba formatirati, da boste lahko vanjo shranjevali fotografije, videoposnetke, glasbo in drugo vsebino. \n\nS formatiranjem boste izbrisali obstoječo vsebino v shrambi <xliff:g id="NAME_1">^2</xliff:g>. Da bi se izognili izgubi vsebine, jo varnostno kopirajte v drugo shrambo <xliff:g id="NAME_2">^3</xliff:g> ali napravo."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatiraj <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Želite premakniti vsebino v nos. <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Med premikanjem:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Ne odstranite nosilca <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Nekatere aplikacije ne bodo delovale"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Premakni vsebino"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Premakni vsebino pozneje"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Premikanje vsebine …"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Počasna naprava za shranjevanje <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Nosilec <xliff:g id="NAME_0">^1</xliff:g> lahko še vedno uporabljate, vendar bo morda počasen. \n\nAplikacije, shranjene v nosilcu <xliff:g id="NAME_1">^2</xliff:g>, morda ne bodo pravilno delovale, prenos vsebine pa bo morda dolgotrajen. \n\nPoskusite uporabiti hitrejši nosilec <xliff:g id="NAME_2">^3</xliff:g> ali pa nosilec <xliff:g id="NAME_3">^4</xliff:g> uporabite kot prenosno shrambo."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Začni znova"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Naprej"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Shrambo <xliff:g id="NAME">^1</xliff:g> lahko začnete uporabljati"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Shrambo <xliff:g id="NAME">^1</xliff:g> lahko začnete uporabljati"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Shrambo <xliff:g id="NAME">^1</xliff:g> lahko začnete uporabljati"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Stanje baterije"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Raven napolnjenosti baterije"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Skupno"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Skupne nastavitve"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN-ji"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Urejanje dostopne točke"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Ni nastavljeno"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Ni nastavljeno"</string>
    <string name="apn_name" msgid="6677695784108157953">"Ime"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Strežnik proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Vrata"</string>
    <string name="apn_user" msgid="5831763936428279228">"Uporabniško ime"</string>
    <string name="apn_password" msgid="7435086635953953029">"Geslo"</string>
    <string name="apn_server" msgid="6997704279138388384">"Strežnik"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"Storitveni center za sporočila MMS"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Strežnik proxy za sporočila MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Vrata MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"Mobilna koda države"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"Koda mobilnega omrežja"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Vrsta preverjanja pristnosti"</string>
    <string name="apn_type" msgid="1835573305077788773">"Vrsta APN-ja"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protokol APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protokol APN za gostovanje"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Omogoči/onemogoči APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN omogočen"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN onemogočen"</string>
    <string name="bearer" msgid="3231443241639159358">"Nosilec"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Vrsta MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Vrednost MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Izbriši APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nov APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Shrani"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Prekliči"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Polje z imenom ne sme biti prazno."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN ne sme biti prazen."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Polje z mobilno kodo države mora vsebovati 3 števke."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Polje s kodo mobilnega omrežja mora vsebovati 2 ali 3 števke."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operater ne podpira dodajanja APN-jev vrste %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Obnavljanje privzetih nastavitev APN-jev"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Ponastavi na privzeto"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Ponastavitev privzetih nastavitev APN-jev končana"</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Možnosti ponastavitve"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Ponastavi nastavitve mobilnega omrežja"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"S tem boste ponastavili vse nastavitve mobilnega omrežja."</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Želite ponastaviti nastavitve mobilnega omrežja?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Ponastavitev Bluetootha in Wi‑Fi-ja"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"S tem boste ponastavili vse nastavitve za Wi‑Fi in Bluetooth. Tega dejanja ni mogoče razveljaviti."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Ponastavi"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth in Wi‑Fi sta bila ponastavljena."</string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Izbriši"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Izbriši kartice e-SIM"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"S tem ne boste prekinili nobenega naročniškega paketa za mobilno telefonijo. Če želite prenesti nadomestne kartice SIM, se obrnite na operaterja."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Ponastavi nastavitve"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Želite ponastaviti vse omrežne nastavitve? Tega dejanja ni mogoče razveljaviti."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Želite ponastaviti vse omrežne nastavitve in izbrisati kartice e-SIM? Tega dejanja ni mogoče razveljaviti."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Ponastavi nastavitve"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Želite ponastaviti?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Ponastavitev omrežnih nastavitev ni na voljo za tega uporabnika"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Omrežne nastavitve so ponastavljene"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Kartic SIM ni mogoče izbrisati"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"Kartic e-SIM ni mogoče izbrisati zaradi napake.\n\nZnova zaženite napravo in poskusite znova."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Izbris vseh podatkov (tovarniška ponastavitev)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Izbriši vse podatke (tov. po.)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"glasbo"</li>\n<li>"fotografije"</li>\n<li>"druge uporabniške podatke"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"Digitalne kartice e-SIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"S tem ne boste prekinili naročniškega paketa za mobilno telefonijo."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Vsi osebni podatki in prenesene aplikacije bodo izbrisani. Tega dejanja ni mogoče razveljaviti."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Izbrisani bodo vsi osebni podatki, vključno s prenesenimi aplikacijami in karticami SIM. Tega dejanja ni mogoče razveljaviti."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Želite izbrisati vse podatke?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Ponastavitev na tovarniške nastavitve ni na voljo za tega uporabnika"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Brisanje"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Počakajte …"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Nastavitve klicanja"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Nastavite telefonski predal, preusmeritev klicev, čakajoči klic, ID klicatelja"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Internet prek USB-ja"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Prenosna dostopna točka"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Internet prek Bluetootha"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Internet prek mob. napr."</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Dostopna točka in deljenje mobilnega interneta"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Dostopna točka je vklopljena, internetna povezava prek telefona"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Dostopna točka je vklopljena"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Internetna povezava prek telefona"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"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="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Samo dostopna točka"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Samo USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Samo Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Samo ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Dostopna točka, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Dostopna točka, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Dostopna točka, ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Dostopna točka, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Dostopna točka, USB, ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Dostopna točka, Bluetooth, ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Dostopna točka, USB, Bluetooth, ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internetna povezava ni deljena z drugimi napravami"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Izklopljeno"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Internetna povezava prek mobilnega telefona"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Brez uporabe dostopne točke Wi‑Fi"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Deljenje internetne povezave samo prek USB-ja"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Deljenje internetne povezave samo prek Bluetootha"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Deljenje internetne povezave samo prek etherneta"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Deljenje internetne povezave samo prek USB-ja in Bluetootha"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Deljenje internetne povezave samo prek USB-ja in etherneta"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Deljenje internetne povezave samo prek Bluetootha in etherneta"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Deljenje internetne povezave samo prek USB-ja, Bluetootha in etherneta"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Internet prek USB-ja"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Internet prek Bluetootha"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Internet prek etherneta"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Uporabite dostopno točko in povezavo z internetom prek mobilnega telefona, da zagotovite internet drugim napravam prek svoje mobilne podatkovne povezave. Tudi aplikacije lahko ustvarijo dostopno točko za deljenje vsebin z napravami v bližini."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Uporabite dostopno točko in povezavo z internetom prek mobilnega telefona, da zagotovite internet drugim napravam prek Wi-Fi-ja ali mobilne podatkovne povezave. Tudi aplikacije lahko ustvarijo dostopno točko za deljenje vsebin z napravami v bližini."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Pomoč"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilno omrežje"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Naročniški paket za mobilno napravo"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplikacija za SMS-je"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Ali želite zamenjati aplikacijo za sporočila SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"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="6215622785087181275">"Ali želite za SMS-e uporabljati aplikacijo <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Želite zamenjati Pomočnika za Wi‑Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Ž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="680685773455072321">"Želite za upravljanje omrežnih povezav uporabljati aplikacijo <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Neznan ponudnik kartice SIM"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> nima znanega splet. mesta za omogočanje uporabe"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Vstavite SIM in znova zaženite"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Vzpostavite internetno povezavo"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nedavne zahteve za lokacijo"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokacija za delovni profil"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Dovoljenja aplikacij za lokacijo"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Zaznavanje lokacije je izklopljeno."</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{Dostop do lokacije ima # aplikacija od {total}.}one{Dostop do lokacije ima # aplikacija od {total}.}two{Dostop do lokacije imata # aplikaciji od {total}.}few{Dostop do lokacije imajo # aplikacije od {total}.}other{Dostop do lokacije ima # aplikacij od {total}.}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Nedavni dostop"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Prikaz vseh"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Ogled podrobnosti"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"V zadnjem času ni nobena aplikacija zahtevala lokacijskih podatkov."</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Nobena aplikacija ni nedavno dostopala do lokacije."</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Visoka poraba baterije"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Nizka poraba baterije"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Iskanje omrežij Wi‑Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Aplikacijam in storitvam omogoči, da kadar koli iščejo omrežja Wi-Fi, tudi ko je Wi-Fi izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Iskanje naprav Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Aplikacijam in storitvam omogoči, da kadar koli iščejo naprave v bližini, tudi ko je Bluetooth izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Lokacijske storitve"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Lokacijske storitve"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Uporabi lokacijo"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Samodejna nastavitev časovnega pasu ni mogoča"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"Izklopljena lokacija ali izklopljene lokacijske storitve"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Potrebno je dovoljenje za lokacijo naprave"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Če želite nastaviti časovni pas na podlagi lokacije, vklopite lokacijo in nato posodobite nastavitve časovnega pasu."</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Nastavitve lokacije"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Popravi"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Prekliči"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Samodejno nastavljanje časovnega pasu je izklopljeno."</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Uporaba lokacije za zaznavanje časovnega pasu je onemogočeno"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Uporaba lokacije za zaznavanje časovnega pasu ni podprta"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Spremembe uporabe lokacije za zaznavanje časovnega pasu niso dovoljene"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Lokacija se lahko uporabi za nastavitev časovnega pasu."</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Ogled pravnih informacij, stanja, različice programske opreme"</string>
    <string name="legal_information" msgid="7509900979811934843">"Pravne informacije"</string>
    <string name="manual" msgid="3651593989906084868">"Ročno"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Zakonsko predpisane oznake"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Varnostne in zakonsko predpisane inform."</string>
    <string name="copyright_title" msgid="83245306827757857">"Avtorska pravica"</string>
    <string name="license_title" msgid="8745742085916617540">"Licenca"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licence za posodobitev sistema prek Googla Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Določila in pogoji"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licenca za WebView v sistemu"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Ustvarjalci ozadij"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Ponudniki satelitskih posnetkov: \n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Priročnik"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Težava pri nalaganju priročnika."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licence drugih ponudnikov"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Pri nalaganju licenc je prišlo do težave."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Nalaganje …"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Nalaganje …"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Nastavite geslo"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Nastavitev gesla za službo"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Nastavite kodo PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Nastavitev kode PIN za službo"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Nastavite vzorec"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Za večjo varnost nastavite vzorec za odklepanje naprave."</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Nastavitev vzorca za službo"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Nastavite geslo za prstni odtis"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Nastavite vzorec za prstni odtis"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Zaradi varnosti nastavite kodo PIN."</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Nastavite kodo PIN za prstni odtis"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Znova vnesite geslo"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Znova vnesite geslo za službo"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Vnesite geslo za delovni profil"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Potrdite vzorec"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Vnesite vzorec za del. profil"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Znova vnesite kodo PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Znova vnesite kodo PIN za službo"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Vnesite kodo PIN za delovni profil"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Gesli se ne ujemata"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Kodi PIN se ne ujemata"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Znova narišite vzorec"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Izbira načina odklepanja"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Geslo je nastavljeno"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Koda PIN je nastavljena"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Vzorec je nastavljen"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Za odklepanje z obrazom nastavite geslo"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Za odklepanje z obrazom nastavite vzorec"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Za odklepanje z obrazom nastavite PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Nastavite geslo za uporabo obraza ali prstnega odtisa"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Nastavite vzorec za uporabo obraza ali prstnega odtisa"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Nastavite kodo PIN za uporabo obraza ali prstnega odtisa"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Ste pozabili geslo?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Ste pozabili vzorec?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Ste pozabili svoj PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Za nadaljevanje uporabite vzorec za odklepanje naprave"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Za nadaljevanje vnesite kodo PIN za napravo"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Če želite nadaljevati, vnesite geslo za napravo"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Če želite nadaljevati, uporabite vzorec za delovni profil"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Za nadaljevanje vnesite kodo PIN za delovni profil"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Če želite nadaljevati, vnesite geslo za delovni profil"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Zaradi večje varnosti vnesite vzorec za to napravo"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Zaradi večje varnosti vnesite kodo PIN za to napravo"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Zaradi večje varnosti vnesite geslo za to napravo"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Zaradi večje varnosti vnesite vzorec za delovni profil"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Zaradi večje varnosti vnesite kodo PIN za delovni profil"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Zaradi večje varnosti vnesite geslo za delovni profil"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Potrdite vzorec"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Potrdite PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Potrdite geslo"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Preverjanje identitete"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Če želite prenesti račune Google, nastavitve in druge podatke, vnesite vzorec druge naprave. Vzorec je šifriran."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Če želite prenesti račune Google, nastavitve in druge podatke, vnesite kodo PIN druge naprave. Koda PIN je šifrirana."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Če želite prenesti račune Google, nastavitve in druge podatke, vnesite geslo druge naprave. Geslo je šifrirano."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Ta naprava se lahko odklepa tudi z vzorcem"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Ta naprava se lahko odklepa tudi s kodo PIN"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Ta naprava se lahko odklepa tudi z geslom"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Napačna koda PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Napačno geslo"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Napačen vzorec"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Nujni primer"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Varnost naprave"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Spremeni vzorec za odklepanje"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Spremeni kodo PIN za odklepanje"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Narišite vzorec za odklepanje."</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Če želite pomoč, pritisnite meni."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Ko končate, dvignite prst."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Povežite vsaj toliko pik: <xliff:g id="NUMBER">%d</xliff:g>. Poskusite znova."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Vzorec je shranjen."</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Znova narišite vzorec, da ga potrdite."</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Novi vzorec za odklepanje"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Potrdi"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Ponovno nariši"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Izbriši"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Naprej"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Vzorec za odklepanje"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Zahtevaj vzorec"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Za odklepanje zaslona je treba narisati vzorec"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Vzorec naj bo viden"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Izboljšana zasebnost pri uporabi kode PIN"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Onemogoči animacije med vnašanjem kode PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Vzorec za profil naj bo viden"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibriranje ob dotiku"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Zaklepanje z vklopnim gumbom"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"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="2193588309557281466">"Nastavi vzorec za odklepanje"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Spremeni vzorec za odklepanje"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kako narisati vzorec za odklepanje"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Preveč napačnih poskusov. Poskusite znova čez <xliff:g id="NUMBER">%d</xliff:g> s."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplikacija ni nameščena v telefonu."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Varnost delovnega profila"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Zaklepanje zaslona za delovni profil"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Uporabi eno zaklepanje"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Uporabljajte eno zaklepanje za delovni profil in zaslon naprave."</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Želite uporabljati eno zaklepanje?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"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="8844682343443755895">"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="6276915393736137843">"Uporabi eno zaklepanje"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Uporabi eno zaklepanje"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Enako kot zaklepanje zaslona naprave"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Upravljaj aplikacije"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Podatki o aplikaciji"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Nastavitve aplikacij"</string>
    <string name="install_applications" msgid="3921609656584369901">"Neznani viri"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Dovoli vse vire aplikacij"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Nedavno odprte aplikacije"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Prikaz vseh aplikacij}one{Prikaz vseh aplikacij (#)}two{Prikaz vseh aplikacij (#)}few{Prikaz vseh aplikacij (#)}other{Prikaz vseh aplikacij (#)}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Obrnite se na skrbnika za IT"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Lahko vam pomaga ponastaviti kodo PIN, vzorec ali geslo"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Dodatne nastavitve"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Omogoči več možnosti nastavitev."</string>
    <string name="application_info_label" msgid="1015706497694165866">"Podatki o aplikaciji"</string>
    <string name="storage_label" msgid="2522307545547515733">"Shramba"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Privzeto odpiranje"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Privzete nastavitve"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Združljivost zaslona"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Dovoljenja"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Predpomnilnik"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Počisti predpomnilnik"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Predpomnilnik"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 element}one{# element}two{# elementa}few{# elementi}other{# elementov}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Počisti dostop"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontrolniki"</string>
    <string name="force_stop" msgid="2681771622136916280">"Prisilno ustavi"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Skupaj"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Velikost aplikacije"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplikacija na pogonu USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Uporabniški podatki"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Odmesti"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Odstrani za vse uporabnike"</string>
    <string name="install_text" msgid="4558333621516996473">"Namesti"</string>
    <string name="disable_text" msgid="5146002260857428005">"Onemogoči"</string>
    <string name="enable_text" msgid="8570798764647110430">"Omogoči"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Počisti shrambo"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Odmesti posodobitve"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Dovoli omejene nastavitve"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Nekatere dejavnosti, ki ste jih izbrali, se privzeto odprejo v tej aplikaciji."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Aplikaciji dovolite, da ustvari pripomočke in dostopa do njihovih podatkov."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Ni privzetih nastavitev."</string>
    <string name="clear_activities" msgid="488089228657585700">"Počisti privzete nastavitve"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Ta aplikacija morda ni namenjena za vaš zaslon. Tu lahko nastavite način prilagajanja zaslonu."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Vprašaj, ko se zažene"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Upravljanje aplikacij"</string>
    <string name="unknown" msgid="8192160131923461175">"Neznano"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Razvrsti po imenu"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Razvrsti po velikosti"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Najnovejše"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Najpogostejše"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Pokaži storitve, ki se izvajajo"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Pokaži predpom. procese"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplikacija v sili"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Ponastavitev nastavitev aplikacij"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Želite ponastaviti nastavitve aplikacij?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"S tem bodo ponastavljene vse nastavitve za:\n\n"<li>"onemogočene aplikacije,"</li>\n<li>"onemogočena obvestila aplikacij,"</li>\n<li>"privzete aplikacije za dejanja,"</li>\n<li>"omejitev prenosa podatkov v ozadju za aplikacije,"</li>\n<li>"omejitve dovoljenj,"</li>\n<li>"porabo energije baterije."</li>\n\n"Podatkov iz aplikacij ne boste izgubili."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Ponastavi aplikacije"</string>
    <string name="filter" msgid="9039576690686251462">"Filtriraj"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Izberite možnosti filtriranja"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Vse aplikacije"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Onemogočene aplikacije"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Preneseno"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Se izvaja"</string>
    <string name="not_installed" msgid="5074606858798519449">"Ni namešč. za tega uporabnika"</string>
    <string name="installed" msgid="2837449358488825884">"Nameščeno"</string>
    <string name="no_applications" msgid="985069304755391640">"Ni aplikacij."</string>
    <string name="internal_storage" msgid="999496851424448809">"Notranja shramba"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Preračunavanje velikosti ..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Želite izbrisati podatke aplikacije?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Podatki te aplikacije, vključno z datotekami in nastavitvami, bodo trajno izbrisani iz te naprave."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"V redu"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Prekliči"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Izbriši"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplikacije ni bilo mogoče najti na seznamu nameščenih aplikacij."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Shrambe za aplikacijo ni bilo mogoče počistiti."</string>
    <string name="computing_size" msgid="4915310659841174866">"Izračunavanje ..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Velikosti paketa ni bilo mogoče izračunati."</string>
    <string name="version_text" msgid="7628938665256107608">"različica <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Premakni"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Poteka že druga selitev."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Ni dovolj prostora za shranjevanje."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplikacija ne obstaja."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Mesto namestitve ni veljavno."</string>
    <string name="system_package" msgid="7559476279008519360">"Sistemskih posodobitev ni mogoče namestiti na zunanji medij."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Skrbniške aplikacije naprave ni mogoče namestiti na zunanji medij."</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Želite prisilno ustaviti?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Če boste vsilili zaustavitev aplikacije, morda ne bo pravilno delovala."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Onemogočanje aplikacije"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Če onemogočite to aplikacijo, Android in druge aplikacije morda ne bodo več delovali, kot bi morali. Upoštevajte, da te aplikacije ni mogoče izbrisati, ker je bila vnaprej nameščena v napravi. Če jo onemogočite, jo boste izklopili in skrili v napravi."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Trgovina"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Podrobnosti o aplikaciji"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplikacija je nameščena iz trgovine <xliff:g id="APP_STORE">%1$s</xliff:g>."</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Več informacij v trgovini <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Se izvaja"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nikoli uporabljeno)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Uporaba pomnilnika"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Ponovno zaganjanje"</string>
    <string name="cached" msgid="5379485147573438201">"Predpomnjeni procesi v ozadju"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nič se ne izvaja."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Zagnala aplikacija."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Prosto: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"V uporabi: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Uporabnik: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Odstranjen uporabnik"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<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="1209371773353932361">"<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="8957061449107822282">"<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="3292999232897469679">"Š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="558961782589967366">"Pomnilnik naprave"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Poraba RAM-a za aplikacije"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplikacije"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Prosto"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Uporabljeno"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Predpomnjeno"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM-a"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aplikacija, ki se izvaja"</string>
    <string name="no_services" msgid="3898812785511572899">"Nedejavno"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Storitve"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesi"</string>
    <string name="service_stop" msgid="5712522600201308795">"Ustavi"</string>
    <string name="service_manage" msgid="3896322986828332075">"Nastavitve"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"To storitev je zagnala aplikacija. Če jo ustavite, aplikacija morda ne bo delovala."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Aplikacije ni mogoče varno ustaviti. Če jo ustavite, boste morda izgubili nekaj svojega trenutnega dela."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"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="6615788996428486121">"<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="6685973937935027773">"Glavni proces je v uporabi."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Storitev <xliff:g id="COMP_NAME">%1$s</xliff:g> je v uporabi."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Ponudnik <xliff:g id="COMP_NAME">%1$s</xliff:g> je v uporabi."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Želite ustaviti sistemsko storitev?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Jeziki, vnos in poteze"</string>
    <string name="language_settings" msgid="8700174277543875046">"Jeziki in vnos"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Jeziki"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Tipkovnica"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nimate dovoljenja za spreminjanje jezika naprave."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Jeziki in vnos"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Orodja"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tipkovnica in načini vnosa"</string>
    <string name="system_language" msgid="1146762166579643257">"Sistemski jeziki"</string>
    <string name="phone_language" msgid="5986939176239963826">"Jeziki"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Samodejno zamenjaj"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Popravi napačno natipkane besede"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Samodejna uporaba velikih začetnic"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Uporaba velike začetnice za prvo črko v stavku"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Samodejno vstavljanje ločil"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Nastavitve fizične tipkovnice"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Dvakrat pritisnite preslednico, da vnesete ».«"</string>
    <string name="show_password" msgid="7101900779571040117">"Pokaži gesla"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Za trenutek prikaži znake med vnašanjem."</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"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="6449414356743946577">"Nastavitve"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Jezik"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tipkovnice"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Zaslonska tipkovnica"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Razpoložljiva zaslonska tipkovnica"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Upravljaj zaslonske tipkovnice"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Možnosti"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fizična tipkovnica"</string>
    <string name="show_ime" msgid="4334255501724746849">"Uporabi zaslonsko tipkovnico"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Obdrži na zaslonu, tudi ko je fizična tipkovnica aktivna."</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Bližnjične tipke"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Prikaz seznama bližnjic"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tipkovnice in orodja delovnega profila"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Zaslonska tipkovnica za delo"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Privzeto"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Sledilna ploščica"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Sledilna ploščica in miška"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Hitrost kazalca, poteze"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Dotik za klik"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Poteze na sledilni ploščici"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Prilagajanje potez za krmarjenje na sledilni ploščici"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Obratno pomikanje"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Pri pomikanju drsnika navzdol se vsebina premika navzgor"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Dotik spodnjega desnega kota"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Za več možnosti se dotaknite sledilne ploščice spodaj desno."</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Hitrost kazalca"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Učenje potez na sledilni ploščici"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Pomik na začetni zaslon"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"S tremi prsti povlecite navzgor po sledilni ploščici."</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Pomik nazaj"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"S tremi prsti povlecite v levo ali desno."</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Ogled nedavnih aplikacij"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"S tremi prsti povlecite navzgor, pridržite in spustite."</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Ogled obvestil in hitrih nastavitev"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"S tremi prsti povlecite navzdol po začetnem zaslonu."</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Preklop aplikacij"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"S štirimi prsti povlecite v levo ali desno."</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Preskoči"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Naprej"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Od začetka"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Končano"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Nazaj"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Vlečenje v levo ali desno s tremi prsti"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Pojdi na začetni zaslon"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Vlečenje navzgor s tremi prsti"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Nedavne aplikacije"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Vlečenje navzgor s tremi prsti in pridržanje"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Obvestila"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Vlečenje navzdol s tremi prsti"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Preklop aplikacij"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Vlečenje v levo ali desno s štirimi prsti"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modifikatorske tipke"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Spreminjanje načina delovanja tipk"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Ponastavi vse"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Privzeto"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Ali ste prepričani, da želite vse modifikatorske tipke ponastaviti na privzeto vrednost?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Končano"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Prekliči"</string>
    <string name="modifier_keys_restore" msgid="7627661630556839268">"Obnovi"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Izbira modifikatorske tipke"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Izberite novo tipko za »<xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>«:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Privzeto"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Govor"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Hitrost kazalca"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Krmilnik za igre"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Preusmeritev vibriranja"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Pošiljanje vibriranja v krmilnik za igre, ko je povezan"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Izbira razporeditve tipkovnice"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Nastavitev razporeditev tipkovnice"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Preklopite s Ctrl + preslednica"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Privzeto"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Razporeditve tipkovnice"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Postavitve fizične tipkovnice"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Osebni slovar"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Osebni slovar za službo"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Dodajte besede, ki naj bodo uporabljene v aplikacijah, kot je Preverjanje črkovanja."</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Dodaj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Dodajte v slovar"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Besedna zveza"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Več možnosti"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Manj možnosti"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"V redu"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Beseda:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Bližnjica:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Jezik:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Vnesite besedo"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Izbirna bližnjica"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Uredi besedo"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Uredi"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Izbriši"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"V uporabniškem slovarju ni besed. Če želite dodati besedo, se dotaknite gumba za dodajanje (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Za vse jezike"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Več jezikov ..."</string>
    <string name="testing" msgid="6294172343766732037">"Preizkušanje"</string>
    <string name="keyboard_settings_summary" msgid="2716339620942356432">"Zaslonska tipkovnica, govor, orodja"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="6628668004523183413">"Zaslonska tipkovnica, fizična tipkovnica, govor, orodja"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fizična tipkovnica"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Postavitev"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Izberi pripomoček"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Izberite pripomoček"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Želite ustvariti pripomoček in dovoliti dostop?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Ko ustvarite pripomoček, ima aplikacija dostop do vsega prikazanega.\n\nAplikacija: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nPripomoček: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Vedno dovoli, da <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> ustvari pripomočke in dostopa do njihovih podatkov"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Statistika uporabe"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Razvrsti po času uporabe"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Razvrsti po datumu zadnje uporabe"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Razvrsti po imenu aplikacije"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Zadnjič uporabljeno"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Čas uporabe"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Funkcije za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Nastavitve pripomočkov za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Prikaz, interakcija, zvok"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Nastavitve za slepe in slabovidne"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"To napravo lahko prilagodite svojim potrebam. Te funkcije za ljudi s posebnimi potrebami lahko pozneje spremenite v nastavitvah."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Spremenite velikost pisave"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Bralnik zaslona"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Podnapisi"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Zvok"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Splošno"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Zaslon"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Barva in gibanje"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Potemnitev zaslona"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Kontrolniki za interakcije"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Časovni kontrolniki"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Sistemski kontrolniki"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Prenesene aplikacije"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Poskusno"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Zastavice za funkcije"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtriranje dnevnika za zajem Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Nastavitev filtrov"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Za uveljavitev sprememb onemogočite in znova omogočite Bluetooth."</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Filtriranje dnevnika za zajem Bluetooth HCI – PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Filtriranje dnevnika za zajem Bluetooth HCI – MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Nastavitev načina filtriranja (Za uveljavitev sprememb onemogočite in znova omogočite Bluetooth.)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Za spremembo te možnosti nastavite način zapisovanja dnevnika za zajem Bluetooth HCI na »Omogočeno filtrirano«."</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Bralnik zaslona je predvsem za slepe in slabovidne."</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Če želite slišati vsebino elementov na zaslonu, se jih dotaknite."</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Nastavitve podnapisov"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"O nastavitvah podnapisov"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Preberite več o nastavitvah podnapisov."</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Povečava"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Bližnjica za povečavo"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Povečava tipkanja"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Povečevalnik zaslona sledi besedilu med tipkanjem."</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3738009998799304549">"Vedno vklopljeno"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="8946516092699010033">"Pri preklopu aplikacij se namesto deaktiviranja povečave preprosto izvede pomanjšava na običajno velikost. Razmaknite prsta, da znova povečate, kadar koli želite."</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Krmilna palica"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Povečevalnik aktivirajte in premikajte s krmilno palico na zaslonu. Dotaknite se, pridržite in nato povečevalnik upravljajte z vlečenjem po krmilni palici. Če želite premakniti krmilno palico, se je dotaknite in jo povlecite."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"O povečavi"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Preberite več o povečavi."</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Način povečave"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Povečajte celoten zaslon, določen del zaslona ali preklapljajte med obema možnostma."</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Celotni zaslon"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Del zaslona"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Preklapljanje med celotnim zaslonom in delom zaslona."</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Izbira načina povečave"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Povečanje celotnega zaslona"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Povečanje dela zaslona"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Preklapljanje med celotnim zaslonom in delom zaslona"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Med možnostma se pomikajte z dotikom gumba za preklop."</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Želite preklopiti na gumb za funkcije?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Uporaba trikratnega dotika za povečavo dela zaslona povzroči zakasnitve pri vnašanju in drugih dejanjih.\n\nGumb za funkcije za ljudi s posebnimi potrebami lebdi na zaslonu nad drugimi aplikacijami. Dotaknite se ga, če ga želite povečati."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Preklopi na gumb za funkcije"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Uporabi trikratni dotik"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"To bo morda upočasnilo delovanje tipkovnice."</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Pri uporabi trikratnega dotika za povečavo dela zaslona boste morda opazili težave s tipkovnico.\n\nTemu se lahko izognete, če za bližnjico za povečavo namesto trikratnega dotika uporabite eno od drugih možnosti.\n"<annotation id="link">"Sprememba nastavitve"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Vseeno nadaljuj"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Prekliči"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Nastavitve povečave"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Povečevanje s trikratnim dotikom"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Povečanje z bližnjico"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Povečanje z bližnjico in trikratnim dotikom"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"O funkciji »<xliff:g id="SERVICE">%1$s</xliff:g>«"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Velikost prikaza in besedilo"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Spremenite prikaz besedila"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Zadeva: Oblikovne zasnove za toplozračni balon"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Od: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Dobro jutro!\n\nŽelim samo preveriti, kako napreduje oblikovanje. Bo narejeno, preden začnemo izdelovati nove balone?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Ponastavi nastavitve"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Nastavitve besedila in velikosti prikaza so bile ponastavljene."</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Želite ponastaviti velikost prikaza in besedilo?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Ponastavi"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Imaš kakšne načrte za konec tedna?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Odpravljam se na Obalo. Greš zraven?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Možnosti"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Povečava zaslona"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Če želite povečati, se trikrat dotaknite"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Če želite povečati, se dotaknite gumba"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Hitro povečajte zaslon za povečavo vsebine."</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Če želite povečati:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Z bližnjico vklopite povečavo.&lt;br/&gt; {1,number,integer}. Dotaknite se zaslona.&lt;br/&gt; {2,number,integer}. Po zaslonu se pomikajte z vlečenjem dveh prstov.&lt;br/&gt; {3,number,integer}. Stopnjo povečave prilagodite tako, da prsta razmaknete ali primaknete.&lt;br/&gt; {4,number,integer}. Z bližnjico izklopite povečavo.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Povečavo začasno vklopite tako:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Prepričajte se, da je vrsta povečave nastavljena na celozaslonski način.&lt;br/&gt; {1,number,integer}. Z bližnjico vklopite povečavo.&lt;br/&gt; {2,number,integer}. Dotaknite se poljubne točke na zaslonu in jo pridržite.&lt;br/&gt; {3,number,integer}. Po zaslonu se pomikajte z vlečenjem prsta.&lt;br/&gt; {4,number,integer}. Dvignite prst, da izklopite povečavo."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Ko je povečava vklopljena, lahko povečate prikaz na zaslonu.\n\n"<b>"Če želite povečati prikaz"</b>", zaženite povečavo, 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>"Primaknite ali razmaknite dva ali več prstov, če želite prilagoditi povečavo."</li></ul>\n\n<b>"Če želite začasno povečati prikaz"</b>", zaženite povečavo ter 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_tutorial_pager" msgid="8461939455728454061">"<xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. stran od <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Odpiranje z gumbom za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Za odpiranje pridržite tipki za glasnost"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Za odpiranje se trikrat dotaknite zaslona"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Odpiranje s potezo"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Uporaba poteze za funkcije za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Če želite uporabljati to funkcijo, se na dnu zaslona dotaknite gumba za funkcije za ljudi s posebnimi potrebami <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nČe želite preklopiti med funkcijami, se dotaknite gumba za funkcije za ljudi s posebnimi potrebami in ga pridržite."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Za uporabo te funkcije se na zaslonu dotaknite gumba za funkcije za ljudi s posebnimi potrebami."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Če želite uporabljati to funkcijo, pritisnite obe tipki za glasnost in ju pridržite."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Če želite vklopiti ali izklopiti povečavo, se trikrat dotaknite poljubnega mesta na zaslonu."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Če želite uporabljati to funkcijo, z dvema prstoma povlecite z dna zaslona navzgor.\n\nČe želite preklopiti med funkcijami, z dvema prstoma povlecite navzgor in pridržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Če želite uporabljati to funkcijo, s tremi prsti povlecite z dna zaslona navzgor.\n\nČe želite preklopiti med funkcijami, s tremi prsti povlecite navzgor in pridržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Če želite uporabljati funkcijo za ljudi s posebnimi potrebami, z dvema prstoma povlecite z dna zaslona navzgor.\n\nČe želite preklopiti med funkcijami, z dvema prstoma povlecite navzgor in pridržite."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Če želite uporabljati funkcijo za ljudi s posebnimi potrebami, s tremi prsti povlecite z dna zaslona navzgor.\n\nČe želite preklopiti med funkcijami, s tremi prsti povlecite navzgor in pridržite."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Razumem"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Nastavitve gumba za funkcije za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Bližnjica do funkcije »<xliff:g id="SERVICE">%1$s</xliff:g>«"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Gumb za dostopnost"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Poteza za funkcije za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Vlečenje navzgor z dvema prstoma"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Vlečenje navzgor s tremi prsti"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Dotik gumba za funkcije za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Uporaba poteze za funkcije za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Na dnu zaslona se dotaknite gumba za funkcije za ljudi s posebnimi potrebami <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nČe želite preklopiti med funkcijami, se dotaknite gumba za funkcije za ljudi s posebnimi potrebami in ga pridržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Z dvema prstoma povlecite z dna zaslona navzgor.\n\nČe želite preklopiti med funkcijami, z dvema prstoma povlecite navzgor in pridržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"S tremi prsti povlecite z dna zaslona navzgor.\n\nČe želite preklopiti med funkcijami, s tremi prsti povlecite navzgor in pridržite."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Več možnosti"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Več o storitvi <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Pridržanje tipk za glasnost"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"pridržanje tipk za glasnost"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Pritisnite in pridržite obe tipki za glasnost."</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Trikratni dotik zaslona"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"trikratni dotik zaslona"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"{0,number,integer}-krat se hitro dotaknite zaslona. Ta bližnjica bo morda upočasnila delovanje naprave."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Dodatno"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"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_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Poteza za ljudi s posebnimi potrebami je nastavljena na <xliff:g id="SERVICE">%1$s</xliff:g>. Če želite uporabiti povečavo, z dvema prstoma povlecite z dna zaslona navzgor in pridržite. Nato izberite povečavo."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Bližnjica na tipki za glasnost"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Nastavitve bližnjice"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Bližnjica na zaklenjenem zaslonu"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Omogoči vklop bližnjice do funkcije na zaklenjenem zaslonu. Za nekaj sekund pridržite obe tipki za glasnost."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Gumb za dostopnost"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Gumb ali poteza za dostopnost"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Hitro dostopajte do funkcij za ljudi s posebnimi potrebami na poljubnem zaslonu."</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"O gumbu za fun. za ljudi s pos. potr."</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"O gumbu in potezi za funk. za ljudi s poseb. potrebami"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Preberite več o gumbu in potezi za funkcije za ljudi s posebnimi potrebami."</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Uporaba gumba za funkcije za ljudi s posebnimi potrebami Poteza ni na voljo pri krmarjenju s tremi gumbi."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Hiter dostop do funkcij za ljudi s posebnimi potrebami."</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Začnete tako:"</b>\n"1. Odprite nastavitve funkcij za ljudi s posebnimi potrebami.\n2. Izberite funkcijo in se dotaknite bližnjice.\n3. Izberite, ali želite do funkcije dostopati z gumbom ali potezo."</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Začnete tako:"</b>\n"1. Odprite nastavitve funkcij za ljudi s posebnimi potrebami.\n2. Izberite funkcijo in se dotaknite bližnjice.\n3. Izberite gumb za dostop do funkcije."</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Uporaba gumba ali poteze"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Lokacija"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Velikost"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Pobleditev, ko ni v uporabi"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Pobledi po nekaj sekundah, da boste lažje videli zaslon."</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Prosojnost, ko ni v uporabi"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Prosojno"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Neprosojno"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Visokokontrastno besedilo"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Spremenite barvo besedila v črno ali belo. Poveča kontrast z ozadjem."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Samodejno posodobi povečavo zaslona"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Posodabljanje povečave zaslona pri prehodih aplik."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Gumb za vklop konča klic"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Velik kazalec miške"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Povečanje ikone za kazalec miške"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Odstranjevanje animacij"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Zmanjšanje gibanja na zaslonu"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Mono zvok"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Združevanje kanalov pri predvajanju zvoka."</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Ravnovesje zvoka"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Levo"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Desno"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Privzeto"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekund"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekund"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minuta"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minuti"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Čas za dejanje (časovna omejitev funkcije)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"O času za dejanje (časovni omejitvi funkcije)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Preberite več o času za dejanje (časovni omejitvi funkcije)."</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Čas za ukrepanje"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Ta časovna nastavitev ni podprta v vseh aplikacijah."</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Izberite, kako dolgo naj bodo prikazana začasna sporočila, ki vas pozivajo k ukrepanju."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Časovni zamik za dotik in pridržanje"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inverzija barv"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Uporabi inverzijo barv"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Bližnjica za inverzijo barv"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Pri inverziji barv se svetli zasloni spremenijo v temne. Poleg tega se temni zasloni spremenijo v svetle."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Upoštevajte:&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Barve se spremenijo v predstavnosti in na slikah.&lt;/li&gt; &lt;li&gt; Inverzija barv deluje v vseh aplikacijah.&lt;/li&gt; &lt;li&gt; Za prikaz temnega ozadja lahko vklopite tudi temno temo.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Samodejni klik (na podlagi časa mirovanja)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"O samodejnem kliku (na podlagi časa mirovanja)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Preberite več o samodejnem kliku (na podlagi časa mirovanja)."</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Povezano miško lahko nastavite tako, da bo samodejno kliknila, kadar se kazalec določen čas ne premakne."</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Samodejni klik je lahko koristen, če težko klikate miško."</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Izklop samodejnega klika"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kratko"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekunde"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Srednje dolgo"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekunde"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Dolgo"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekunda"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Po meri"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Krajše"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Daljše"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Čas za samodejni klik"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibriranje in tipni odziv"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Nastavitev moči vibriranja za različne uporabe"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Vklopljeno"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Izklopljeno"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Nastavitev je onemogočena, ker je naprava nastavljena na tiho."</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Klici"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Obvestila in alarmi"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktivni tipni odziv"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Uporabi vibriranje in tipni odziv"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibriranje alarma"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibriranje predstavnosti"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibriranje pri zvonjenju"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibriranje pri obvestilih"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Odziv na dotik"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Uporabi funkcijo <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Odpiranje aplikacije <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"Funkcija <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> je dodana v hitre nastavitve. Kadar koli jo lahko vklopite ali izklopite tako, da povlečete navzdol."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Funkcijo <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> lahko v hitre nastavitve dodate tudi z vrha zaslona."</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Popravljanje barv je dodano v hitre nastavitve. Kadar koli ga lahko vklopite ali izklopite tako, da povlečete navzdol."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Popravljanje barv lahko v hitre nastavitve dodate tudi z vrha zaslona."</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Inverzija barv je dodana v hitre nastavitve. Kadar koli jo lahko vklopite ali izklopite tako, da povlečete navzdol."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Inverzijo barv lahko v hitre nastavitve dodate tudi z vrha zaslona."</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Možnost zelo zatemnjenega zaslona je dodana v hitre nastavitve. Kadar koli jo lahko vklopite ali izklopite tako, da povlečete navzdol."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Možnost za zelo zatemnjen zaslon lahko v hitre nastavitve dodate tudi z vrha zaslona."</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Enoročni način je dodan v hitre nastavitve. Kadar koli ga lahko vklopite ali izklopite tako, da povlečete navzdol."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Enoročni način lahko v hitre nastavitve dodate tudi z vrha zaslona."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Opusti"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Uporabi popravljanje barv"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Bližnjica za popravljanje barv"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"O popravljanju barv"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Preberite več o popravljanju barv."</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"O inverziji barv"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Preberite več o inverziji barv."</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Prikaz podnapisov"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Samo za podprte aplikacije."</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Velikost in slog podnapisov"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Velikost besedila: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>."</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Več možnosti"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Prilagodite velikost in slog podnapisov, da jih boste lažje brali."</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Te nastavitve podnapisov niso podprte v vseh aplikacijah za predstavnost."</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Gumb za dostopnost"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Vlečenje z dvema prstoma od dna navzgor"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Pridržanje tipk za glasnost"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trikratni dotik zaslona"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Naprej"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Slušni aparati"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Slušne aparate, polževe vsadke in druge ojačevalnike lahko uporabljate s telefonom."</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"Noben slušni pripomoček ni povezan."</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Dodajanje slušnih pripomočkov"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Seznanite slušne aparate"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Na naslednjem zaslonu se dotaknite slušnih aparatov. Morda boste morali posebej seznaniti aparat za levo in desno uho.\n\nPrepričajte se, da so slušni aparati vklopljeni in pripravljeni za seznanjanje."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"Naprava <xliff:g id="DEVICE_NAME">%1$s</xliff:g> je aktivna"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, samo levo"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, samo desno"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, levo in desno"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> in še 1"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Seznanitev nove naprave"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"O seznanjanju nove naprave"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Slušni aparati"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Shranjene naprave"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Kontrolniki slušnega aparata"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Bližnjica do slušnega aparata"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Združljivost s slušnimi aparati"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Izboljša združljivost s teletuljavami in zmanjša količino neželenega hrupa."</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"O slušnih aparatih"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Poskrbite, da je slušni aparat vklopljen in pripravljen za seznanjanje."</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Seznanitev slušnega aparata"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Razpoložljivi slušni aparati"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Ali vaš slušni aparat ni prikazan?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Ogled več naprav"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Prilagoditev zvoka"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Zvočni opis"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Poslušajte opis dogodkov na zaslonu za podprte filme in oddaje."</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"zvočni opis, zvok, opis, slabovidnost"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Bližnjica je vklopljena"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Izklopljeno"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Vklopljeno"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Izklopljeno"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Ne deluje. Dotaknite se za več informacij."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Ta storitev ne deluje pravilno."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Bližnjice funkcij za ljudi s posebnimi potrebami"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Prikaži v »Hitrih nastavitvah«"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Rdeča-zelena"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Rdeča-zelena"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Modra-rumena"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Sivine"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Šibka zelena, devteranomalija"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Šibka rdeča, protanomalija"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalija"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Zelo zatemnjen zaslon"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Zelo zatemni zaslon"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Bližnjica za zelo zatemnjen zaslon"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"O zelo zatemnjenem zaslonu"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Zatemnite zaslon, da bo branje prijetnejše."</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intenzivnost"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Temneje"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Svetleje"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Ohrani vklopljeno po vnovičnem zagonu naprave"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Kratko ({time} sekunda)}one{Kratko ({time} sekunda)}two{Kratko ({time} sekundi)}few{Kratko ({time} sekunde)}other{Kratko ({time} sekund)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Srednje dolgo ({time} sekunda)}one{Srednje dolgo ({time} sekunda)}two{Srednje dolgo ({time} sekundi)}few{Srednje dolgo ({time} sekunde)}other{Srednje dolgo ({time} sekund)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Dolgo ({time} sekunda)}one{Dolgo ({time} sekunda)}two{Dolgo ({time} sekundi)}few{Dolgo ({time} sekunde)}other{Dolgo ({time} sekund)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekunda}one{{time} sekunda}two{{time} sekundi}few{{time} sekunde}other{{time} sekund}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Nastavitve"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Vklopljeno"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Izklopljeno"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Predogled"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardne možnosti"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Jezik"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Velikost besedila"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Slog podnapisov"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Možnosti po meri"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Barva ozadja"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Neprosojnost ozadja"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Barva oken za napise"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Neprosojnost oken za napise"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Barva besedila"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Neprosojnost besedila"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Barva roba"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Vrsta roba"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Skupina pisav"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Podnapisi bodo videti tako."</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Privzeto"</string>
    <string name="color_title" msgid="2511586788643787427">"Barva"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Privzeto"</string>
    <string name="color_none" msgid="3703632796520710651">"Brez"</string>
    <string name="color_white" msgid="1896703263492828323">"Bela"</string>
    <string name="color_gray" msgid="8554077329905747877">"Siva"</string>
    <string name="color_black" msgid="9006830401670410387">"Črna"</string>
    <string name="color_red" msgid="5210756997426500693">"Rdeča"</string>
    <string name="color_green" msgid="4400462091250882271">"Zelena"</string>
    <string name="color_blue" msgid="4997784644979140261">"Modra"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cijan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Rumena"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Ali storitvi »<xliff:g id="SERVICE">%1$s</xliff:g>« dovolite popoln nadzor nad svojo napravo?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> mora:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Ker aplikacija zakriva zahtevo za dovoljenje, z nastavitvami ni mogoče preveriti vašega odziva."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> zahteva popoln nadzor nad to napravo. Storitev lahko prebere zaslon in deluje v imenu uporabnikov s posebnimi potrebami. Ta raven nadzora za večino aplikacij ni primerna."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Popoln nadzor je ustrezen za aplikacije, ki vam pomagajo pri funkcijah za ljudi s posebnimi potrebami, vendar ne za večino aplikacij."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Ogledovanje in upravljanje zaslona"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Bere lahko vso vsebino na zaslonu ter prikaže vsebino prek drugih aplikacij."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Ogledovanje in izvajanje dejanj"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Spremlja lahko vaše interakcije z aplikacijo ali senzorjem strojne opreme ter komunicira z aplikacijami v vašem imenu."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Dovoli"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Zavrni"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Ustavi"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Prekliči"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Želite izklopiti »<xliff:g id="SERVICE">%1$s</xliff:g>«?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Če se dotaknete možnosti »<xliff:g id="STOP">%1$s</xliff:g>«, se bo funkcija »<xliff:g id="SERVICE">%2$s</xliff:g>« ustavila."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nameščena ni nobena storitev"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nobena storitev ni izbrana"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Ni opisa."</string>
    <string name="settings_button" msgid="2195468788019730377">"Nastavitve"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"občutljivost na svetlobo, fotofobija, temna tema, migrena, glavobol, način branja, nočni način, zmanjšanje svetlosti, točka beline"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"preprosta uporaba, preprost dostop, pomoč, podporno"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"lupa v oknu, povečava/pomanjšava, povečava, slabovidnost, povečaj, naredi večje"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"podnapisi, sproten prepis, naglušnost, izguba sluha, CART, pretvorba govora v besedilo, podnapis"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"velikost zaslona, velik zaslon"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"visok kontrast, slabovidnost, krepka pisava, krepke črke"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"prilagajanje barve"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"potemnitev zaslona, posvetlitev zaslona"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motorično, gibalno, miška"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"slušni aparati, naglušna oseba, izguba sluha, polževi vsadki, ojačevalniki, obdelovalniki zvoka"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"naglušnost, izguba sluha, podnapisi, teleprinter, tty"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Tiskanje"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Izklopljeno"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 storitev tiskanja je vklopljena.}one{# storitev tiskanja je vklopljena.}two{# storitvi tiskanja sta vklopljeni.}few{# storitve tiskanja so vklopljene.}other{# storitev tiskanja je vklopljenih.}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 tiskalno opravilo}one{# tiskalno opravilo}two{# tiskalni opravili}few{# tiskalna opravila}other{# tiskalnih opravil}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Storitve tiskanja"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nameščena ni nobena storitev"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Tiskalnikov ni mogoče najti"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Nastavitve"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Dodajanje tiskalnikov"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Vklopljeno"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Izklop"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Dodajte storitev"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Dodajte tiskalnik"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Iskanje"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Iskanje tiskalnikov"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Storitev je onemogočena"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Zahteve za tiskanje"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Tiskalno opravilo"</string>
    <string name="print_restart" msgid="4424096106141083945">"Začni znova"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Prekliči"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Konfiguriranje: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Tiskanje: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Preklic: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Napaka tiskalnika: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Tiskalnik je blokiral <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Iskalno polje je prikazano"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Iskalno polje je skrito"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Več informacij o tem tiskalniku"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Baterija"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Kaj porablja energijo baterije"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> – <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Preostali čas: <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> do napolnjenosti"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Skoraj prazna baterija"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Dovoli, da se aplikacija izvaja v ozadju"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Želite omejiti dejavnost v ozadju?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Če boste omejili dejavnost aplikacije v ozadju, morda ne bo pravilno delovala"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Ker za to aplikacijo ni izbrana nastavitev optimiziranja porabe baterije, je ni mogoče omejiti.\n\nČe želite omejiti aplikacijo, najprej vklopite optimizacijo baterije."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Neomejeno"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimizirano"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Omejeno"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Neomejena poraba energije baterije med izvajanjem v ozadju. Poraba energije baterije bo morda višja."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimizirano na podlagi vaše porabe. Priporočeno za večino aplikacij."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Omejena poraba energije baterije med izvajanjem v ozadju. Aplikacija morda ne bo delovala po pričakovanjih. Obvestila bodo morda zakasnjena."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Če spremenite način, na katerega aplikacija porablja energijo baterije, lahko vplivate na delovanje aplikacije."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Ta aplikacija potrebuje <xliff:g id="STATE">%1$s</xliff:g> porabo energije baterije."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"neomejeno"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimizirano"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Preberite več o možnostih porabe energije baterije."</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Uporaba zaslona od polne napolnjenosti"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Poraba baterije"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Podrobnosti zgodovine"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Poraba energije baterije"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Ogled porabe za zadnjih 24 ur"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Ogled uporabe od zadnje polne napolnjenosti"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Poraba energije baterije za aplikacijo"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Podrobnosti uporabe"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Prilagodi porabo energije"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Vključeni paketi"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplikacije delujejo normalno"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Nizka raven napolnjenosti baterije"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Vklopite varčevanje z energijo baterije, da podaljšate čas delovanja baterije."</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Podaljšanje časa delovanja baterije"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Vklopite varčevanje z energijo baterije"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Vklop varčevanja z baterijo"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Baterija se bo morda izpraznila prej kot običajno"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Varčevanje z energijo baterije je vklopljeno"</string>
    <string name="battery_saver_link_a11y" msgid="740558184830458845">"Preberite več o varčevanju z energijo baterije."</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Nekatere funkcije bodo morda omejene"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Višja poraba energije baterije"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Ogled aplikacij z najvišjo porabo energije"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Polnjenje je optimizirano zaradi zaščite baterije"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="6836981984725209843">"Polnjenje je optimizirano zaradi podaljšanja življenjske dobe baterije."</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Polnjenje je optimizirano zaradi zaščite baterije"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Zaradi podaljšanja življenjske dobe baterije je polnjenje optimizirano, ko je naprava priklopljena na nosilec."</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Polnjenje je optimizirano zaradi zaščite baterije"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Zaradi podaljšanja življenjske dobe baterije je polnjenje optimizirano, ko je naprava priklopljena na nosilec."</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Polnjenje do konca"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Zaradi zaščite baterije bo polnjenje optimizirano ob naslednjem priklopu tabličnega računalnika na nosilec."</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Več o začasno zaustavljenem polnjenju"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Nadaljuj polnjenje"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Vključuje dejavnost z visoko porabo energije v ozadju"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Omejitev # aplikacije}one{Omejitev # aplikacije}two{Omejitev # aplikacij}few{Omejitev # aplikacij}other{Omejitev # aplikacij}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{Pred kratkim je bila omejena aplikacija {label}}one{Pred kratkim je bila omejena # aplikacija}two{Pred kratkim sta bili omejeni # aplikaciji}few{Pred kratkim so bile omejene # aplikacije}other{Pred kratkim je bilo omejenih # aplikacij}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{Aplikacija {label} ima visoko porabo energije baterije v ozadju.}one{# aplikacija ima visoko porabo energije baterije v ozadju.}two{# aplikaciji imata visoko porabo energije baterije v ozadju.}few{# aplikacije imajo visoko porabo energije baterije v ozadju.}other{# aplikacij ima visoko porabo energije baterije v ozadju.}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Ta aplikacija se ne sme izvajati v ozadju.}one{Te aplikacije se ne smejo izvajati v ozadju.}two{Te aplikacije se ne smejo izvajati v ozadju.}few{Te aplikacije se ne smejo izvajati v ozadju.}other{Te aplikacije se ne smejo izvajati v ozadju.}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Želite omejiti aplikacijo?}one{Želite omejiti # aplikacijo?}two{Želite omejiti # aplikaciji?}few{Želite omejiti # aplikacije?}other{Želite omejiti # aplikacij?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Če želite varčevati z energijo baterije, preprečite aplikaciji <xliff:g id="APP">%1$s</xliff:g>, da bi porabljala energijo baterije v ozadju. Ta aplikacija morda ne bo delovala pravilno, obvestila pa bodo morda zakasnjena."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Če želite varčevati z energijo baterije, preprečite tem aplikacijam, da bi porabljale energijo baterije v ozadju. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena.\n\nAplikacije:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Če želite varčevati z energijo baterije, preprečite tem aplikacijam, da bi porabljale energijo baterije v ozadju. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena.\n\nAplikacije:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Omeji"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Želite odstraniti omejitev?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Ta aplikacija bo lahko porabljala energijo baterije za izvajanje v ozadju. Baterija se bo morda izpraznila prej, kot bi pričakovali."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Odstrani"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Prekliči"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Napolni do konca"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Težava s pripomočkom za polnjenje"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Več o nezdružljivem polnjenju"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Varčevanje z energijo baterije"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Samodejno upravljanje aplikacij"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Ko varčevanje z energijo baterije zazna, da aplikacije porabljajo energijo baterije, lahko te aplikacije omejite. Omejene aplikacije morda ne bodo delovale pravilno, obvestila pa bodo morda zakasnjena."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Omejene aplikacije"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Omejevanje porabe energije baterije za # aplikacijo}one{Omejevanje porabe energije baterije za # aplikacijo}two{Omejevanje porabe energije baterije za # aplikaciji}few{Omejevanje porabe energije baterije za # aplikacije}other{Omejevanje porabe energije baterije za # aplikacij}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Omejeno <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Te aplikacije ne smejo porabljati energije baterije v ozadju. Morda ne bodo delovale po pričakovanjih in morda bodo obvestila zakasnjena."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Uporaba varčevanja z energijo baterije"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Zaznavanje, ko aplikacije porabljajo energijo baterije"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Zaznavanje, ko aplikacije porabljajo energijo baterije."</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Zaznavanje, ko aplikacije porabljajo energijo baterije."</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# aplikacija je omejena.}one{# aplikacija je omejena.}two{# aplikaciji sta omejeni.}few{# aplikacije so omejene.}other{# aplikacij je omejenih.}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Težava z branjem merilnika stanja napolnjenosti baterije."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Dotaknite se, če želite izvedeti več o tej napaki."</string>
    <string name="power_screen" msgid="3926703168513988776">"Zaslon"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPE"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Svetilka"</string>
    <string name="power_camera" msgid="4778315081581293923">"Fotoaparat"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi‑Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobilno omrežje"</string>
    <string name="power_phone" msgid="2768396619208561670">"Glasovni klici"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Uporaba zaslona: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> porabil: <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> celotne napolnjenosti baterije"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Razčlenitev od zadnje napolnjenosti baterije"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Zadnja polna napolnjenost"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Polno napolnjena naprava deluje približno"</string>
    <string name="battery_footer_summary" msgid="8221691063048377342">"Podatki o porabi energije baterije so približni in se lahko spremenijo glede na uporabo naprave."</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Poraba baterije"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Brez uporabe od zadnje polne napolnjenosti"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Ni bilo uporabe v zadnjih 24 urah."</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"od zadnje polne napolnjenosti"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Sistemske aplikacije"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Drugo"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Približni preostali čas"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Do napolnjenosti"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Ocena je odvisna od uporabe in se lahko spremeni."</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Predstavnostni strežnik"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimizacija aplikacij"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Internetna povezava prek mobilnega telefona"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Odstranjene aplikacije"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Varčevanje z energijo baterije"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Samodejni vklop"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Ni razporeda"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Na podlagi vaših navad"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"To bo vklopljeno na podlagi vaših navad."</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Na podlagi odstotka"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Varčevanje z energijo baterije se vklopi, če je verjetno, da se bo baterija izpraznila pred naslednjim običajnim polnjenjem."</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Vklop pri <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Nastavitev razporeda"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Podaljšanje časa delovanja baterije"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Izklop ob napolnjenosti"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Izklop pri napolnjenosti <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Varčevanje z energijo baterije se izklopi, ko je baterija napolnjena na <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>."</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Vklop"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Uporabi varčevanje z energijo baterije"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Samodejni vklop"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nikoli"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"pri <xliff:g id="PERCENT">%1$s</xliff:g> napolnjenosti baterije"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Odstotek napolnjenosti baterije"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Pokaži odstotek napolnjenosti baterije v vrstici stanja."</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Raven napolnjenosti baterije od zadnje polne napolnjenosti baterije"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Raven napolnjenosti baterije v zadnjih 24 urah"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Poraba aplikacij od zadnje polne napolnjenosti baterije"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Poraba aplikacij v zadnjih 24 urah"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Poraba sistema od zadnje polne napolnjenosti baterije"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Poraba sistema v zadnjih 24 urah"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Poraba sistema za <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Poraba aplikacij za <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Skupno: manj kot minuta"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"V ozadju: manj kot minuta"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Čas uporabe: manj kot min"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Skupno: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"V ozadju: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Čas uporabe: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Podatki o porabi energije baterije bodo na voljo čez nekaj ur, ko bo baterija popolnoma napolnjena."</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"zdaj"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g>–<xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Grafikon porabe energije baterije"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Grafikon porabe energije baterije po dnevih"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Grafikon porabe energije baterije po urah"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Poraba energije baterije od zadnje polne napolnjenosti"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Poraba energije baterije za <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Čas uporabe od zadnje polne napolnjenosti"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Čas uporabe za <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_breakdown_by_apps" msgid="7746337368402445072">"Razčlenitev po aplikacijah"</string>
    <string name="battery_usage_spinner_breakdown_by_system" msgid="4646952798665973464">"Razčlenitev po sistemih"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistični podatki o procesih"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Statistični podatki o procesih, ki se izvajajo"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Poraba pomnilnika"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"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="4391502694312709148">"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="4094034441562453522">"V ozadju"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"V ospredju"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Predpomnjeni"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Sistem Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Izvorno"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Jedro"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Predpomnjeno"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Uporaba RAM-a"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Uporaba RAM-a (v ozadju)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Trajanje izvajanja"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesi"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Storitve"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Trajanje"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Podrobnosti pomnilnika"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 ure"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 ur"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 ur"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 dan"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Prikaži sistemske procese"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Skrij sistemske procese"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Prikaži odstotke"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Uporaba USS-ja"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Vrsta statističnih podatkov"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"V ozadju"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"V ospredju"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Predpomnjeni"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Glasovni vnos in izhod"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Nastavitve glasovnega vnosa in izhoda"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Glasovno iskanje"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Tipkovnica Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Nastavitve glasovnega vnosa"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Glasovni vnos"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Storitve glasovnega vnosa"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Polna uporaba sprožilnih besed in govora"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Pretvorba preprostega govora v besedilo"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"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="on_device_recognition_settings" msgid="6503160369314598069">"Nastavitve prepoznavanja v napravi"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Prepoznavanje v napravi"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Prepoznavanje govora v napravi"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Prednostni mehanizem"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Nastavitve mehanizma"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Hitrost in višina tona govora"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Mehanizem"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Glasovi"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Govorjeni jezik"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Namestitev glasov"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Pojdite v aplikacijo <xliff:g id="TTS_APP_NAME">%s</xliff:g>, če želite namestiti glasove"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Odpri aplikacijo"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Prekliči"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Ponastavi"</string>
    <string name="tts_play" msgid="2945513377250757221">"Predvajaj"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Ni varno"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"Toliko ni varnih: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"Toliko ni varnih: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Prilagodljivo povezovanje"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Podaljša čas delovanja baterije in izboljša učinkovitost delovanja naprave s samodejnim upravljanjem omrežnih povezav."</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Vklopljeno"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Izklopljeno"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Uporaba prilagodljivega povezovanja"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Shramba poverilnic"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Namestitev potrdila"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Brisanje poverilnic"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Odstranitev vseh potrdil"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Preverjene poverilnice"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Prikaz zaupanja vrednih potrdil overiteljev"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Uporabniške poverilnice"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Ogled in spreminjanje shranjenih poverilnic"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Dodatno"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Za tega uporabnika niso na voljo poverilnice"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Nameščeno za VPN in aplikacije"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Nameščeno za Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Nameščeno za Wi-Fi (v uporabi)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Želite odstraniti vso vsebino?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Shramba poverilnic je izbrisana."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Shrambe pover. ni mogoče izbr."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apl. z dost. do pod. o uporabi"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Potrdilo overitelja potrdil"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Upor. potrdilo za VPN in apl."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Potrdilo za Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Vaši podatki ne bodo zasebni"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Spletna mesta, aplikacije in navidezna zasebna omrežja (VPN) uporabljajo potrdila overiteljev potrdil za izvajanje šifriranja. Nameščajte samo potrdila overiteljev potrdil, ki jih izdajo zaupanja vredne organizacije. \n\nČe namestite potrdilo overitelja potrdil, lahko lastnik potrdila dostopa do vaših podatkov, kot so gesla ali podrobnosti o kreditni kartici, ki izvirajo z obiskanih spletnih mest in iz uporabljenih aplikacij – tudi če so podatki šifrirani."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Ne namesti"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Kljub temu namesti"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Potrdilo ni nameščeno"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Ali aplikaciji "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" dovolite nameščanje potrdil v to napravo?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Ta potrdila bodo uporabljena za preverjanje pristnosti, pri katerem se enoznačni ID naprave deli z aplikacijami in naslovi URL, ki so navedeni spodaj."</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Ne dovoli"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Dovoli"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Pokaži več"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Aplik. za upravljanje potrdil"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Ni aplikacije"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Potrdila bodo uporabljena za preverjanje pristnosti pri uporabi aplikacij in naslovov URL, ki so navedeni spodaj."</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Odmesti potrdila"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Odstrani aplikacijo"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Želite odstraniti aplikacijo?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Ta aplikacija ne bo upravljala potrdil, vendar bo ostala v napravi. Vsa potrdila, nameščena s to aplikacijo, bodo odmeščena."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}one{# URL}two{# URL-ja}few{# URL-ji}other{# URL-jev}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Signal za klice v sili"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Nastavi način delovanja ob klicanju v sili"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Varnostno kopiranje"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Vklopljeno"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Izklopljeno"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Varnostno kopiranje in obnovitev"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Osebni podatki"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Varn. kopiraj podatke"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Varnostno kopiranje podatkov aplikacij, gesel za Wi-Fi in drugih nastavitev v Googlove strežnike"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Račun za kopiranje"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Upravljanje računa za varnostno kopiranje"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Vključi podatke aplikacije"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Samodejna obnovitev"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Obnovitev varnostno kopiranih nastavitev in podatkov pri vnovični namestitvi aplikacije"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Storitev varnostnega kopiranja ni aktivna"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Trenutno v nobenem računu niso shranjeni varnostno kopirani podatki"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"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="2379053988557486162">"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="971587401251601473">"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="31392408594557070">"Nastavitve skrbnika naprave"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Skrbniška aplikacija naprave"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktiviraj to skrbniško aplikacijo naprave"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Odstrani aplikacijo"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktiviraj in odstrani"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Skrbniške aplikacije naprave"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Na voljo ni nobena skrbniška aplikacija naprave"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Na voljo ni nobenega posrednika zaupanja"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktivacija skrbniške aplikacije naprave?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktiviraj to skrbniško aplikacijo naprave"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Skrbnik naprave"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Če aktivirate to skrbniško aplikacijo, boste aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> omogočili izvajanje teh dejanj:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"To napravo bo upravljala in nadzirala aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Ta skrbniška aplikacija je aktivna in aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> omogoča izvajanje teh dejanj:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Želite aktivirati Upravitelja profilov?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Želite dovoliti nadzor?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Č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="8122039047419172139">"Druge možnosti je onemogočil skrbnik"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Več o tem"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Dnevnik obvestil"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Zgodovina obvestil"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Zadnjih toliko ur: %d"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Preloženo"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nedavno opuščeno"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# obvestilo}one{# obvestilo}two{# obvestili}few{# obvestila}other{# obvestil}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Ton zvonjenja in vibriranje"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Podatki o omrežju"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinhronizacija omogočena"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinhronizacija onemogočena"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sinhronizacija poteka"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Napaka pri sinhronizaciji"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinhronizacija ni uspela"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinhronizacija je aktivna"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinhroniziranje"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Težava pri sinhronizaciji. Kmalu bo spet na voljo."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Dodajte račun"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Delovni profil še ni na voljo"</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Delovni profil"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Upravlja vaša organizacija."</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Aplikacije in obvestila so izklopljeni."</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Odstranite delovni profil"</string>
    <string name="background_data" msgid="321903213000101158">"Podatki v ozadju"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplikacije lahko kadar koli sinhronizirajo, pošiljajo in prejemajo podatke"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Želite onemogočiti podatke v ozadju?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Če onemogočite podatke v ozadju, podaljšate življenjsko dobo baterije in zmanjšate rabo podatkov. Nekatere aplikacije bodo mogoče še vedno potrebovale povezavo s podatki v ozadju."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sinhroniz. je VKLOP."</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinhron. je IZKLOPLJENA"</string>
    <string name="sync_error" msgid="846923369794727644">"Sinhron. napaka"</string>
    <string name="last_synced" msgid="1527008461298110443">"Zadnja sinhronizacija: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sinhroniziranje ..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Varnostno kopiranje nastavitev"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Varnostno kopiranje nastavitev"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinhroniziraj"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Prekliči sinhronizacijo"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Dotaknite se za sinhronizacijo<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Koledar"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Stiki"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Nastavitve sinhronizacije aplikacij"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Podatki in sinhronizacija"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Spremeni geslo"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Nastavitve računa"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Odstrani račun"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Dodajanje računa"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Želite odstraniti račun?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Skrbnik ne dovoli te spremembe"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Ročna sinhronizacija ni mogoča"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Sinhronizacija za ta element je trenutno onemogočena. Če želite spremeniti nastavitev, vklopite podatke v ozadju in samodejno sinhronizacijo."</string>
    <string name="delete" msgid="8330605554706263775">"Izbriši"</string>
    <string name="select_all" msgid="7898929601615536401">"Izberi vse"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Podatkovni promet"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobilni podatki in Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Samod. sinhron. oseb. podatkov"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Samod. sinhr. delov. podatkov"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Spremeni cikel ..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dan za ponastavitev cikla porabe podatkov:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"V tem obdobju ni podatkov uporabljala nobena aplikacija."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Ospredje"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Ozadje"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"omejeno"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Želite izklopiti prenos podatkov v mobilnih omrežjih?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Nast. omejitev mobilnih podatkov"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Nastavi omejitev podatkov za 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Nast. omejitev za EDGE in UMTS"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Nast. omej. pod. za Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi‑Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobilni"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G-3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobilno"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Brez"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobilni podatki"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Podatki 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Podatki 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Gostovanje"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Ospredje:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Ozadje:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Nastavitve aplikacije"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Podatki v ozadju"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Omogoči prenos podatkov v mobilnem omrežju v ozadju."</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Č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="5383874438677899255">"Želite omejiti podatke v ozadju?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"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="8599940395497268584">"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="2048411447974361181">"Želite vklopiti samodejno sinhroniziranje podatkov?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Želite izklopiti samodejno sinhroniziranje podatkov?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"S tem zmanjšate količino prenesenih podatkov in porabo baterije, 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="2019035830921480941">"Datum ponastavitve cikla merjenja prenosa"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Dan v mesecu:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Nastavi"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Nastavite opozorilo za prenos podatkov"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Nastavite omejitev količine prenesenih podatkov"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Omejitev prenosa podatkov"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">" <xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"opozorilo"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"omejitev"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Odstranjene aplikacije"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Odstranjene aplikacije in uporabniki"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Uporaba omrežja"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Omejen prenos podatkov"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Ime"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Vrsta"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Naslov strežnika"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Šifriranje PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Skrivnost L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identifikator IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Vnaprej deljeni ključ IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Uporabniško potrdilo IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Overjeno potrdilo IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Potrdilo strežnika IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Prikaži dodatne možnosti"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Domene za iskanje DNS"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Strežniki DNS (npr. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Poti za posredovanje (npr. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Uporabniško ime"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Geslo"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Shrani podatke o računu"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ni uporabljeno)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ne preveri strežnika)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(prejeto iz strežnika)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Ta vrsta omrežja VPN ne more biti stalno vklopljena."</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Stalno vklopljeno omrežje VPN podpira samo številske naslove strežnikov."</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Za stalno vklopljeno omrežje VPN mora biti naveden strežnik DNS."</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Za stalno vklopljeno omrežje VPN morajo biti naslovi strežnikov DNS številski."</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Vneseni podatki ne podpirajo stalno vklopljenega omrežja VPN."</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Prekliči"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Opusti"</string>
    <string name="vpn_save" msgid="683868204634860888">"Shrani"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Vzpostavi povezavo"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Zamenjaj"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Urejanje profila VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Pozabi"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Povezovanje z <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Prekinitev povezave s tem omrežjem VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Prekini povezavo"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Različica"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Pozabi omrežje VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Želite zamenjati obstoječe omrežje VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Ali želite, da je omrežje VPN stalno vklopljeno?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Ko je ta nastavitev vklopljena, ne boste imeli internetne povezave, dokler se ne vzpostavi povezava z omrežjem VPN."</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"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="4299175336198481106">"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="1094297700371463386">"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="3568307071295211187">"Vklopi"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"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="2139148820719163694">"Ta aplikacija ne podpira stalno vklopljenega omrežja VPN."</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Dodajanje profila VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Urejanje profila"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Brisanja profila"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Stalno vklopljen VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Dodano ni bilo nobeno omrežje VPN."</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Stalna povezava v omrežje VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Ta aplikacija tega ne podpira"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Vedno vklopljeno"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Ni varno"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokiraj povezave brez omrežja VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Ali zahtevate povezavo VPN?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Ni varno. Posodobite na VPN različice IKEv2."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"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="455915403560910517">"Brez"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"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="7187593680049843763">"Ni omrežne povezave. Poskusite pozneje."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Povezava z VPN je prekinjena"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Brez"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Ni potrdila. Uredite profil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Uporabnik"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Onemogoči"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Omogoči"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Odmesti"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Zaupaj"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Želite omogočiti sistemsko overjeno potrdilo?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Želite onemogočiti sistemsko overjeno potrdilo?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Želite trajno odstraniti uporabniško overjeno potrdilo?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Trenutno uporabljeno za"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Ta vnos vsebuje"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 uporabniški ključ"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 uporabniško potrdilo"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 overjeno potrdilo"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"Potrdila overitelja potrdil: %d"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Podrobnosti poverilnic"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Odstranjena poverilnica: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Ni nameščenih uporabniških poverilnic."</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Črkovalnik"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Črkovalnik za delo"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Sem vnesite trenutno geslo za popolno varnostno kopiranje"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Sem vnesite novo geslo za popolno varnostno kopiranje"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Znova vnesite novo geslo za popolno varnostno kopiranje"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Nastavi geslo za varnostno kopijo"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Prekliči"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Dodatne posodobitve sistema"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Omrežje je lahko nadzorovano"</string>
    <string name="done_button" msgid="6269449526248267">"Končano"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Označevanje potrdila kot zaupanja vrednega ali odstranitev potrdila}one{Označevanje potrdil kot zaupanja vrednih ali odstranitev potrdil}two{Označevanje potrdil kot zaupanja vrednih ali odstranitev potrdil}few{Označevanje potrdil kot zaupanja vrednih ali odstranitev potrdil}other{Označevanje potrdil kot zaupanja vrednih ali odstranitev potrdil}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{Skrbnik organizacije {orgName} je namestil overitelja potrdil v vaši napravi, s čimer morda lahko spremlja omrežno dejavnost naprave, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o tem potrdilu, se obrnite na skrbnika.}one{Skrbnik organizacije {orgName} je namestil overitelje potrdil v vaši napravi, s čimer morda lahko spremlja omrežno dejavnost naprave, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o tem potrdilih, se obrnite na skrbnika.}two{Skrbnik organizacije {orgName} je namestil overitelja potrdil v vaši napravi, s čimer morda lahko spremlja omrežno dejavnost naprave, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o tem potrdilih, se obrnite na skrbnika.}few{Skrbnik organizacije {orgName} je namestil overitelje potrdil v vaši napravi, s čimer morda lahko spremlja omrežno dejavnost naprave, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o tem potrdilih, se obrnite na skrbnika.}other{Skrbnik organizacije {orgName} je namestil overitelje potrdil v vaši napravi, s čimer morda lahko spremlja omrežno dejavnost naprave, vključno z e-pošto, aplikacijami in varnimi spletnimi mesti.\n\nČe želite več informacij o tem potrdilih, se obrnite na skrbnika.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{Skrbnik organizacije {orgName} je namestil overitelja 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 tem potrdilu, se obrnite na skrbnika.}one{Skrbnik organizacije {orgName} 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.}two{Skrbnik organizacije {orgName} je namestil overitelja 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.}few{Skrbnik organizacije {orgName} 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.}other{Skrbnik organizacije {orgName} 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.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"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>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Preveri potrdilo}one{Preveri potrdila}two{Preveri potrdila}few{Preveri potrdila}other{Preveri potrdila}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Več uporabnikov"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Uporabniki in profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Dodajanje uporabnika ali profila"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Omejen profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Uporabnik ni nastavljen"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Ni nastavljeno – omejen profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Ni nastavljeno – delovni profil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Skrbnik"</string>
    <string name="user_you" msgid="3070562015202859996">"Vi (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Ne morete več dodajati uporabnikov. Če želite dodati novega, odstranite enega od obstoječih."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Profili z omejitvami ne morejo dodajati računov"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Izbris up. <xliff:g id="USER_NAME">%1$s</xliff:g> iz napr."</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Nastavitve zaklepanja zaslona"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Dodajanje uporabnikov na zaklenjenem zaslonu"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Preklopi na skrbniš. uporabnika, ko je v nosilcu"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Želite izbrisati sebe?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Želite izbrisati uporabnika?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Odstranitev profila?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Želite odstraniti delovni profil?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Vse aplikacije in vsi podatki bodo izbrisani."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Če nadaljujete, bodo izbrisane vse aplikacije in podatki v tem profilu."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Vse aplikacije in vsi podatki bodo izbrisani."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Dodajanje novega uporabnika ..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Izbriši uporabnika"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Izbriši"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Vse aplikacije in podatki v tej seji bodo izbrisani."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Odstrani"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Gost (vi)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Uporabniki"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Drugi uporabniki"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Izbriši dejavnost gosta"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Brisanje vseh aplikacij in podatkov gosta ob zaprtju načina za goste"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Želite izbrisati dejavnost gosta?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Aplikacije in podatki v tej seji gosta bodo zdaj izbrisani, prihodnja dejavnost gosta pa bo izbrisana vsakič, ko zaprete način za goste."</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"brisanje, gost, dejavnost, odstrani, podatki, obiskovalec, izbriši"</string>
    <string name="enable_guest_calling" msgid="8300355036005240911">"Gostu dovoli uporabo telefona"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Zgodovina klicev bo v deljena s tem gostom."</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Vklop telefonskih klicev in sporočil SMS"</string>
    <string name="user_grant_admin" msgid="6511342422361803820">"Temu uporabniku podeli skrbniške pravice"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Brisanje uporabnika"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Vklop telefonskih klicev in sporočil SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Zgodovina klicev in sporočil SMS bo deljena s tem uporabnikom."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Želite odstraniti skrbniške pravice?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="2719667217562982318">"Ali ste prepričani, da želite temu uporabniku odvzeti skrbniške pravice?"</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Informacije za nujne primere"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Podatki in stiki za uporabnika <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Odpri aplikacijo <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Omogočanje aplikacij in vsebine"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplikacije z omejitvami"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Dodatne nastavitve za aplikacijo"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Izberite aplikacije za namestitev"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Namestitev razpoložljivih aplikacij"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Brezstična plačila"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Privzeta aplikacija za plačevanje"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Če želite plačati z aplikacijo za plačevanje, prislonite hrbtno stran naprave k plačilnem terminalu."</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Več o tem"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Želite delovno aplikacijo uporabljati kot privzeto aplikacijo za plačevanje?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Če želite plačati z delovno aplikacijo:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"Delovni profil mora biti vklopljen."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"Vnesti boste morali kodo PIN, vzorec ali geslo (če to imate) za delovni profil."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Kako deluje"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Plačujte v trgovinah s telefonom"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Privzeta aplikacija za plačevanje"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Ni nastavljeno"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Uporaba privzete aplikacije za plačevanje"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Uporaba privzete aplikacije za plačevanje"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Vedno"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Razen ko je odprta druga aplikacija za plačevanje"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Na brezstičnem terminalu plačaj z aplikacijo:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Plačevanje na terminalu"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"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="4717868843368296630">"Razumem"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Več …"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Nastavite privzeto aplikacijo za plačevanje"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Posodobite privzeto aplikacijo za plačevanje"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Na brezstičnem terminalu plačaj z aplikacijo <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Na brezstičnem terminalu plačaj z aplikacijo <xliff:g id="APP_0">%1$s</xliff:g>.\n\nS tem boste zamenjali aplikacijo <xliff:g id="APP_1">%2$s</xliff:g> kot privzeto aplikacijo za plačevanje."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Nastavi za privzeto"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Posodobi"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Služba"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Omejitve"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Odstranitev omejitev"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Sprememba kode PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Pomoč in povr. inf."</string>
    <string name="user_account_title" msgid="6389636876210834864">"Račun za vsebino"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID fotografije"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Skrajne grožnje"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Prejem. opozoril o skrajnih grožnjah za življenje in premož."</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Resne grožnje"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Prejem. opozoril o resnih grožnjah za življenje in premož."</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Opozorila AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Prejemanje objav o ugrabitvah otrok"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Ponovitev"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Omogočanje Upravitelja klicev"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Omogoči tej storitvi upravljanje načina izvajanja klicev."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Upravitelj klicev"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Brezžična nujna opozorila"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Omrežni operaterji"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Imena dostopnih točk (APN)"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Napredno klicanje"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Klicanje prek omrežja 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Uporaba storitev LTE za izboljšanje glasovnih klicev (priporočeno)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Uporaba storitev 4G za izboljšanje glasovnih klicev (priporočeno)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Uporaba tehnologije 5G za glasovne klice"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Pošiljanje stikov operaterju"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Pošiljajte telefonske številke stikov za zagotavljanje dodatnih funkcij"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Želite stike pošiljati operaterju <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Želite stike pošiljati operaterju?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Telefonske številke stikov se bodo redno pošiljale operaterju <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Na podlagi teh podatkov je mogoče ugotoviti, ali stiki lahko uporabljajo določene funkcije, na primer videoklice ali nekatere funkcije za sporočila."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Telefonske številke stikov se bodo redno pošiljale operaterju.<xliff:g id="EMPTY_LINE">

</xliff:g>Na podlagi teh podatkov je mogoče ugotoviti, ali stiki lahko uporabljajo določene funkcije, na primer videoklice ali nekatere funkcije za sporočila."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Prednostna vrsta omrežja"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (priporočeno)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Sporočila MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Pošiljanje in prejemanje, ko je prenos podatkov v mobilnih omrežjih izklopljen"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Samodejni preklop prenosa podatkov v mobilnem omrežju"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Uporabi to omrežje, kadar ima boljšo razpoložljivost."</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Delovna kartica SIM"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Dostop do aplikacij in vsebine"</string>
    <string name="user_rename" msgid="8735940847878484249">"PREIMENOVANJE"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Nastavitev omejitev za aplikacijo"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Nadzira aplikacija <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Ta aplikacija lahko dostopa do vaših računov"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"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="2630656989926554685">"Wi-Fi in mobilna omrežja"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Dovoli spreminjanje nastavitev za Wi-Fi in mobilna omrežja"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Dovoli spreminjanje seznanjanj in nastavitev naprav Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Lokacija"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Aplikacije lahko uporabljajo podatke o vaši lokaciji"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Nazaj"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Naprej"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formatiraj na drug način"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"Kartici SIM"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Prenos podatkov v mob. omr. ni na voljo"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Dotaknite se, če želite izbrati SIM za prenos podatkov"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Vedno uporabi to možnost za klice"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Izberite kartico SIM za mobilne podatke"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Izberite kartico SIM za sporočila SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Preklop podatkovne kartice SIM. Lahko traja kakšno minuto …"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Uporaba kartice <xliff:g id="NEW_SIM">%1$s</xliff:g> za mobilne podatke?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Če preklopite na kartico <xliff:g id="NEW_SIM">%1$s</xliff:g>, kartica <xliff:g id="OLD_SIM">%2$s</xliff:g> ne bo več uporabljena za prenos podatkov v mobilnem omrežju."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Uporabi kartico <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Klicanje z …"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Vnesite ime kartice SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Reža za SIM %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranžna"</string>
    <string name="color_purple" msgid="6603701972079904843">"Vijolična"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Stanje kartice SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Stanje kartice SIM (reža za SIM %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"Kartici SIM sta bili spremenjeni."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Dotaknite se, če želite nastaviti"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Vedno vprašaj"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Zahtevana je izbira"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Izbira kartice SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Nastavitve"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Omrežje in internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobilni podatki, Wi‑Fi, dostopna točka"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi-Fi, dostopna točka"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Povezane naprave"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, seznanjanje"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, način vožnje, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, način vožnje"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, način vožnje, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, način vožnje"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Ni na voljo, ker je vmesnik NFC izklopljen."</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Za uporabo najprej namestite aplikacijo za plačevanje."</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nedavne aplikacije, privzete aplikacije"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Dostop do obvestil ni na voljo za aplikacije v delovnem profilu."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Gesla in računi"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Shranjena gesla, samodejno izpolnjevanje, sinhronizirani računi"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Privzete aplikacije"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Klonirane aplikacije"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Ustvarite drugi primerek aplikacije, da boste lahko uporabljali dva računa hkrati."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Aplikacije, ki jih je mogoče klonirati."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"Št. kloniranih aplikacij: <xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g>; št. aplikacij, ki so na voljo za kloniranje: <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g>"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Brisanje vseh klonov aplikacij"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Brisanje vseh klonov aplikacij ni uspelo"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Ustvarjanje …"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Klonirano"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Ustvarjanje klona aplikacije <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Ustvarjen klon aplikacije <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Jeziki, poteze, ura, varnostno kopiranje"</string>
    <string name="languages_setting_summary" msgid="4924440599794956443">"Sistemski jeziki, jeziki aplikacij"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, omrežna povezava, internet, brezžično, podatki, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Obvestilo za Wi‑Fi, obvestilo za wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"prenesena količina podatkov"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Uporaba 24-urne oblike"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Za odpiranje uporabi"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplikacije"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"časovni pas"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Glava klepeta, sistem, opozorilo, okno, pogovorno okno, prikaz, čez druge aplikacije, risanje"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Svetilka, luč, baterijska svetilka, žepna svetilka"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, preklop, upravljanje"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilno omrežje, mobilno, operater, brezžično, podatki, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, klic, klicanje"</string>
    <string name="keywords_display" msgid="874738809280751745">"zaslon, zaslon na dotik"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"zatemnitev zaslona, zaslon na dotik, akumulator, baterija, svetlo"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"zatemnitev zaslona, noč, obarvanje, preklop na nočni način, svetlost, barva zaslona, barva"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"ozadje, prilagajanje, prilagajanje zaslona"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"velikost besedila"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projekcija, predvajanje, zrcaljenje zaslona, deljenje zaslona, zrcaljenje, skupna raba zaslona, predvajanje zaslona"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"prostor, disk, trdi disk, uporaba naprave"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"poraba energije, polnjenje"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"prikaz porabe energije baterije, poraba energije baterije, poraba energije"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"varčevanje z energijo baterije, varčevanje z energijo, varčevanje"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"nastavitve prilagodljivega varčevanja, prilagodljivo varčevanje z energijo baterije"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"črkovanje, slovar, preverjanje črkovanja, samodejno popravljanje"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"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="6728080502619011668">"hitrost, jezik, privzeto, govor, govorjenje, pretvorba besedila v govor, dostopnost bralnik zaslona, slep"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"ura, vojaško"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"ponastavitev, obnovitev, tovarniško"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"izbrisati, obnoviti, počistiti, odstraniti, tovarniška ponastavitev, ponastavitev na tovarniške nastavitve"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"tiskalnik"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"pisk zvočnika, zvočnik, glasnost, utišati, tišina, zvok, glasba, haptično, tipno, vibriranje, vibrirati"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"ne moti, prekinjaj, prekinitev, motnja"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"v bližini, lokacija, zgodovina, poročanje, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"račun, dodajanje računa, delovni profil, dodaj račun, odstrani, izbriši"</string>
    <string name="keywords_users" msgid="3497517660077620843">"omejitev, omeji, omejeno"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"popravljanje besedila, pravilno, zvok, vibriranje, samodejno, jezik, poteza, predlaganje, predlog, tema, žaljivo, beseda, vrsta, emodžiji, mednarodno"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"ponastavitev, nastavitve, privzeto"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"aplikacije, prenos, aplikacije, sistem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplikacije, dovoljenja, varnost"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplikacije, privzeto"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"prezrtje, optimizacije, dremanje, aplikacija v pripravljenosti"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"živo, RGB, sRGB, barva, naravno, standardno"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, ločljivost, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"barva, temperatura, D65, D73, bela, rumena, modra topla, hladna"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"podrsanje za odklepanje, geslo, vzorec, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"pripenjanje zaslona"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"delovna preizkušnja, delo, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"delovni profil, upravljan profil, poenotiti, poenotenje, delo, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"poteze"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"denarnica"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"plačaj, dotakni se, plačevanje z dotikom, plačila"</string>
    <string name="keywords_backup" msgid="707735920706667685">"varnostna kopija, varnostno kopiranje, varnostno kopirati"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"poteza"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"obraz, odklepanje, preverjanje pristnosti, prijava"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"obraz, odklepanje, preverjanje pristnosti, prijava, prstni odtis, biometrični podatki"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, različica seznama prednostnih omrežij za gostovanje, različica programske opreme za imei"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"omrežje, stanje mobilnega omrežja, stanje storitve, moč signala, vrsta mobilnega omrežja, gostovanje"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"omrežje, stanje mobilnega omrežja, stanje storitve, moč signala, vrsta mobilnega omrežja, gostovanje, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"omrežje, stanje mobilnega omrežja, stanje storitve, moč signala, vrsta mobilnega omrežja, gostovanje, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"omrežje, stanje mobilnega omrežja, stanje storitve, moč signala, vrsta mobilnega omrežja, gostovanje, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serijska številka, različica strojne opreme"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"raven varnostnih popravkov za android, različica radijske programske opreme, različica jedra"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, svetla, temna, način, občutljivost na svetlobo, fotofobija, naredi temnejše, potemni, temni način, migrena"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"temna tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"napaka"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"prikaz na podlagi okolja, prikaz na zaklenjenem zaslonu"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"obvestilo na zaklenjenem zaslonu, obvestila"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"obraz"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"prstni odtis, dodajanje prstnega odtisa"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"obraz, prstni odtis, dodajanje prstnega odtisa"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"odklepanje z uro, dodajanje odklepanja z uro"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"zatemnitev zaslona, zaslon na dotik, baterija, pametna svetlost, dinamična svetlost, samodejno prilagajanje svetlosti"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"pametno, zatemnitev zaslona, stanje pripravljenosti, baterija, časovna omejitev, zaznavanje pogleda, prikaz, zaslon, nedejavnost"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"fotoaparat, pametno, samodejni zasuk, zasuk, vrtenje, obrniti, obrat, pokončno, ležeče, postavitev, navpično, vodoravno"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"nadgradnja, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"ne moti, razpored, obvestila, blokirati, utišati, vibriranje, spanje, delo, zbranost, izklopiti zvok, dan, delavnik, vikend, noč med tednom, dogodek"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"zaslon, čas zaklepanja, časovna omejitev, zaklenjen zaslon"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"pomnilnik, predpomnilnik, podatki, izbrisati, počistiti, sprostiti, prostor"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"povezano, naprava, slušalke, slušalke z mikrofonom, zvočnik, brezžično, seznaniti, seznanitev, ušesne slušalke, glasba, predstavnost"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"ozadje, tema, mreža, prilagajanje po meri, osebno prilagajanje, individualno prilagajanje"</string>
    <string name="keywords_styles" msgid="5291614313348476068">"ikona, poudarek, barva"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"privzeto, pomočnik"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"plačilo, plačevanje, privzeto"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"dohodno obvestilo"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"povezava z internetom prek mobilnega telefona prek kabla USB, povezava z internetom prek mobilnega telefona prek povezave Bluetooth, dostopna točka wifi"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"haptično, tipno, vibriranje, vibrirati"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptično, tipno, vibriranje, zaslon, občutljivost"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"haptično, tipno, vibriranje, telefon, klic, občutljivost, zvonjenje"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"haptično, tipno, vibriranje, telefon, klic, zvonjenje, postopno"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"haptično, tipno, vibriranje, občutljivost, obvestilo"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"haptično, tipno, vibriranje, občutljivost, alarm"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"haptično, vibriranje, občutljivost, predstavnost"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"haptično, tipno, odziv na dotik, vibriranje, vibrirati"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"varčevanje z energijo baterije, lepljivo, trajno, varčevanje z energijo, baterija"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutina, vsakodnevni opravek, razpored, urnik, varčevanje z energijo baterije, varčevanje z energijo, baterija, samodejno, odstotek, delež"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, napredno klicanje, klicanje 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, napredno klicanje, klicanje 5g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"dodajanje jezika, dodajte jezik"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"velikost besedila, velika pisava, velike črke, veliko besedilo, slabovidnost, povečaj besedilo, povečevalnik pisave, povečanje pisave"</string>
    <string name="keywords_always_show_time_info" msgid="645658129239452778">"stalno vklopljen zaslon"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, oznaka, bralnik"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Glasnost, vibriranje, ne moti"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Glasnost predstavnosti"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Glasnost predvajanja"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Glasnost klica"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Glasnost alarma"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Glasnost zvonjenja in obvestil"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Glasnost zvonjenja"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Glasnost obvestila"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Ni na voljo, ker je zvonjenje izklopljeno"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Ton zvonjenja telefona"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Privzeti zvok obvestila"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Zvok iz aplikacije"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Privzeti zvok obvestila"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Privzeti zvok alarma"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Najprej vibriranje, nato postopno zvonjenje"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Prostorski zvok"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Toni tipkovnice"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Zvok ob zaklepanju zaslona"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Zvoki in vibriranje ob polnjenju"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Zvok ob odlaganju v nosilec"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Zvoki dotikov"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Vedno pokaži ikono v načinu vibriranja"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Zvočnik nosilca je vklopljen"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Vsi zvoki"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Samo zvoki predstavnosti"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Tišina"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Toni"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibriranje"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Zvoki ob zagonu"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Samodejni podnapisi"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Samodejni podnapisi predstavnosti"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Zvočnik telefona"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Žične slušalke"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Zvok iz združljivih predstavnosti dobi prostornejšo razsežnost."</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Izklopljeno"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Vklopljeno/<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Vklopljeno/<xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> in <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Prostorski zvok lahko vklopite tudi za naprave Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Nastavitve povezanih naprav"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Noben}=1{Nastavljen je 1 razpored}one{Nastavljen je # razpored}two{Nastavljena sta # razporeda}few{Nastavljeni so # razporedi}other{Nastavljenih je # razporedov}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Ne moti"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Prejemajte samo obvestila pomembnih oseb in aplikacij."</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Omejitev prekinitev"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Vklop načina »Ne moti«"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarmi in zvoki predstavnosti lahko preglasijo"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Časovni razporedi"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Izbriši razporede"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Izbriši"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Uredi"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Razporedi"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Razpored"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Časovni razpored"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Utišanje telefona ob določenih urah"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Nastavitev pravil za način »Ne moti«"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Časovni razpored"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Uporabi razpored"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Dovoljene zvočne motnje"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokiranje vizualnih motenj"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Dovoli vizualne znake"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Možnosti prikaza skritih obvestil"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Ko je vklopljen način »Ne moti«"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Brez zvočnega opozarjanja na obvestila"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Obvestila bodo prikazana na zaslonu."</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Telefon ob prejemu obvestil ne bo predvajal zvoka ali vibriral."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Brez vidnega in zvočnega opozarjanja na obvestila"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Obvestila ne bodo prikazana in ne bodo pospremljena z zvokom."</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Telefon ob prejemu novih ali obstoječih obvestil ne bo vibriral ali zvonil oziroma jih ne bo prikazal. Upoštevajte, da se bodo nujna obvestila v zvezi z dejavnostjo in stanjem naprave še vedno prikazovala.\n\nKo izklopite način »Ne moti«, lahko zamujena obvestila poiščete tako, da povlečete od vrha zaslona navzdol."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Po meri"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Omogoči nastavitev po meri"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Odstrani nastavitev po meri"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Brez zvočnega opozarjanja na obvestila"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Delno skrito"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Brez vidnega in zvočnega opozarjanja na obvestila"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Omejitve po meri"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Pri vklopljenem zaslonu"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Pri izklopljenem zaslonu"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Izklopi zvok in vibriranje"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Ne vklopi zaslona"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Ne pokaži utripajoče lučke"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Ne prikaži obvestil na zaslonu"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Skrij ikone v vrstici stanja na vrhu"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Skrij obvestilne pike na ikonah aplikacij"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ne vklopi za obvestila"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Skrij s poteznega zaslona z obvestili"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nikoli"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Pri izklopljenem zaslonu"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Pri vklopljenem zaslonu"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Zvok in vibriranje"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Zvok, vibriranje in nekateri vizualni znaki obvestil"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Zvok, vibriranje in vizualni znaki obvestil"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Obvestila, potrebna za osnovno dejavnost naprave in stanje naprave, ne bodo nikoli skrita."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Brez"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"druge možnosti"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Dodaj"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Vklopi"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Vklopi zdaj"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Izklopi zdaj"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Način »Ne moti« bo vklopljen do <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Način »Ne moti« bo ostal vklopljen, dokler ga ne izklopite."</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Način »Ne moti« je bil samodejno vklopljen na podlagi razporeda (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Način »Ne moti« je samodejno vklopila aplikacija (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Način »Ne moti« je vklopljen za <xliff:g id="RULE_NAMES">%s</xliff:g> z nastavitvami po meri."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Ogled nastavitev po meri"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Samo prednostno"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Vklopljeno/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Vklopljeno"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Vedno vprašaj"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Dokler ne izklopite"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 uro}one{# uro}two{# uri}few{# ure}other{# ur}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuto}one{# minuto}two{# minuti}few{# minute}other{# minut}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Izklopljeno}=1{Izklopljeno/1 razpored se lahko samodejno vklopi.}one{Izklopljeno/# razpored se lahko samodejno vklopi.}two{Izklopljeno/# razporeda se lahko samodejno vklopita.}few{Izklopljeno/# razporedi se lahko samodejno vklopijo.}other{Izklopljeno/# razporedov se lahko samodejno vklopi.}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Kaj lahko preglasi način »Ne moti«"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Osebe"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplikacije"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmi in druge motnje"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Razporedi"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Trajanje pri uporabi hitrih nastavitev"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Splošno"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Pri vklopljenem načinu »Ne moti« bosta zvok in vibriranje izklopljena v vseh primerih razen za zgoraj omogočene elemente."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Nastavitve po meri"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Preglej razpored"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Razumem"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Obvestila"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Trajanje"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Sporočila, dogodki in opomniki"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Pri vklopljenem načinu »Ne moti« bodo prezrta vsa sporočila, opomniki in dogodki razen za zgoraj omogočene elemente. Nastavitve sporočil lahko prilagodite tako, da boste dosegljivi za prijatelje, družinske člane ali druge stike."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Končano"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Nastavitve"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Brez vidnega in zvočnega opozarjanja na obvestila"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Brez zvočnega opozarjanja na obvestila"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Obvestila ne bodo prikazana in ne bodo pospremljena z zvokom. Klici od stikov z zvezdico in večkratnih klicateljev so dovoljeni."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(trenutna nastavitev)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Želite spremeniti nastavitve obvestil v načinu »Ne moti«?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Zvoki v delovnem profilu"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Uporabi zvoke iz osebnega profila"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Uporabite iste zvoke kot v osebnem profilu."</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Ton zvonjenja službenega telefona"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Privzeti zvok obvestila delovnega profila"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Privzeti zvok alarma delovnega profila"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Kot v osebnem profilu"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Ali želite uporabiti zvoke iz osebnega profila?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Potrdi"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Delovni in osebni profil bosta uporabljala iste zvoke."</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Obvestila"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Zgodovina obvestil, pogovori"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Pogovor"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Upravljanje"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Obvestila aplikacij"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Upravljajte obvestila iz posameznih aplikacij."</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Splošno"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Obvestila za delovni profil"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Delovni profil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prilagodljiva prednost obvestil"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Samodejna nastavitev manj pomembnih obvestil na »Brez zvočnega opozorila«"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Prilagodljivo razvrščanje obvestil"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Samodejna razvrstitev obvestil glede na ustreznost"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Povratne informacije o prilagodljivih obvestilih"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Pokaži spremembe nastavitev obvestil in možnost posredovanja povratnih informacij sistemu"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Ponastavitev pomembnosti obvestil"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Ponastavitev uporabniško spremenjenih nastavitev pomembnosti in omogočanje prednostne obravnave Pomočniku za obvestila"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Predlagana dejanja in odgovori"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Samodejen prikaz predlaganih dejanj in odgovorov"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Prikažite nedavna in preložena obvestila."</string>
    <string name="notification_history" msgid="8663811361243456201">"Zgodovina obvestil"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Uporabi zgodovino obvestil"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Zgodovina obvestil je izklopljena"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Če si želite ogledati nedavna in preložena obvestila, vklopite zgodovino obvestil."</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Ni nedavnih obvestil"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Tukaj bodo prikazana tako nedavna kot preložena obvestila."</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"ogled nastavitev obvestil"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"odpiranje obvestila"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Omogoči prelaganje obvestil"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Obvestilna pika na ikoni aplikacije"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Oblački"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Oblački"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Prikaži ta pogovor v oblačku"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Prikaži plavajočo ikono čez aplikacije"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Želite vklopiti oblačke za napravo?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Če vklopite oblačke za to aplikacijo, bodo vklopljeni tudi za napravo.\n\nTo vpliva na druge aplikacije ali pogovore, v katerih je prikaz v oblačkih že omogočen."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Vklopi"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Prekliči"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Vklopljeno/pogovori so lahko prikazani kot lebdeče ikone."</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Omogoči aplikacijam, da prikažejo oblačke"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Nekateri pogovori bodo prikazani kot lebdeče ikone nad drugimi aplikacijami."</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Vsi pogovori so lahko prikazani v oblačkih"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Izbrani pogovori so lahko prikazani v oblačkih"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Nič ne sme biti prikazano v oblačkih"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Pogovori"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Vsi pogovori so lahko prikazani v oblačkih razen"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Izklop oblačkov za ta pogovor"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Vklop oblačkov za ta pogovor"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Povlecite desno za opustitev ali levo za prikaz menija"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Povlecite levo za opustitev ali desno za prikaz menija"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Skrij tiha obvestila v vrstici stanja"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Utripajoča lučka"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Zasebnost"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Preskoči zaklenjen zaslon"</string>
    <string name="lockscreen_bypass_summary" msgid="464277506200346748">"Po odklepanju odpri nazadnje uporabljen zaslon."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"odklepanje zaslona, zaklenjen zaslon, preskok, zaobitje"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Ko je delovni profil zaklenjen"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Na zaklenjenem zaslonu prikaži samo nova obvestila"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Že ogledana obvestila samodejno odstrani z zaklenjenega zaslona"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Obvestila na zaklenjenem zaslonu"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Prikaži pogovore ter privzeta in tiha obvestila."</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Prikaži obvestila za privzeto in tiho v razdelku Pogovori."</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Skrij tihe pogovore in obvestila."</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ne prikaži nobenih obvestil."</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Občutljiva obvestila"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Prikaži občutljivo vsebino na zaklenjenem zaslonu."</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Občutljiva obvestila za delovni profil"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Prikaži občutljivo vsebino delovnega profila na zaklenjenem zaslonu."</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Prikaži vso vsebino obvestil"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Prikaži občutljivo vsebino samo na odklenjenem zaslonu"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Sploh ne prikazuj obvestil"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Kaj želite, da je prikazano na zaklenjenem zaslonu?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Zaklenjen zaslon"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Pokaži vso vsebino obvestil za delovni profil."</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Skrivanje občutljive vsebine za delovni profil"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kako naj se obvestila o profilu prikazujejo, ko je naprava zaklenjena?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Obvestila o profilu"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Obvestila"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Obvestila aplikacij"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kategorija obvestil"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Vedenje"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Pogovori"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Razdelek s pogovorom"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Aplikaciji dovoli uporabo razdelka s pogovorom."</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Ni pogovor"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Odstrani iz razdelka s pogovorom."</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"To je pogovor"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Dodajanje v razdelek s pogovorom"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Ni prednostnih pogovorov"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prednostni pogovor}one{# prednostni pogovor}two{# prednostna pogovora}few{# prednostni pogovori}other{# prednostnih pogovorov}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prednostni pogovori"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Prikazani so na vrhu razdelka Pogovor in v plavajočih oblačkih."</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Prikaz na vrhu razdelka s pogovorom"</string>
    <string name="other_conversations" msgid="551178916855139870">"Neprednostni pogovori"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Pogovori, v katere ste vnesli spremembe."</string>
    <string name="recent_conversations" msgid="471678228756995274">"Nedavni pogovori"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Počisti nedavne pogovore"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Nedavni pogovori odstranjeni"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Pogovor je odstranjen."</string>
    <string name="clear" msgid="5092178335409471100">"Počisti"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Prednostni in spremenjeni pogovori bodo prikazani tukaj"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Pogovori, ki jih označite kot prednostne ali jih kakor koli drugače spremenite, bodo prikazani tukaj. \n\nČe želite spremeniti nastavitve pogovorov: \nS prstom povlecite z vrha zaslona navzdol, da odprete potezni zaslon z obvestili, in nato pridržite pogovor."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimiraj"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Prikaži na zaslonu"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Tiho"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Privzeto"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Dovoli prekinitve"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Dovoli aplikaciji, da predvaja zvok, vibrira in/ali prikaže obvestila na zaslonu"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prednostno"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Prikaz na vrhu razdelka s pogovorom in v plavajočem oblačku, prikaz profilne slike na zaklenjenem zaslonu."</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"Aplikacija <xliff:g id="APP_NAME">%1$s</xliff:g> ne podpira večine pogovornih funkcij. Pogovora ne morete označiti kot prednostnega in pogovori ne bodo prikazani v plavajočih oblačkih."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Na poteznem zaslonu z obvestili strni obvestila v eno vrstico."</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Brez zvočnega opozarjanja ali vibriranja."</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Brez zvočnega opozarjanja ali vibriranja, prikaz nižje v razdelku s pogovorom."</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Zvonjenje ali vibriranje je omogočeno na podlagi nastavitev telefona."</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Kadar je naprava odklenjena, so obvestila prikazana kot pasica na vrhu zaslona."</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Vsa obvestila aplikacije »<xliff:g id="APP_NAME">%1$s</xliff:g>«"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Vsa obvestila aplikacije <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Približno # obvestilo na dan}one{Približno # obvestilo na dan}two{Približno # obvestili na dan}few{Približno # obvestila na dan}other{Približno # obvestil na dan}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Približno # obvestilo na teden}one{Približno # obvestilo na teden}two{Približno # obvestili na teden}few{Približno # obvestila na teden}other{Približno # obvestil na teden}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nikoli"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Obvestila naprave in aplikacij"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Upravljajte, katere aplikacije in naprave lahko berejo obvestila."</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Dostop do obvestil delovnega profila je blokiran"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Pametna obvestila"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Prejemajte predlagana dejanja, odgovore in drugo."</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Brez"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Nobena nameščena aplikacija ni zahtevala dostopa do obvestil."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Dovoli dostop do obvestil"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Pametna obvestila so v Androidu 12 zamenjala prilagodljiva obvestila Android. Ta funkcija prikazuje predlagana dejanja in odgovore ter organizira vaša obvestila. \n\nPametna obvestila lahko preberejo vso vsebino obvestil, vključno z osebnimi podatki, kot so imena in sporočila stikov. Ta funkcija lahko tudi opusti obvestila ali se odziva nanje (npr. sprejema telefonske klice in upravlja način Ne moti)."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Želite storitvi <xliff:g id="SERVICE">%1$s</xliff:g> dovoliti dostop do obvestil?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Aplikacija <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bo lahko prebrala vsa obvestila, vključno z osebnimi podatki, kot so imena stikov, fotografije in besedilo prejetih sporočil. Ta aplikacija bo lahko tudi preložila ali opustila obvestila in izvajala dejanja z gumbi v obvestilih, vključno s sprejemanjem telefonskih klicev. \n\nS tem bo lahko aplikacija tudi vklopila ali izklopila način »Ne moti« in spremenila povezane nastavitve."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Aplikacija <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> bo lahko izvajala ta dejanja:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Branje obvestil"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Prebere lahko obvestila, vključno z osebnimi podatki, kot so stiki, sporočila in fotografije."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Pošiljanje odgovora na sporočila"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Lahko odgovarja na sporočila in izvaja dejanja z gumbi v obvestilih, vključno s prelaganjem ali opuščanjem obvestil in sprejemanjem klicev."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Spreminjanje nastavitev"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Lahko vklopi ali izklopi način »ne moti« in spremeni povezane nastavitve."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Č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="841492108402184976">"Izklopi"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Prekliči"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"V realnem času"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Aktivna komunikacija iz aplikacij v uporabi, navigacije, telefonskih klicev in od drugod."</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Pogovori"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"Sporočila SMS, besedilna sporočila in druge komunikacije."</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Obvestila"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Zvonjenje ali vibriranje je omogočeno na podlagi nastavitev."</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Tiho"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Obvestila, ki nikoli ne sprožijo zvonjenja ali vibriranja."</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Dovoljeno"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Ni dovoljeno"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Prikaz vseh aplikacij"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Spremenite nastavitve za vsako aplikacijo, ki lahko pošilja obvestila."</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Aplikacije, prikazane v napravi"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Ta aplikacija ne podpira naprednih nastavitev."</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Več nastavitev"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Več nastavitev je na voljo v tej aplikaciji."</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Storitve za pomoč za VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nobena nameščena aplikacija ni zahtevala izvajanja kot storitev za pomoč za VR."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Dovolite storitvi <xliff:g id="SERVICE">%1$s</xliff:g> dostop za storitev za VR?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"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="4850474436291113569">"Ko je naprava v načinu VR"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Zmanjšanje zameglitve (priporočeno)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Zmanjšanje utripanja"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Slika v sliki"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Nobena aktivna aplikacija ne podpira načina slike v sliki"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip slika v sliki"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Slika v sliki"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Dovoli sliko v sliki"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Omogočite tej aplikaciji, da ustvari okno s sliko v sliki, medtem ko je aplikacija odprta ali potem ko jo zapustite (na primer, da nadaljujete ogled videoposnetka). To okno prekrije druge aplikacije, ki jih uporabljate."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Povezane delovne in osebne aplikacije"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Povezano"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Ni povezano"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Ni povezanih aplikacij"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"za več profilov povezana aplikacija aplikacije delovne in osebne"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Povezano"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Poveži ti aplikaciji"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Povezane aplikacije si delijo dovoljenja in imajo dostop do podatkov druga druge."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Aplikaciji povežite le, če ste prepričani, da ne bosta delili osebnih podatkov s skrbnikom za IT."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Povezavo med aplikacijami lahko kadar koli prekinete v nastavitvah zasebnosti za napravo."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Ali želite delovni aplikaciji <xliff:g id="NAME">%1$s</xliff:g> zaupati osebne podatke?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Aplikaciji povežite le, če ste prepričani, da ne bosta delili osebnih podatkov s skrbnikom za IT."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Podatki aplikacij"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Ta aplikacija lahko dostopa do podatkov v osebni aplikaciji <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Dovoljenja"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Ta aplikacija lahko uporablja dovoljenja osebne aplikacije <xliff:g id="NAME">%1$s</xliff:g>, kot je dostop do lokacije, shrambe ali stikov."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Ni povezanih aplikacij"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# aplikacija je povezana.}one{# aplikacija je povezana.}two{# aplikaciji sta povezani.}few{# aplikacije so povezane.}other{# aplikacij je povezanih.}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Če želite povezati ti aplikaciji, namestite aplikacijo <xliff:g id="NAME">%1$s</xliff:g> v delovni profil"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Če želite povezati ti aplikaciji, namestite aplikacijo <xliff:g id="NAME">%1$s</xliff:g> v osebni profil"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Dotaknite se za prenos aplikacije."</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Dostop do načina »Ne moti«"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Dovoli način »Ne moti«"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Nobena nameščena aplikacija ni zahtevala dostopa do načina »Ne moti«"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Niste dovolili obvestil te aplikacije"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Na vašo zahtevo je prikazovanje te kategorije obvestil blokirano v tej napravi Android"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Na vašo zahtevo je prikazovanje te skupine obvestil blokirano v tej napravi Android"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Ta aplikacija ne pošilja obvestil."</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorije"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Drugo"</string>
    <string name="no_channels" msgid="4716199078612071915">"Ta aplikacija ni objavila nobenih obvestil."</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Dodatne nastavitve v aplikaciji"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# kategorija je izbrisana.}one{# kategorija je izbrisana.}two{# kategoriji sta izbrisani.}few{# kategorije so izbrisane.}other{# kategorij je izbrisanih.}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokiraj vse"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Nikoli ne prikaži teh obvestil"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Pokaži obvestila"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nikoli ne pokaži obvestil na zaslonu z obvestili ali v zunanjih napravah."</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Dovoli obvestilno piko"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Pokaži obvestilno piko"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Preglasi način »Ne moti«"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Dovoli prikazovanje teh obvestil tudi, ko je vklopljen način »Ne moti«."</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Na zaklenjenem zaslonu"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Končano"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Utripajoča lučka"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibriranje"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Zvok"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prednostno"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Ime razporeda"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Vnesite ime razporeda"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Ime razporeda je že v uporabi"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Dodajte več"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Dodajte razpored za dogodek"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Dodajte časovni razpored"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Izberite vrsto razporeda"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Želite izbrisati pravilo »<xliff:g id="RULE">%1$s</xliff:g>«?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Izbriši"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Teh nastavitev trenutno ni mogoče spremeniti. Aplikacija (<xliff:g id="APP_NAME">%1$s</xliff:g>) je samodejno vklopila način »Ne moti« z delovanjem po meri."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Teh nastavitev trenutno ni mogoče spremeniti. Aplikacija je samodejno vklopila način »Ne moti« z delovanjem po meri."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Teh nastavitev trenutno ni mogoče spremeniti. Način »Ne moti« je bil ročno vklopljen z delovanjem po meri."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Čas"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Dogodek"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Med dogodki za"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Kateri koli koledar"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Kjer je odgovor"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"»Da«, »Mogoče« ali »Neodgovorjeno«"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"»Da« ali »Mogoče«"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"»Da«"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Pravila ni mogoče najti."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Vklopljeno/<xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Dnevi"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Brez"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarm lahko razveljavi končni čas"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Razpored se izklopi, ko alarm zazvoni."</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Vedenje načina »Ne moti«"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Uporabi privzete nastavitve"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Ustvari nastavitve po meri za ta razpored"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Za »<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>«"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g>–<xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Pogovori"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Vsi pogovori"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prednostni pogovori"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prednostni pogovori"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Noben"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Noben}=1{1 pogovor}one{# pogovor}two{# pogovora}few{# pogovori}other{# pogovorov}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kdo lahko preglasi"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Tudi če vam aplikacije za sporočanje ali klicanje ne morejo poslati obvestila, boste za osebe, ki jih tukaj izberete, kljub temu dosegljivi prek teh aplikacij."</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Klici"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Klici"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"klici"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Klici, ki lahko preglasijo"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Če se želite prepričati, da bo telefon zvonil, ko prejmete dovoljene klice, preverite, ali je naprava nastavljena na zvonjenje."</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Dohodni klici za »<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>« so blokirani. Nastavitve lahko prilagodite tako, da boste dosegljivi za prijatelje, družinske člane ali druge stike."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Stiki z zvezdico"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Noben}=1{{contact_1}}=2{{contact_1} in {contact_2}}=3{{contact_1}, {contact_2} in {contact_3}}one{{contact_1}, {contact_2} in še # drug}two{{contact_1}, {contact_2} in še # druga}few{{contact_1}, {contact_2} in še # drugi}other{{contact_1}, {contact_2} in še # drugih}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Ni imena)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Sporočila"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"sporočila"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Sporočila"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Sporočila, ki lahko preglasijo"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Če se želite prepričati, da bo telefon zvonil, ko prejmete dovoljena sporočila, preverite, ali je naprava nastavljena na zvonjenje."</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Dohodna sporočila za »<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>« so blokirana. Nastavitve lahko prilagodite tako, da boste dosegljivi za prijatelje, družinske člane ali druge stike."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Vsa sporočila vas lahko dosežejo"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Vsi klici vas lahko dosežejo"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Noben}=1{1 stik}one{# stik}two{# stika}few{# stiki}other{# stikov}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Vsi"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Stiki"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Stiki z zvezdico"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Noben klic"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Nobeno sporočilo"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmi"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Obvestila o časovnikih, alarmih, varnostnih sistemih in drugih aplikacijah"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmi"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmi"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Zvoki predstavnosti"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Zvoki videoposnetkov, iger in druge predstavnosti"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"predstavnost"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Predstavnost"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Zvoki dotikov"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Zvoki tipkovnice in drugih gumbov"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"zvoki dotikov"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Zvoki dotikov"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Opomniki"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Obvestila o opravilih in opomnikih"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"opomniki"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Opomniki"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Dogodki v koledarju"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Obvestila o prihajajočih dogodkih v koledarju"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"dogodki"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Dogodki"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Aplikacijam dovoli preglasitev"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplikacije, ki lahko preglasijo"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Izberite več aplikacij"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Ni izbranih aplikacij"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Nobena aplikacija ne sme preglasiti"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Dodajte aplikacije"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Vsa obvestila"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Nekatera obvestila"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Izbrane osebe vas lahko še vedno dosežejo, tudi če aplikacijam ne dovolite preglasitve."</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Nobena aplikacija ne sme preglasiti}=1{Aplikacija {app_1} lahko preglasi}=2{Aplikaciji {app_1} in {app_2} lahko preglasita}=3{Aplikacije {app_1}, {app_2}in {app_3} lahko preglasijo}one{Aplikaciji {app_1} in {app_2} ter še # druga lahko preglasijo}two{Aplikaciji {app_1} in {app_2} ter še # drugi lahko preglasijo}few{Aplikaciji {app_1} in {app_2} ter še # druge lahko preglasijo}other{Aplikaciji {app_1} in {app_2} ter še # drugih lahko preglasijo}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplikacije"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Obvestila, ki lahko preglasijo"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Dovoli vsa obvestila"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nič ne sme preglasiti}=1{Preglasitev dovoljena za: {sound_category_1}}=2{Preglasitev dovoljena za: {sound_category_1} in {sound_category_2}}=3{Preglasitev dovoljena za: {sound_category_1}, {sound_category_2} in {sound_category_3}}one{Preglasitev dovoljena za: {sound_category_1}, {sound_category_2} in še # drugo vrsto zvoka}two{Preglasitev dovoljena za: {sound_category_1}, {sound_category_2} in še # drugi vrsti zvoka}few{Preglasitev dovoljena za: {sound_category_1}, {sound_category_2} in še # druge vrste zvoka}other{Preglasitev dovoljena za: {sound_category_1}, {sound_category_2} in še # drugih vrst zvoka}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nič ne sme preglasiti"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Nihče ne sme preglasiti"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Nekatere osebe lahko preglasijo"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Vsakdo lahko preglasi"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Klicatelji, ki večkrat kličejo"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Dovoli večkratne klicatelje"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"vseh"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"stikov"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"stiki z zvezdico"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"klicatelji, ki večkrat kličejo"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> in <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Če ista oseba kliče že drugič v <xliff:g id="MINUTES">%d</xliff:g> min."</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Ura začetka"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Ura konca"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> naslednji dan"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Sprememba na samo alarme za nedoločen čas"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Sprememba na samo alarme za eno minuto do {time}}one{Sprememba na samo alarme za # minuto (do {time})}two{Sprememba na samo alarme za # minuti (do {time})}few{Sprememba na samo alarme za # minute (do {time})}other{Sprememba na samo alarme za # minut (do {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Sprememba na samo alarme za eno uro do {time}}one{Sprememba na samo alarme za # uro do {time}}two{Sprememba na samo alarme za # uri do {time}}few{Sprememba na samo alarme za # ure do {time}}other{Sprememba na samo alarme za # ur do {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Sprememba na samo alarme do <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Sprememba na vedno prekini"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Opozorilo"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Zapri"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Povratne informacije o tej napravi"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Vnos skrbniške kode PIN"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Vklopljeno"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Izklopljeno"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Vklopljeno"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Izklopljeno"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Vklopljeno"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Izklopljeno"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Pripenjanje aplikacije"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Pripenjanje aplikacije omogoča, da trenutna aplikacija ostane vidna, dokler je ne odpnete. To funkcijo lahko na primer uporabite, če želite prijatelju, ki mu zaupate, dovoliti igranje določene igre."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Ko je aplikacija pripeta, lahko ta odpre druge aplikacije, prav tako pa so lahko dostopni osebni podatki. \n\nČe želite uporabiti pripenjanje aplikacije, storite to: 	\n1. Vklopite pripenjanje aplikacije. 	\n2. Odprite »Pregled«. 	\n3. Dotaknite se ikone aplikacije na vrhu zaslona, nato pa se dotaknite »Pripni«."</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Ko je aplikacija pripeta, lahko ta odpre druge aplikacije, prav tako pa so lahko dostopni osebni podatki. \n\nČe želite varno deliti svojo napravo z drugimi, namesto tega uporabite gosta. \n\nČe želite uporabiti pripenjanje aplikacije, storite to: 	\n1. Vklopite pripenjanje aplikacije. 	\n2. Odprite »Pregled«. 	\n3. Dotaknite se ikone aplikacije na vrhu zaslona, nato pa se dotaknite »Pripni«."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Ko je aplikacija pripeta: \n\n• Dostopni so lahko osebni podatki \n (na primer stiki in vsebina e-poštnih sporočil). \n• Pripeta aplikacija lahko odpre druge aplikacije. \n\nPripenjanje aplikacij uporabite le za osebe, ki jim zaupate."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Pred odpenjanjem vprašaj za vzorec za odklepanje"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Zahtevaj PIN pred odpenjanjem"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Pred odpenjanjem vprašaj za geslo"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Pri odpenjanju zakleni napravo"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Potrdi brisanje kartice SIM"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Pred izbrisom kartice e-SIM potrdite, da ste to res vi."</string>
    <string name="memtag_title" msgid="5096176296797727201">"Napredna zaščita pomnilnika – beta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Napredna zaščita pomnilnika"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Ta funkcija v različici beta ščiti napravo pred napakami, ki bi lahko ogrozile varnost."</string>
    <string name="memtag_on" msgid="824938319141503923">"Vklopljeno"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Izklopljeno"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Vklop po vnovičnem zagonu"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Izklop po vnovičnem zagonu"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Trenutno ni na voljo za vašo napravo"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Vedno vklopljeno za vašo napravo"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Za vklop ali izklop napredne zaščite pomnilnika boste morali znova zagnati napravo. Ko je zaščita vklopljena, boste morda opazili počasnejše delovanje naprave."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Želite znova zagnati napravo?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Za vklop napredne zaščite pomnilnika boste morali znova zagnati napravo."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Za izklop napredne zaščite pomnilnika boste morali znova zagnati napravo."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Znova zaženi"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Ne zdaj"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Preberite več o napredni zaščiti pomnilnika."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Ta delovni profil upravlja:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Upravlja: <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Privzeto odpiranje"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Odpri podprte povezave"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Dovoli odpiranje spletnih povezav v tej aplikaciji."</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Povezave za odpiranje v tej aplikaciji"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Podprte povezave"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Druge privzete nastavitve"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Dodajte povezavo"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Aplikacija lahko preveri povezave za samodejno odpiranje v aplikaciji."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# preverjena povezava}one{# preverjena povezava}two{# preverjeni povezavi}few{# preverjene povezave}other{# preverjenih povezav}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Ta povezava je preverjena in se samodejno odpre v tej aplikaciji.}one{Te povezave so preverjene in se samodejno odprejo v tej aplikaciji.}two{Ti povezavi sta preverjeni in se samodejno odpreta v tej aplikaciji.}few{Te povezave so preverjene in se samodejno odprejo v tej aplikaciji.}other{Te povezave so preverjene in se samodejno odprejo v tej aplikaciji.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"V redu"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Prikaz seznama preverjenih povezav"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Iskanje drugih podprtih povezav …"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Prekliči"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# podprta povezava}one{# podprta povezava}two{# podprti povezavi}few{# podprte povezave}other{# podprtih povezav}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Dodaj"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Odpre se v aplikaciji <xliff:g id="APP_LABEL">%s</xliff:g>."</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"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="979243131665635278">"notranja shramba"</string>
    <string name="storage_type_external" msgid="125078274000280821">"zunanja shramba"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"Preneseno <xliff:g id="SIZE">%1$s</xliff:g> od <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Uporabljena shramba"</string>
    <string name="change" msgid="273206077375322595">"Sprememba"</string>
    <string name="change_storage" msgid="8773820275624113401">"Sprememba shrambe"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Obvestila"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Vklopljeno"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Izklopljeno"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# izklopljena kategorija}one{# izklopljena kategorija}two{# izklopljeni kategoriji}few{# izklopljene kategorije}other{# izklopljenih kategorij}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# dodatno dovoljenje}one{# dodatno dovoljenje}two{# dodatni dovoljenji}few{# dodatna dovoljenja}other{# dodatnih dovoljenj}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Ni odobrenih dovoljenj"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Ni zahtevanih dovoljenj"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Nadzorujte dostop aplikacij do podatkov."</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Nadzorna plošča za zasebnost"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Prikažite aplikacije, ki so pred kratkim uporabile dovoljenja."</string>
    <string name="unused_apps" msgid="4566272194756830656">"Neuporabljene aplikacije"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# neuporabljena aplikacija}one{# neuporabljena aplikacija}two{# neuporabljeni aplikaciji}few{# neuporabljene aplikacije}other{# neuporabljenih aplikacij}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Nastavitve neuporabljenih aplikacij"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Zaustavi dejavnost aplikacije ob neuporabi"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Dovoljenja se odstranijo, začasne datoteke se izbrišejo in prikazovanje obvestil se ustavi."</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Vse aplikacije"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Nameščene aplikacije"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Nenamestljive aplikacije"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Izklopljeno"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Dodatno"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Upravitelj dovoljenj"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Posodobitve deljenja podatkov o lokaciji"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Pregled aplikacij s spremembami v načinu deljenja vaših lokacijskih podatkov"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Dot. za prekl. iz stan. pripr."</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Za preklop naprave iz stanja pripravljenosti se dvakrat dotaknite kjer koli na zaslonu"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Odpiranje povezav"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Brez odpiranja podprtih povezav"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Odpre <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Odpiranje naslova <xliff:g id="DOMAIN">%s</xliff:g> in drugih URL-jev"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Aplikaciji je dovoljeno odpiranje podprtih povezav."</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Vedno vprašaj"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Aplikaciji ni dovoljeno odpiranje povezav"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Aplikacija naj bi odpirala # povezavo.}one{Aplikacija naj bi odpirala # povezavo.}two{Aplikacija naj bi odpirala # povezavi.}few{Aplikacija naj bi odpirala # povezave.}other{Aplikacija naj bi odpirala # povezav.}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplikacija naj bi odpirala te povezave:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Pomoč in glasovni vnos"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digitalni pomočnik"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Privzeti digitalni pomočnik"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Strinjam se"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Brskalnik"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplikacija za telefon"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistemska)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Shramba za aplikacije"</string>
    <string name="usage_access" msgid="5487993885373893282">"Dostop do podatkov o uporabi"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Dovoli dostop do podatkov o uporabi"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Čas uporabe"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"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="6582588646363308430">"Pomnilnik"</string>
    <string name="always_running" msgid="9012705720688200252">"Vedno se izvaja (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Včasih se izvaja (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Redko se izvaja (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimizacija baterije"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Ni optimizirano"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Ni optimizirano"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimizacija porabe baterije"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimizacija baterije ni na voljo"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Želite omogočiti stalno izvajanje aplikacije v ozadju?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Če aplikaciji <xliff:g id="APP_NAME">%1$s</xliff:g> omogočite stalno izvajanje v ozadju, lahko to skrajša čas delovanja baterije. \n\nTo lahko pozneje spremenite v »Nastavitve &gt; Aplikacije«."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> porabe od zadnje polne napolnjenosti."</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"Poraba za zadnjih 24 ur: <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Baterija ni bila uporabljena od zadnje polne napolnjenosti."</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Želite deliti poročilo o napakah?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Skrbnik za IT je zahteval poročilo o napakah za pomoč pri odpravljanju napak v tej napravi. Aplikacije in podatki bodo morda deljeni."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Skrbnik za IT je zahteval poročilo o napakah za pomoč pri odpravljanju napak v tej napravi. Aplikacije in podatki bodo morda deljeni in delovanje naprave bo morda začasno upočasnjeno."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"To poročilo o napakah je deljeno s skrbnikom za IT. Če želite več podrobnosti, se obrnite nanj."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Deli"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Zavrnitev"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Brez prenosa podatkov"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Polnjenje priključene naprave"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Prenos datotek"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Spletna kamera"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Pretvorba videoposnetkov v AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videoposnetki se bodo predvajali v več predvajalnikih predstavnosti, vendar bo kakovost morda nižja."</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Internet prek USB-ja"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Uporaba povezave USB za"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Privzeta konfiguracija povezave USB"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Te nastavitve bodo uporabljene, ko bo telefon odklenjen in povezan z drugo napravo. Telefon povežite samo z zaupanja vrednimi napravami."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Možnosti napajanja"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Možnosti prenosa datotek"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Nastavitve USB-ja"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"Povezavo USB upravlja"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Povezana naprava"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Ta naprava"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Preklapljanje …"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Preklop ni uspel"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Polnjenje te naprave"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Polnjenje baterije v povezani napravi"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Prenos datotek"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Internet prek USB-ja"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Spletna kamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Prenos datotek in napajanje"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Internet in napajanje prek USB-ja"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP in napajanje"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI in napajanje"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Spletna kamera in napajanje"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Preverjanje ozadja"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Uporabi besedilo na zaslonu"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Aplikaciji za pomoč dovoli dostop do vsebine na zaslonu v obliki besedila."</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Uporabi posnetek zaslona"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Aplikaciji za pomoč dovoli dostop do posnetka zaslona."</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Utripanje zaslona"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Utripanje robov zaslona, ko aplikacija za pomoč dostopa do besedila z zaslona ali posnetka zaslona."</string>
    <string name="assist_footer" msgid="8248015363806299068">"Aplikacije za pomoč vam lahko pomagajo na podlagi podatkov na zaslonu, ki si ga ogledujete. Nekatere aplikacije podpirajo storitve zaganjalnika in glasovnega vnosa in vam tako zagotavljajo celovito pomoč."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Povprečna uporaba pomnilnika"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Največja uporaba pomnilnika"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Uporaba pomnilnika"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Uporaba aplikacije"</string>
    <string name="memory_details" msgid="6133226869214421347">"Podrobnosti"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Povprečno <xliff:g id="SIZE">%1$s</xliff:g> uporabljenega pomnilnika v zadnjih 3 urah"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"V zadnjih 3 urah ni bilo uporabe pomnilnika"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Razvrsti glede na povprečno uporabo"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Razvrsti glede na največjo uporabo"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Izvajanje"</string>
    <string name="total_memory" msgid="5244174393008910567">"Pomnilnik – skupno"</string>
    <string name="average_used" msgid="690235917394070169">"Povprečno uporabljeno (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Prosto"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Pomnilnik, ki ga uporabljajo aplikacije"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 aplikacija je uporabljala pomnilnik v zadnjega toliko časa: {time}.}one{# aplikacija je uporabljala pomnilnik v zadnjega toliko časa: {time}.}two{# aplikaciji sta uporabljali pomnilnik v zadnjega toliko časa: {time}.}few{# aplikacije so uporabljale pomnilnik v zadnjega toliko časa: {time}.}other{# aplikacij je uporabljalo pomnilnik v zadnjega toliko časa: {time}.}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frekvenca"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Največja uporaba"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Ni bilo prenosa podatkov."</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Dovolite aplikaciji <xliff:g id="APP">%1$s</xliff:g> dostop do funkcije »Ne moti«?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplikacija bo lahko vklopila/izklopila način »Ne moti« in spreminjala povezane nastavitve."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Mora biti vklopljeno, ker je vklopljen dostop do obvestil."</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Ž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="8689801842914183595">"Vsa pravila za način »Ne moti«, ki jih je ustvarila ta aplikacija, bodo odstranjena."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Brez optimizacije"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizacija"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Baterija se lahko hitreje izprazni. Aplikaciji ne bo več preprečena poraba energije baterije v ozadju."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Priporočljivo za daljši čas delovanja baterije"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Nobena aplikacija"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Č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="draw_overlay" msgid="7902083260500573027">"Prekrivanje drugih aplikacij"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Prekrivanje drugih aplikacij"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Dovoli prekrivanje drugih aplikacij"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Omogočite tej aplikaciji, da na zaslonu prekrije druge aplikacije, ki jih uporabljate. Ta aplikacija bo lahko spremljala dotike zaslona ali spreminjala prikaz na zaslonu."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Dostop do vseh datotek"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Dovoli dostop za upravljanje vseh datotek"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Tej aplikaciji dovolite, da bere, spreminja in briše vse datoteke v tej napravi ali drugih povezanih nosilcih za shranjevanje. Če daste to dovoljenje, bo aplikacija morda dostopala do datotek brez vaše vednosti."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Lahko dostopa do vseh datotek"</string>
    <string name="full_screen_intent_title" msgid="1068024949389956404">"Upravljanje celozasl. namenskih obvestil"</string>
    <string name="permit_full_screen_intent" msgid="2251949245519201421">"Aplikacijam dovoli pošiljanje celozaslonskih namenskih obvestil"</string>
    <string name="footer_description_full_screen_intent" msgid="8322826300555418227">"Tej aplikaciji dovolite pošiljanje celozaslonskih namenskih obvestil, ki prekrivajo celoten zaslon."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Aplikacije za upravljanje predstavnosti"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Aplikaciji dovoli upravljanje predstavnosti"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Pri vklopljenem dovoljenju lahko ta aplikacija brez vaše vednosti spreminja ali briše predstavnostne datoteke, ustvarjene z drugimi aplikacijami. Aplikacija mora imeti dovoljenje za dostop do datotek in predstavnosti."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"predstavnost, datoteka, upravljanje, upravitelj, upravljati, urejati, urejevalnik, aplikacija, program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr navidezna resničnost poslušalec stereo storitev za pomoč"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Prekrivanje drugih aplikacij"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplikacije z dovoljenjem"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Dovoljeno"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Ni dovoljeno"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"nameščanje aplikacij neznani viri"</string>
    <string name="write_settings" msgid="6864794401614425894">"Spreminjanje sist. nastavitev"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"zapisovanje spreminjanje sistemske nastavitve"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Lahko namestijo druge aplikacije"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Lahko spreminjajo sistemske nastavitve"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Lahko spreminjajo sistemske nastavitve"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Spreminjanje sist. nastavitev"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Dovoli spreminjanje sistemskih nastavitev"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"To dovoljenje aplikaciji dovoljuje spreminjanje sistemskih nastavitev."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Dovoli aplikacije iz tega vira"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Dvakratno sukanje za fotoaparat"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Odprite aplikacijo za fotografiranje, tako da dvakrat zasukate zapestje"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Velikost prikaza"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Povečava ali pomanjšava vsega na zaslonu"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"gostota zaslona, povečava zaslona, razmerje, spreminjanje velikosti"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Predogled"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Pomanjšanje"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Povečanje"</string>
    <string name="disconnected" msgid="3469373726996129247">"Povezava ni vzpostavljena"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Ni priključena"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Nameščenih aplikacij: <xliff:g id="COUNT">%1$d</xliff:g>"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> uporabljeno – <xliff:g id="FREE_SPACE">%2$s</xliff:g> prosto"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Temna tema, velikost pisave, svetlost"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Povprečna uporaba pomnilnika: <xliff:g id="USED_MEMORY">%1$s</xliff:g> od <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Prijavljeni ste kot: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Posodobljeno na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Na voljo je posodobljena različica"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Blokirano s službenim pravilnikom"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Spreminjanje glasnosti ni mogoče"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Ni mogoče klicati"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Ni mogoče pošiljati sporočil SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Fotoaparata ni mogoče uporabljati"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Ni mogoče delati posnetkov zaslona"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Te aplikacije ni mogoče odpreti"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokiral posojilodajalec"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Potrebuješ starša"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Za začetek nastavljanja te funkcije daj telefon staršu."</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Telefon daj staršu, da bo omogočil spreminjanje te nastavitve."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Za več informacij se obrnite na skrbnika za IT."</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Več podrobnosti"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"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="4929926887231544950">"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="5503131744126520590">"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="admin_financed_message" msgid="1156197630834947884">"Skrbnik naprave morda lahko dostopa do podatkov, povezanih s to napravo, upravlja aplikacije in spreminja nastavitve naprave."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Izklopi"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Vklop"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Prikaz"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Skrivanje"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Dostopna točka je aktivna"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Vklopljen je način za letalo"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Omrežja niso na voljo"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Način »Ne moti« je vklopljen"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Zvok telefona je izklopljen"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Z izjemami"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Varč. z energijo bat. je vkl."</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funkcije so omejene"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobilni podatki so izklopljeni"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Dostop do interneta je na voljo le prek omrežja Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Varčevanje s podatki"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funkcije so omejene"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Delovni profil je izklopljen"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Za aplikacije in obvestila"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Vklop zvoka"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Zvok zvonjenja je izklopljen"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Za klice in obvestila"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Samo vibriranje"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Za klice in obvestila"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Nastavi razpored za nočno svetlobo"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Samodejno obarvanje zaslona vsak večer"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Nočna svetloba je vklopljena"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Zaslon ima jantarni odtenek"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Sivine"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Prikaz samo v sivih barvah"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Strni"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Hladnejša barvna temperatura"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Uporaba hladnejših barv zaslona"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Če želite uveljaviti spremembo barv, izklopite zaslon"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Lasersko tipalo fotoaparata"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Samodejne sistemske posodobitve"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Namesti posodobitve ob vnovičnem zagonu naprave."</string>
    <string name="usage" msgid="287782903846013936">"Poraba"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Prenos mobilnih podatkov"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Prenos podatkov aplikacij"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Preneseni podatki (Wi-Fi)"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Prenesena količina podatkov zunaj omrežij operaterjev"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Preneseni podatki (ethernet)"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> podatkov v mobilnem omrežju"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> podatkov prek omrežij Wi-Fi"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> podatkov prek etherneta"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Opozorilo in omejitev za prenos podatk."</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Cikel prenosa mobilnih podatkov"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Opozorilo pri <xliff:g id="ID_1">^1</xliff:g> prenesenih podatkov"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Omejitev prenosa podatkov pri <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Opozorilo ob preneseni količini podatkov <xliff:g id="ID_1">^1</xliff:g>/omejitev prenosa podatkov pri <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="operator_warning" msgid="5672761970087591211">"Operaterjeve meritve prenosa podatkov so morda drugačne kot v napravi."</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Ne vključuje podatkov, ki jih uporabljajo omrežja operaterjev."</string>
    <string name="data_used_template" msgid="8229342096562327646">"Preneseno: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Nastavi opozorilo za prenos podatkov"</string>
    <string name="data_warning" msgid="2925054658166062884">"Opozorilo za prenos podatkov"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Preneseno količino podatkov za opozorilo in omejitev prenosa podatkov meri vaša naprava. Ti podatki se lahko razlikujejo od podatkov operaterja."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Nastavi omej. prenosa pod."</string>
    <string name="data_limit" msgid="8731731657513652363">"Omejitev prenosa podatkov"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> preneseno v obdobju <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfiguriranje"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Druge aplikacije, vključene v prikaz porabe"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen 1 aplikaciji.}one{Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen # aplikaciji.}two{Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen # aplikacijama.}few{Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen # aplikacijam.}other{Ko je vklopljeno varčevanje s podatki, je neomejen prenos podatkov dovoljen # aplikacijam.}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Glavni podatki"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Podatki prek omrežij Wi‑Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Preneseno: <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Prekoračeno za <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Preostalo: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafikon prikazuje prenesene količine podatkov v obdobju od <xliff:g id="START_DATE">%1$s</xliff:g> do <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Ni podatkov za to obdobje"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Še # dan}one{Še # dan}two{Še # dneva}few{Še # dni}other{Še # dni}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Ni preostalega časa"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Še manj kot 1 dan"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Posodobil <xliff:g id="ID_1">^1</xliff:g> pred <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Posodobljeno pred <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Pravkar posodobil <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Pravkar posodobljeno"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Prikaži paket"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Ogled podrobnosti"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Varčevanje s podatki"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neomejen prenos podatkov"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Prenos podatkov v ozadju je izklopljen"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Vklopljeno"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Izklopljeno"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Uporabi varčevanje s podatki"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neomejen podatkovni prenos"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Dovoli neomejen podatkovni dostop, ko je vklopljeno varčevanje s podatki."</string>
    <string name="home_app" msgid="6056850504746902747">"Aplikacija na začetnem zaslonu"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Dodajte nov prstni odtis"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Odklepanje z drugim prstom"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Vklopljeno"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Vklop pri <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Izklopljeno"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Poraba energije baterije za aplikacijo"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Nastavitev porabe energije baterije za aplikacije"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Neomejeno"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimizirano"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Omejeno"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Privzeti črkovalnik"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Izbira črkovalnika"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Uporabi črkovalnik"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Ni izbrano"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"ključ"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"skupina"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(povzetek)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"različica za javnost"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"pomembnost"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"razlaga"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"lahko pokaže značko"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"namen"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"izbris namena"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"namen za celozaslonski način"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"dejanja"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"naziv"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"oddaljeni vhodi"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"pogled po meri"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"dodatki"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"velikost paketa"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"opozorjeno z obvestilom"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Manjka predmet za uvrščanje."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Predmet za uvrščanje ne vsebuje tega ključa."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Zareza zaslona"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"izrez prikaza"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Privzeta nastavitev naprave"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Prekrivanje ni uspelo"</string>
    <string name="special_access" msgid="1767980727423395147">"Posebni dostop za aplikacije"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <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="special_access_more" msgid="132919514147475846">"Prikaži več"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Dolgotrajna opravila v ozadju"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Dovoli dolgotrajna opravila v ozadju"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Dolgotrajna opravila v ozadju"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Tej aplikaciji dovolite izvajanje dolgotrajnih opravil v ozadju. Aplikacija bo tako lahko izvajala opravila, ki morda trajajo več kot nekaj minut, na primer prenašanje iz strežnika ali nalaganje v strežnik. \n\nČe to dovoljenje ni odobreno, sistem določa, kako dolgo lahko aplikacija izvaja takšna opravila v ozadju."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"dolgotrajna opravila, prenos podatkov, opravila v ozadju"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Ponastavitev omejevanja hitrosti za ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Omejevanje hitrosti za ShortcutManager je ponastavljeno"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Upravljanje podatkov na zaklenjenem zaslonu"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Prikaz ali skrivanje vsebine obvestil"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Nasveti in podpora"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Najmanjša širina"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Nobena nameščena aplikacija ni zahtevala dostopa za plačljiva sporočila SMS."</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"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="5605970342699013212">"Dostop za plačljiva sporočila SMS"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Izklopljeno"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Povezan z: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Povezan z več napravami"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Predstavitveni način uporabniškega vmesnika sistema"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Temna tema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Začasno onemogočeno zaradi varčevanja z energijo baterije"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Začasno onemogočeno zaradi varčevanja z energijo baterije."</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Izklopi varčevanje z energijo baterije"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Začasno vklopljeno zaradi varčevanja z energijo baterije"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Preizkusite temno temo"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Podaljša čas delovanja baterije"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Ploščice razvijalcev za hitre nastavitve"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Onemogoči časovno omejitev pooblastila ADB"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Onemogoči samodejni preklic pooblastil ADB za sisteme, ki niso znova vzpostavili povezave v privzetem času (7 dni) ali v uporabniško konfiguriranem času (najmanj 1 dan)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Sledenje z apl. Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Izklop tipal"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Nastavitve delovnega profila"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Iskanje stikov v delovnem imeniku prek osebnih aplikacij"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Iskanja in dohodni klici so lahko vidni vašemu skrbniku za IT."</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Koledar za več profilov"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Prikaz delovnih dogodkov v osebnem koledarju"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Upravljanje shrambe"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"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="5077286114860539367">"Odstranjevanje fotografij in videoposnetkov"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Upravitelj shrambe"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Uporaba upravitelja shrambe"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Poteze"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Hitro odpiranje fotoaparata"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Če želite hitro odpreti fotoaparat, dvakrat pritisnite gumb za vklop. Deluje na vsakem zaslonu."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Zasuk fotoaparata za selfije"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Način krmarjenja"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Krmarjenje z dvema gumboma"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Za preklop med aplikacijami povlecite navzgor po gumbu za začetni zaslon. Za ogled vseh aplikacij znova povlecite navzgor. Za vrnitev se dotaknite gumba za nazaj."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Varnost in nujni primeri"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Klic v sili, zdravstveni podatki, opozorila"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Krmarjenje s potezami"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Za vrnitev na začetni zaslon povlecite z dna zaslona navzgor. Za preklop med aplikacijami povlecite z dna zaslona navzgor, pridržite in spustite. Za pomik nazaj povlecite z levega ali desnega roba."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Krmarjenje s tremi gumbi"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Za pomik nazaj, vrnitev na začetni zaslon in preklop med aplikacijami uporabite gumbe na dnu zaslona."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"krmarjenje po sistemu, krmarjenje z dvema gumboma, krmarjenje s tremi gumbi, krmarjenje s potezami, vlečenje"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitalni pomočnik"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Vlečenje za sproženje pomočnika"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Če želite sprožiti digitalnega pomočnika, s prstom povlecite navzgor iz spodnjega kota."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Priklic Pomočnika s pridržanjem gumba za začetni zaslon"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Pridržite gumb za začetni zaslon, če želite priklicati digitalnega pomočnika."</string>
    <string name="low_label" msgid="6525629096999711220">"Nizka"</string>
    <string name="high_label" msgid="357503396626018487">"Visoka"</string>
    <string name="left_edge" msgid="1513576842959071849">"Levi rob"</string>
    <string name="right_edge" msgid="1505309103265829121">"Desni rob"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Višja občutljivost bo morda ovirala izvajanje potez ob robovih zaslona v aplikaciji."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Občutljivost poteze za nazaj"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Občutljivost krmarjenja s potezami"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Krmarjenje z gumbi"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"krmarjenje s potezami, občutljivost poteze za nazaj, poteza za nazaj"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"krmarjenje, gumb za začetni zaslon"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Enoročni način"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Uporabi enoročni način"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Bližnjica za enoročni način"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"dosegljivost"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Povlecite navzdol za"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Uporaba bližnjice za"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Zgornjo polovico zaslona povlecite navzdol, da ga boste lažje dosegli z eno roko."</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Uporaba enoročnega načina"</b>\n" • Prepričajte se, da je v nastavitvah krmarjenja po sistemu izbrano krmarjenje s potezami.\n • Povlecite navzdol pri spodnjem robu zaslona."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Približanje dela zaslona na doseg"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Vrh zaslona se pomakne na doseg palca."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Prikaz obvestil"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Prikažejo se obvestila in nastavitve."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Če želite preveriti uro, obvestila in druge informacije, se dvakrat dotaknite zaslona."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Preklop zaslona iz stanja pripravljenosti"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Če želite preveriti uro, obvestila in druge informacije, se dotaknite zaslona."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Nujni primer"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Klicanje na pomoč v nujnem primeru"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Za zagon spodaj navedenih dejanj vsaj petkrat hitro pritisnite gumb za vklop."</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Predvajanje alarma z odštevanjem"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Predvajaj glasni zvok ob začetku klicanja na pomoč v nujnem primeru."</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Obvestilo za pomoč"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Klic za pomoč"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Številka za klic za pomoč"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Dotaknite se, da spremenite"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Če vnesete številko, ki ni za klic v sili:\n • naprava mora biti odklenjena, če želite uporabiti klic za pomoč v nujnem primeru;\n • na vaš klic morda nihče ne bo odgovoril."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Poteg s prstom po tipalu prstnih odtisov za prikaz obvestil"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Poteg po prstnem tipalu"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Hiter ogled obvestil"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Vklopljeno"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Izklopljeno"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Nalagalnik zagona je že odklenjen."</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Povežite se z internetom ali se obrnite na operaterja"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Ni na voljo v napravah, zaklenjenih na operaterja"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Znova zaženite napravo, da omogočite funkcijo zaščite naprave."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"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="6654581786741216382">"Nenamestljive aplikacije"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Odpri povezave v aplikacijah, tudi če niso nameščene."</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Nenamestljive aplikacije"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Nastavitve nenamestljivih aplikacij"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Nameščene aplikacije"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Shrambo zdaj upravlja upravitelj shrambe"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Računi uporabnika »<xliff:g id="USER_NAME">%1$s</xliff:g>«"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Samodejno sinhroniziranje podatkov aplikacij"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Omogoči, da aplikacije samodejno osvežijo podatke."</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sinhronizacija računa"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sinhronizacija je vklopljena za <xliff:g id="ID_1">%1$d</xliff:g> od <xliff:g id="ID_2">%2$d</xliff:g> elementov"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sinhronizacija je vklopljena za vse elemente"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinhronizacija je izklopljena za vse elemente"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Podatki o upravljani napravi"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Spremembe in nastavitve, ki jih upravlja vaša organizacija"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Spremembe in nastavitve, ki jih upravlja <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"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="2507761423540037308">"Vrste podatkov, ki jih vidi vaša organizacija"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Spremembe, ki jih je izvedel skrbnik vaše organizacije"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Vaš dostop do vsebin te naprave"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Podatke, povezane z delovnim računom, npr. e-pošto in koledar"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Seznam aplikacij v napravi"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Trajanje uporabe in količina prenesenih podatkov za vsako od aplikacij"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Najnovejši dnevnik omrežnega prometa"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Najnovejše poročilo o napakah"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Najnovejši varnostni dnevnik"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Brez"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Nameščene aplikacije"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"To je ocena števila aplikacij. Morda ne vključuje aplikacij, nameščenih zunaj Trgovine Play."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Najmanj # aplikacija}one{Najmanj # aplikacija}two{Najmanj # aplikaciji}few{Najmanj # aplikacije}other{Najmanj # aplikacij}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Dovoljenja za lokacijo"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Dovoljenja za mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Dovoljenja za fotoaparat"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Privzete aplikacije"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# aplikacija}one{# aplikacija}two{# aplikaciji}few{# aplikacije}other{# aplikacij}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Privzeta tipkovnica"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Nastavljeno na <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Stalno vklopljen VPN je vklopljen"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Stalno vklopljen VPN je vklopljen v vašem osebnem profilu"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Stalno vklopljen VPN je vklopljen v vašem delovnem profilu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Globalni strežnik proxy za HTTP je nastavljen"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Zaupanja vredne poverilnice"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Zaupanja vredne poverilnice v vašem osebnem profilu"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Zaupanja vredne poverilnice v vašem delovnem profilu"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Najmanj # potrdilo overitelja potrdil}one{Najmanj # potrdilo overiteljev potrdil}two{Najmanj # potrdili overiteljev potrdil}few{Najmanj # potrdila overiteljev potrdil}other{Najmanj # potrdil overiteljev potrdil}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Skrbnik lahko zaklene napravo in ponastavi geslo"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Skrbnik lahko izbriše vse podatke v napravi"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Število neuspešnih poskusov vpisa gesla, preden se izbrišejo vsi podatki v napravi"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Število neuspešnih poskusov vpisa gesla, preden se izbrišejo podatki delovnega profila"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# poskus}one{# poskus}two{# poskusa}few{# poskusi}other{# poskusov}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"To napravo upravlja vaša organizacija."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"To napravo upravlja <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Več o tem"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Prepovedana nastavitev"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Omejene nastavitve so dovoljene za aplikacijo <xliff:g id="APP_NAME">%s</xliff:g>."</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Zaradi varnosti ta nastavitev trenutno ni na voljo."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Podatki o napravi na obroke"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Ponudnik obročnega odplačila lahko v tej napravi med nastavitvijo spreminja nastavitve in namešča programsko opremo.\n\nČe ne plačate obroka, lahko ponudnik obročnega odplačila zaklene napravo in spremeni njene nastavitve.\n\nZa več informacij se obrnite na ponudnika obročnega odplačila."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Če je naprava kupljena na obroke, ne morete izvajati tega:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Nameščanje aplikacij, ki niso na voljo v Trgovini Play"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Vnovični zagon naprave v varnem načinu"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Dodajanje več uporabnikov v napravo"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Spreminjanje datuma, ure in časovnega pasu"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Uporaba možnosti za razvijalce"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Ponudniku obročnega odplačila je dovoljeno:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Dostop do številke IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Ponastavitev naprave na tovarniške nastavitve v primeru težav"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Če je naprava zaklenjena, jo lahko uporabljate le za to:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Opravljanje klicev v sili"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Ogled informacij o sistemu, kot so datum, ura, stanje omrežja in stanje baterije"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Vklop ali izklop naprave"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Ogled obvestil in sporočil SMS"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Dostop do aplikacij, ki jih dovoljuje ponudnik obročnega odplačila"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Ko napravo odplačate v celoti:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Vse omejitve se odstranijo iz naprave"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Aplikacijo ponudnika obročnega odplačila lahko odmestite"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Fotografska aplikacija}one{Fotografske aplikacije}two{Fotografske aplikacije}few{Fotografske aplikacije}other{Fotografske aplikacije}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplikacija za koledar"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplikacija za stike"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{E-poštni odjemalec}one{E-poštni odjemalci}two{E-poštni odjemalci}few{E-poštni odjemalci}other{E-poštni odjemalci}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplikacija za zemljevide"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Aplikacija za klicanje}one{Aplikacije za klicanje}two{Aplikacije za klicanje}few{Aplikacije za klicanje}other{Aplikacije za klicanje}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"Ta naprava"</string>
    <string name="storage_games" msgid="1176568610086802469">"Igre"</string>
    <string name="storage_files" msgid="7968460921272772299">"Datoteke"</string>
    <string name="storage_images" msgid="2055893015567979387">"Slike"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videoposnetki"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Zvok"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Aplikacije"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumenti in drugo"</string>
    <string name="storage_system" msgid="8472410119822911844">"Sistem"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Smetnjak"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Želite izprazniti smetnjak?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"V smetnjaku je toliko datotek: <xliff:g id="TOTAL">%1$s</xliff:g>. Vsi elementi bodo trajno izbrisani in jih ne bo mogoče obnoviti."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Smetnjak je prazen."</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Izprazni smetnjak"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Porabljeno: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Skupno: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Počisti aplikacijo"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Ali želite odstraniti to nenamestljivo aplikacijo?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Odpri"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Igre"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Uporabljen prostor"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(odstranjeno za uporabnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(onemogočeno za uporabnika <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Storitev samodejnega izpolnjevanja"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Privzeta storitev samodejnega izpolnjevanja"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Gesla"</string>
    <string name="credman_credentials" msgid="7413302794874989255">"Gesla, ključi za dostop in podatkovne storitve"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# geslo}one{# geslo}two{# gesli}few{# gesla}other{# gesel}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"samodejno, izpolnjevanje, samodejno izpolnjevanje, geslo"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"podatki, ključ za dostop, geslo"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Prepričajte se, da 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="credman_confirmation_message_title" msgid="8847900085593880729">"Želite izklopiti »%1$s«?"</string>
    <string name="credman_confirmation_message" msgid="3499478570809427026">"Shranjeni podatki, kot so naslovi ali plačilna sredstva, ne bodo izpolnjeni ob prijavi. Če želite, da se shranjeni podatki še naprej izpolnijo, nastavite geslo, ključ za dostop in/ali podatkovno storitev."</string>
    <!-- no translation found for credman_enable_confirmation_message_title (3722566298090698004) -->
    <skip />
    <!-- no translation found for credman_enable_confirmation_message (4466773747277583461) -->
    <skip />
    <!-- no translation found for credman_enable_confirmation_message_positive_button (3479082692924433102) -->
    <skip />
    <string name="credman_error_message_title" msgid="4741457523969373713">"Omejitev števila gesel, ključev za dostop in podatkovnih storitev"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Naenkrat je lahko aktivnih največ 5 gesel, ključev za dostop in podatkovnih storitev. Če želite dodati novo storitev, najprej izklopite eno od obstoječih."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Izklopi"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Samodejno izpolnjevanje"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Raven pisanja dnevnika"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Največje dovoljeno število zahtev na sejo"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Največje število prikazanih naborov podatkov"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Ponastavi na privzete vrednosti"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Možnosti samodejnega izpolnjevanja za razvijalce so bile ponastavljene"</string>
    <string name="location_category" msgid="3496759112306219062">"Lokacija"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indikator lokacije v vrstici stanja"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Prikaži za vse lokacije, tudi za zaznane na podlagi omrežja in povezav"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Vsili popolne meritve GNSS"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Spremljaj vse razmestitve in frekvence GNSS brez ciklov."</string>
    <string name="input_method_category" msgid="2252659253631639005">"Način vnosa"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Rokopis s pisalom"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Ko je ta nastavitev omogočena, trenutni način vnosa iz pisala prejme dogodek »MotionEvent«, če je v fokusu urejevalnik."</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema naprave"</string>
    <string name="default_theme" msgid="4815428567082263639">"Privzeto"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Ime omrežja"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Prikaži ime omrežja v vrstici stanja"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Nenamestljiva aplikacija"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Želite izklopiti upravitelja shrambe?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Posodobitev načina »Ne moti«"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Začasno zaustavite prikazovanje obvestil, da ostanete osredotočeni"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkcija ni na voljo"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Ta funkcija je bila izklopljena, ker upočasnjuje vaš telefon"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Vedno pokaži pogovorno okno zrušitve"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Pokaži pogovorno okno ob vsaki zrušitvi aplikacije."</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Izbira aplikacije, ki podpira ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Ni nastavljene aplikacije, ki podpira ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplikacija, ki podpira ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Nastavitve grafičnega gonilnika"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Sprememba nastavitev grafičnega gonilnika"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Kadar je nameščenih več grafičnih gonilnikov, lahko izberete, naj aplikacije, nameščene v napravi, uporabljajo posodobljeni grafični gonilnik."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Omogočanje za vse aplikacije"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Izbira grafičnega gonilnika"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Privzeto"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Gonilnik za igre"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Gonilnik za razvijalce"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Grafični gonilnik sistema"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Spremembe združljivosti aplikacij"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Vklop/izklop sprememb združljivosti aplikacij"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Privzeto omogočene spremembe"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Privzeto onemogočene spremembe"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Ni aplikacij"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Spremembe združljivosti aplikacij je mogoče spreminjati samo za aplikacije z možnostjo odpravljanja napak. Namestite aplikacijo z možnostjo odpravljanja napak in poskusite znova."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Ta nastavitev je odvisna od druge nastavitve"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Račun"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Ime naprave"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Osnovni podatki"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Pravna obvestila in informacije o skladnosti s predpisi"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Podrobnosti o napravi"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identifikatorji naprav"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Upravljanje povezave Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Aplikaciji omogoči, da upravlja Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Tej aplikacij omogočite, da vklopi ali izklopi povezavo Wi-Fi, išče omrežja Wi-Fi in se z njimi poveže, doda ali odstrani omrežja ali pa zažene lokalno dostopno točko."</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Zagon prek NFC-ja"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Dovoli zagon ob optičnem branju oznake NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="7083666814715607078">"Tej aplikaciji dovolite, da se zažene pri optičnem branju oznake NFC.\nČe je to dovoljenje vklopljeno, bo aplikacija na voljo kot ena od možnosti ob vsaki zaznani oznaki."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Predvajaj predstavnost v"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Predvaj <xliff:g id="LABEL">%s</xliff:g> v napravi:"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Ta naprava"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Ni na voljo med klici"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Sprejemanje klicev je vklopljeno"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Tega APN-ja ni mogoče spremeniti."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Preprečevanje zvonjenja"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Sočasno pritisnite gumba za vklop in povečanje glasnosti za"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Bližnjica za preprečevanje zvonjenja"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibriranje"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Izklop zvoka"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibriranje"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Izklop zvoka"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Če želite omogočiti, najprej spremenite »Pridržanje gumba za vklop« na meni za vklop/izklop."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Podatki o omrežju"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Ime naprave je vidno aplikacijam v telefonu. Ko vzpostavite povezavo z napravami Bluetooth ali omrežjem Wi-Fi ali nastavite dostopno točko Wi-Fi, ga bodo morda videle tudi druge osebe."</string>
    <string name="devices_title" msgid="649715719278562515">"Naprave"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Izbira omrežja"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Brez povezave"</string>
    <string name="network_connected" msgid="7637745547242487795">"Povezano"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Povezovanje …"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Povezave ni bilo mogoče vzpostaviti"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Najdeno ni bilo nobeno omrežje."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Omrežij ni bilo mogoče najti. Poskusite znova."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(prepovedano)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Ni kartice SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Ni podatkov"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Za povezavo je potrebna kartica SIM"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Za povezavo je potrebna kartica SIM operaterja <xliff:g id="WIRELESS_CARRIER">%s</xliff:g>"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Prednostni način omrežja: prednostno WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Prednostni način omrežja: samo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Prednostni način omrežja: samo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Prednostni način omrežja: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Želeni način omrežja: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Želeni način omrežja: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Prednostni način omrežja: samo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Prednostni način omrežja: samo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Prednostni način omrežja: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Prednostni način omrežja: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Prednostni način omrežja: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Prednostni način omrežja: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Prednostni način omrežja: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Prednostni način omrežja: globalno"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Prednostni način omrežja: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Prednostni omrežni način: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Prednostni način omrežja: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Prednostni način omrežja: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Prednostni način omrežja: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Prednostni način omrežja: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Prednostni način omrežja: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Prednostni način omrežja: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Prednostni način omrežja: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Prednostni način omrežja: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Prednostni način omrežja: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Prednostni način omrežja: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Prednostni način omrežja: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Prednostni način omrežja: samo NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Prednostni način omrežja: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Prednostni način omrežja: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Prednostni način omrežja: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Prednostni način omrežja: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Prednostni način omrežja: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Prednostni način omrežja: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Prednostni način omrežja: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Prednostni način omrežja: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Prednostni način omrežja: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Prednostni način omrežja: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (priporočeno)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (priporočeno)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (priporočeno)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Samodejno izberi omrežje"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Nastavitve operaterja"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Nastavitev podatkovne storitve"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Prenos podatkov v mobilnem omrežju"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Dostop do prenosa podatkov prek mobilnega omrežja."</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Ko bo ta operater v dosegu, bo telefon samodejno preklopil nanj"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Ni kartic SIM."</string>
    <string name="calls_preference" msgid="2166481296066890129">"Nastavitev za klice"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Nastavitev za sporočila SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Vedno vprašaj"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Dodajte omrežje"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Privzeto za klice"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Privzeto za SMS-je"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Privzeto za klice in SMS-je"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Privzeto za prenos pod. v mob. omrežju"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Prenos pod. v mob. omrežju je vklopljen"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Prenos pod. v mob. omrežju je izklopljen"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Na voljo"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Dodajanje kartice SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktivno/SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Neaktivno/SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktivna/e-SIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Neaktivna/e-SIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Ime in barva kartice SIM"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Ime"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Barva (uporabljajo jo združljive aplik.)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Shrani"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Uporabi kartico SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Izklopljeno"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Če želite onemogočiti to kartico SIM, jo odstranite"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Dotaknite se za aktiviranje operaterja <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Izbriši kartico SIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Prednostna vrsta omrežja"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Sprememba načina delovanja omrežja"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Prednostna vrsta omrežja"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Operaterjeve nastavitve različice"</string>
    <string name="call_category" msgid="641461844504128789">"Klicanje"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videoklicanje prek operaterja"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Sistemska izbira"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Spremeni način gostovanja CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Sistemska izbira"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Omrežje"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Naročnina CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Preklopi med RUIM/SIM in NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"naročnina"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Samodejna registracija …"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Želite dovoliti podatkovno gostovanje?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Preverite cene pri operaterju omrežja."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Prenos podatkov aplikacij"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Neveljaven način omrežja: <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Prezri."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Imena dostopnih točk"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Ni na voljo ob vzpostavljeni povezavi z operaterjem <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Pokaži več"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Želite vklopiti storitev operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Želite vklopiti kartico SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Želite preklopiti na operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Želite preklopiti na uporabo kartice SIM?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Želite preklopiti na operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Hkrati je lahko aktivna samo ena kartica SIM.\n\nČe preklopite na operaterja <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, ne boste preklicali storitve operaterja <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Aktivna je lahko samo ena kartica e-SIM hkrati.\n\nČe preklopite na operaterja <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, s tem še ne boste preklicali storitve operaterja <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Hkrati je lahko aktivna samo ena kartica SIM.\n\nČe preklopite, ne boste preklicali storitve operaterja <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Hkrati lahko uporabljate dve kartici SIM. Če želite preklopiti na operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, izklopite drugo kartico SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Preklopi na operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Izklop operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Z izklopom kartice SIM ne prekličete storitve operaterja"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Povezovanje z omrežjem …"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Preklapljanje na operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g> za klice in sporočila …"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Operaterja ni mogoče preklopiti"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Operaterja ni mogoče preklopiti zaradi napake."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Želite izklopiti storitev operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Želite izklopiti kartico SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Izklapljanje kartice SIM <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Operaterja ni mogoče onemogočiti"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Prišlo je do napake, operaterja ni bilo mogoče onemogočiti."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Želite uporabljati dve kartici SIM?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"V tej napravi sta lahko hkrati aktivni dve kartici SIM. Če želite še naprej uporabljati samo eno kartico SIM, se dotaknite »Ne, hvala«."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Želite znova zagnati napravo?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Da"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Znova zaženi"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Ne, hvala"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Prekliči"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Preklopi"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Kartice SIM ni mogoče aktivirati"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Poskusite znova vklopiti kartico SIM. Če s tem ne odpravite težave, znova zaženite napravo."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktivacija omrežja"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Preklop operaterja"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"Operater <xliff:g id="CARRIER_NAME">%1$s</xliff:g> je aktiven"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Dotaknite se, če želite posodobiti nastavitve kartice SIM"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Preklopljeno na omrežje operaterja <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Preklopljeno na drugega operaterja"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Mobilno omrežje je spremenjeno."</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Nastavite drugo kartico SIM"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Izberite aktivno kartico SIM ali uporabljajte dve kartici SIM hkrati."</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Izberite, katero številko želite uporabiti"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{V tej napravi je na voljo 1 številka, vendar je mogoče uporabljati samo eno hkrati.}=2{V tej napravi sta na voljo 2 številki, vendar je mogoče uporabljati samo eno hkrati.}one{V tej napravi je na voljo # številka, vendar je mogoče uporabljati samo eno hkrati.}two{V tej napravi sta na voljo # številki, vendar je mogoče uporabljati samo eno hkrati.}few{V tej napravi so na voljo # številke, vendar je mogoče uporabljati samo eno hkrati.}other{V tej napravi je na voljo # številk, vendar je mogoče uporabljati samo eno hkrati.}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Aktiviranje <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Aktiviranje trenutno ni bilo mogoče."</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Želite uporabiti storitev <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"Operater <xliff:g id="CARRIER_NAME">%1$s</xliff:g> bo uporabljen za prenos podatkov v mobilnem omrežju, klice in sporočila SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nobena aktivna kartica SIM ni na voljo"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Prenos podatkov v mobilnem omrežju, funkcije klicanja in sporočila lahko nastavite tudi pozneje v omrežnih nastavitvah."</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Želite izbrisati to kartico e-SIM?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Če izbrišete to kartico SIM, boste iz te naprave odstranili storitev operaterja <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>.\n\nStoritev operaterja <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> ne bo preklicana."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Izbriši"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Brisanje kartice SIM …"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Kartice SIM ni mogoče izbrisati"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Te kartice SIM ni mogoče izbrisati zaradi napake.\n\nZnova zaženite napravo in poskusite znova."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Vzpostavitev povezave z napravo"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Aplikacija <xliff:g id="APPNAME">%1$s</xliff:g> želi uporabiti začasno omrežje Wi-Fi za vzpostavitev povezave z napravo"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Ni naprav. Preverite, ali so naprave vklopljene in na voljo za vzpostavitev povezave."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Poskusi znova"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Prišlo je do napake. Aplikacija je preklicala zahtevo za izbiro naprave."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Uspešna vzpostavitev povezave"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Povezava ni bila vzpostavljena"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Pokaži vse"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Iskanje naprave …"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Vzpostavljanje povezave z napravo …"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Levo"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Desno"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Ovitek"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Podokno nastavitev"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Vsili namizni način"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Vsili poskusni namizni način na sekundarnih zaslonih."</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Omogoči okna nespremenljive velikosti v načinu z več okni"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Omogoča uporabo aplikacij brez možnosti spreminjanja velikosti v načinu z več okni."</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Preglasi vsiljenje temnega načina"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Preglasi vsiljenje vedno vklopljenega temnega načina."</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Zasebnost"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Dovoljenja, dejavnost v računu, osebni podatki"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Kontrolniki"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Odstrani"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Obdrži"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Želite odstraniti ta predlog?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Malo shrambe: zasedeno <xliff:g id="PERCENTAGE">%1$s</xliff:g>, prosto <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Pošlji povratne informacije"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Nam želite poslati povratne informacije o tem predlogu?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Vsebina <xliff:g id="COPY_CONTENT">%1$s</xliff:g> je kopirana v odložišče."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Uporaba funkcij za ljudi s posebnimi potrebami"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 aplikacija ima poln dostop do naprave.}one{# aplikacija ima poln dostop do naprave.}two{# aplikaciji imata poln dostop do naprave.}few{# aplikacije imajo poln dostop do naprave.}other{# aplikacij ima poln dostop do naprave.}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Pomembne informacije"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"NADALJUJ"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NE, HVALA"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Lokacija"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Ko uporabite to storitev za klice v sili, vaš operater morda zbira podatke o lokaciji.\n\nPodrobnosti preverite v operaterjevem pravilniku o zasebnosti."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Morda boste izgubili dostop do preostalega časa ali podatkov. Pred odstranjevanjem preverite pri operaterju."</string>
    <string name="content_capture" msgid="868372905432812238">"Vsebina aplikacije"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Aplikacijam dovoli pošiljanje vsebine v sistem Android."</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Zajemi sistemski izvoz kopice"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Razširitev za označevanje pomnilnika"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Razširitev za označevanje pomnilnika (MTE) olajša iskanje varnostnih težav s pomnilnikom v vaši aplikaciji in izboljša varnost njene izvorne kode."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Vklop razširitve MTE lahko upočasni delovanje naprave."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Več o razširitvi MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Omogoči razširitev MTE, dokler je ne izklopite"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Za vklop razširitve MTE boste morali znova zagnati napravo."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Za izklop razširitve MTE boste morali znova zagnati napravo."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Omogoči razširitev MTE za eno samo sejo"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Sistem se bo znova zagnal in bo omogočil preizkušanje razširitve MTE (razširitve za označevanje pomnilnika). Razširitev MTE lahko negativno vpliva na učinkovitost delovanja in stabilnost sistema. Bo ponastavljeno pri naslednjem vnovičnem zagonu."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Znova zaženite za eno samo sejo z omogočeno razširitvijo MTE."</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"Razširitev MTE je že omogočena"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Zajemanje sistemskega izvoza kopice"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Sistemskega izvoza kopice ni bilo mogoče zajeti"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Samodejni zajem sistemskih izvozov kopic"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Samodejni zajem heap izvoza kopice za sistem Android, ko porabi preveč pomnilnika"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Prekini povezavo"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Klici v sili"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Vaš operater ne podpira klicev v sili, opravljenih s funkcijo Klicanje prek Wi-Fi-ja.\nNaprava samodejno preklopi na mobilno omrežje, da opravi klic v sili.\nKlici v sili so mogoči samo na območjih, ki so pokrita z mobilnim signalom."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Uporabljajte omrežje Wi‑Fi za izboljšanje kakovosti klicev"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Pomožno klicanje"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Če <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> ni na voljo ali gostujete, za klice prek operaterja <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g> uporabite SIM za prenos pod. v mob. omrež."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"pomožno klicanje, nadomestni način klicanja"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Dohodno sporočilo MMS"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Sporočila MMS ni mogoče poslati"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Dotaknite se za uporabo sporočil MMS v omrežju <xliff:g id="OPERATOR_NAME">%1$s</xliff:g>, ko je prenos podatkov v mobilnem omrežju izklopljen"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Sporočilo MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Težava s kombinacijo kartic SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Hkratna uporaba operaterjev <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> lahko omeji nekatere funkcije. Za več informacij se dotaknite."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Kombinacija kartic SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Podatki o službenem pravilniku"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Nastavitve upravlja skrbnik za IT"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPE"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Rutina za obravnavo poročila o napakah"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Določa, katera aplikacija obravnava bližnjico za poročilo o napakah v napravi."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Osebno"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Služba"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Sistemsko privzeto"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Brez"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Ta izbira ni več veljavna. Poskusite znova."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Pridržanje gumba za vklop"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Pridržanje gumba za vklop omogoči dostop do:"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Meni za vklop/izklop"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitalni pomočnik"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Dostop do digitalnega pomočnika"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Dostop do menija za vklop/izklop"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Za uporabo najprej nastavite zaklepanje zaslona."</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Meni za vklop/izklop:\nHkrati pritisnite gumb za vklop in gumb za povečanje glasnosti ter ju pridržite."</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Preprečevanje zvonjenja:\nZa bližnjico pritisnite gumb za glasnost."</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Dolžina pridržanja"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Prilagodite občutljivost z izbiro dolžine pridržanja gumba za vklop."</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Kratko"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Dolgo"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Prikaži denarnico"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Dovolite dostop do denarnice na zaklenjenem zaslonu."</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Prikaži optični bralnik kod QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Dovoli dostop do optičnega bralnika kod QR pri zaklenjenem zaslonu"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Prikaži kontrolnike naprave"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="2769166101644452893">"Prikaz kontrolnikov za zunanje naprave na zaklenjenem zaslonu"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="8211063535536295676">"Upravljanje z zaklenjeno napravo"</string>
    <string name="lockscreen_trivial_controls_summary" msgid="680581904143387225">"Upravljanje zunanjih naprav brez odklepanja telefona ali tabličnega računalnika, če aplikacija s kontrolniki naprave to omogoča"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Za uporabo najprej vklopite »Prikaži kontrolnike naprave«."</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Prikaz ure v dveh vrsticah, ko je na voljo"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Ura v dveh vrsticah"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Bližnjice"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="one"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="two"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="few"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Želite izklopiti VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"S tem tudi izklopite povezavo 5G.\nMed glasovnim klicem ne boste mogli uporabljati interneta in nekatere aplikacije morda ne bodo delovale."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Ustavitev izvajanja za predpomnjene aplikacije"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Nikoli ne poteče."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Zakup nikoli ne poteče."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Dovoli prekrivanje zaslonov z nastavitvami"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Dovoli aplikacijam, ki lahko prekrivajo druge aplikacije, prekrivanje zaslonov v aplikaciji Nastavitve."</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Dovoli simuliran modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Tej napravi dovoli izvajanje storitve simuliranega modema za preizkušanje instrumentacije. Tega ne omogočite med običajno uporabo telefona."</string>
    <string name="media_controls_title" msgid="403271085636252597">"Predstavnost"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Pripni predvajalnik predstavnosti"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Predvajalnik predstavnosti ostane odprt v hitrih nastavitvah, da je omogočeno hitro nadaljevanje predvajanja."</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Prikaz predstavnosti na zaklenjenem zaslonu"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Predvajalnik predstavnosti ostane odprt na zaklenjenem zaslonu, da je omogočeno hitro nadaljevanje predvajanja."</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Prikaži priporočila glede predstavnosti"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Priporočila temeljijo glede na vašo dejavnost."</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Skrij predvajalnik"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Prikaži predvajalnik"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"predstavnost"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth se bo vklopil."</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"Kartice SIM"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Klici in sporočila SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Klicanje prek Wi-Fi-ja"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Opravljanje in prejemanje klicev v omrežjih Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Klici"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"Sporočila SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"prednostno"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"prednostno za klice"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"prednostno za sporočila SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"ni na voljo"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Začasno ni na voljo"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Ni kartice SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Omrežne nastavitve"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"omrežna povezava, internet, brezžično, podatki, wifi, wi-fi, wi fi, mobilno omrežje, mobilno, mobilni operater, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Želite ponastaviti internetno povezavo?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Ponastavljanje internetne povezave …"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Odpravljanje težav s povezavo"</string>
    <string name="networks_available" msgid="3299512933684383474">"Omrežja so na voljo"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Če želite preklopiti omrežje, prekinite ethernetno povezavo."</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Povezave W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Storitvi Google Fi omogoči uporabo omrežij W+ za večjo hitrost in pokritost."</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Omrežje W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"Kartica e-SIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"Kartice e-SIM"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Aktivna"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Neaktivna"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Privzeto za: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"klici"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"prenos podatkov v mobilnem omrežju"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Za izboljšano izkušnjo pri uporabi naprave lahko aplikacije in storitve kadar koli iščejo omrežja Wi‑Fi, tudi ko je Wi‑Fi izklopljen. To funkcijo lahko na primer uporabite, če želite izboljšati funkcije in storitve, ki pri delovanju uporabljajo lokacijo. To lahko spremenite v nastavitvah iskanja omrežij Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Spremeni"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g>/<xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Povezano"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Začasno vzpostavljena povezava"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Začasna uporaba storitve <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Ni povezave"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Prenos podatkov v mobilnem omrežju ne bo samodejno vzpostavil povezave."</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Želite izklopiti prenos podatkov v mobilnih omrežjih?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Prek omrežja <xliff:g id="CARRIER">%s</xliff:g> ne boste imeli dostopa do podatkovne povezave ali interneta. Internet bo na voljo samo prek povezave Wi-Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"vašega operaterja"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Organizacija tega ne dovoljuje."</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Ni na voljo, ker je vklopljen način za spanje"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Ponastavitev pomembnosti obvestil je dokončana."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplikacije"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Naprava želi dostopati do vaših sporočil. Dotaknite se za podrobnosti."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Želite dovoliti dostop do sporočil?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Naprava Bluetooth <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi dostopati do vaših sporočil.\n\nŠe nikoli niste vzpostavili povezave z napravo <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Naprava želi dostopati do vaših stikov in dnevnika klicev. Dotaknite se za podrobnosti."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Želite dovoliti dostop do stikov in dnevnika klicev?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Naprava Bluetooth <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi dostopati do vaših stikov in dnevnika klicev. To vključuje podatke o dohodnih in odhodnih klicih.\n\nŠe nikoli niste vzpostavili povezave z napravo <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Svetlost"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Prikaz na zaklenjenem zaslonu"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Videz"</string>
    <string name="category_name_color" msgid="937514550918977151">"Barva"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Drugi kontrolniki prikaza"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Splošno"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Uporabi temno temo"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Uporabi Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Uporabi preprečevanje zvonjenja"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Uporabi dostopno točko Wi‑Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Uporabi pripenjanje aplikacije"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Uporabi možnosti za razvijalce"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Uporabi storitev tiskanja"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Dovoli več uporabnikov"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"dovoli, več, uporabnik, dovoljenje"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Uporabi brezžično odpravljanje napak"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Uporaba nastavitev grafičnega gonilnika"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Uporabi način Nočna svetloba"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Uporabi NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Uporabi prilagodljivo svetlost"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Uporaba klicanja prek Wi‑Fi-ja"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Prikaz vseh aplikacij"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Pametno posredovanje"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Pametno posredovanje je omogočeno."</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Pametno posredovanje je onemogočeno."</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Nastavitve klicanja"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Posodabljanje nastavitev …"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Napaka nastavitev klicev"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Napaka omrežja ali kartice SIM."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"Kartica SIM ni aktivirana."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Vnesite telefonske številke"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Vnesite telefonsko številko"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Manjka telefonska številka."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"V redu"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Omogoči 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G je manj varen, vendar lahko izboljša kakovost povezave na nekaterih lokacijah. Povezava 2G je vedno dovoljena za klice v sili."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"Operater <xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> zahteva razpoložljivo povezavo 2G"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Zahtevaj šifriranje"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Šifriranje je varnejše, vendar na nekaterih lokacijah morda ne boste mogli vzpostaviti povezave. Šifriranje se nikoli ne zahteva za klice v sili."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Vse storitve"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Pokaži dostop do odložišča"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Pokaži sporočilo, ko aplikacije dostopijo do besedila, slik ali drugih vsebin, ki ste jih kopirali."</string>
    <string name="all_apps" msgid="3054120149509114789">"Vse aplikacije"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Ne dovoli"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Izjemno širok pas (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Pomaga določiti relativni položaj naprav v bližini, ki imajo UWB."</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Če želite uporabljati UWB, izklopite način za letalo."</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Dostop do fotoaparata"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Dostop do mikrofona"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Za aplikacije in storitve"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Za aplikacije in storitve. Če je ta nastavitev izklopljena, bodo podatki mikrofona morda še vedno deljeni, ko pokličete številko za klic v sili."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Nazaj"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Naprej"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Predogled barve"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Zahteva za dostop do kartice SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Naprava želi dostopati do kartice SIM. Dotaknite se za podrobnosti."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Želite dovoliti dostop do kartice SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Naprava Bluetooth <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> želi dostopati do podatkov na kartici SIM. To vključuje vaše stike.\n\nDokler bo povezava vzpostavljena, bo naprava <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> prejemala vse klice na številko <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Naprava Bluetooth je na voljo"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Naprava želi vzpostaviti povezavo. Dotaknite se za podrobnosti."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Želite vzpostaviti povezavo z napravo Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"Naprava <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> se želi povezati s tem telefonom.\n\nŠe nikoli niste vzpostavili povezave z napravo <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Ne poveži"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Poveži"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Nastavitve TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Vklopljeno"</string>
    <string name="tare_off" msgid="6305694402929756726">"Izklopljeno"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Povrni na privzete nastavitve"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Nastavitve so ponastavljene na privzete."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Najvišje stanje ob polni napolnjenosti"</string>
    <string name="tare_balances" msgid="731881382594747961">"Stanja"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Omejitve porabe"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Začetna omejitev porabe"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Najnižja omejitev porabe"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Najvišja omejitev porabe"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikatorji"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Dejanja (izvedbena cena)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Dejanja (osnovna cena)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Nagrade po posameznih dogodkih"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Nagrade na sekundo trajanja dogodka"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Najvišje dnevno število nagrad"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Namestitev aplikacije"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Dejavnost v ospredju"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Obvestilo je bilo prebrano"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Obvestilo je bilo prebrano v 15 minutah"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interakcija z obvestilom"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interakcija s pripomočkom"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Druga uporabniška interakcija"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Začetek opravila z najvišjo prednostjo"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Izvajanje opravila z najvišjo prednostjo"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Začetek opravila z visoko prednostjo"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Izvajanje opravila z visoko prednostjo"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Začetek opravila s privzeto prednostjo"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Izvajanje opravila s privzeto prednostjo"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Začetek opravila z nizko prednostjo"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Izvajanje opravila z nizko prednostjo"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Začetek opravila z najnižjo prednostjo"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Izvajanje opravila z najnižjo prednostjo"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Kazen za potek časovne omejitve opravila"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Najnižje stanje ob polni napolnjenosti (izvzete aplikacije)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Najnižje stanje ob polni napolnjenosti (sistemska aplikacija brez vmesnika)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Najnižje stanje ob polni napolnjenosti (preostale aplikacije)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Dodatek pri najnižjem stanju ob polni napolnjenosti (orodja za posod. aplikacij)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Polnjenje"</item>
    <item msgid="658627268149681677">"Dremanje"</item>
    <item msgid="1599558140284643834">"Način varčevanja z energijo"</item>
    <item msgid="588427840913221601">"Stanje procesa"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Potrdi"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Predogled"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Izbira ohranjevalnika zaslona"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Prikaz dodatnih informacij"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Prikaz stvari, kot je ura, vreme ali drugi podatki, na ohranjevalniku zaslona."</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Pokaži kontrolnike za dom"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Prikažite gumb za kontrolnike za dom na ohranjevalniku zaslona."</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Več nastavitev"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Izbira ohranjevalnika zaslona"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Izberite, kaj bo prikazano na zaslonu, ko je tablični računalnik priklopljen na nosilec. Naprava bo med uporabo ohranjevalnika zaslona morda porabljala več energije."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Prilagodi"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Prilagajanje ohranjevalnika zaslona <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Če želite omogočiti podporo za svobodno obliko, morate znova zagnati napravo."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Če želite vsiliti namizni način na sekundarnih zaslonih, morate znova zagnati napravo."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Znova zaženi"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Znova zaženi pozneje"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Prostorski zvok"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Zvok iz združljivih predstavnosti dobi prostornejšo razsežnost."</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Spremljanje premikov glave"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Zvok se med premikanjem glave spreminja za naravnejšo izkušnjo."</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Omejitev hitrosti prenosa omrežja"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Konfigurirajte omejitev dohodne pasovne širine omrežja, ki velja za vsa omrežja, ki zagotavljajo internetno povezljivost."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfiguriranje omejitve hitrosti prenosa omrežja"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Brez omejitev"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Onemogočanje omejitev za podrejene procese"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Onemogočanje omejitev uporabe sistemskih sredstev za podrejene procese aplikacije"</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Oddajanje"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Oddajaj aplikacijo <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Poslušajte oddajanja, ki se predvajajo v bližini."</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Oddajajte predstavnost v naprave v bližini ali poslušajte oddajanje nekoga drugega."</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Oddajanja"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Poslušate"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Iskanje oddajanj"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Zapusti oddajanje"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Optično branje kode QR"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Vnos gesla"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Povezave ni mogoče vzpostaviti. Poskusite znova."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Napačno geslo"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Oddaji se ni mogoče pridružiti"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Če želite začeti poslušati, postavite spodnjo kodo QR na sredino."</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Koda QR nima pravilne oblike zapisa."</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Pretvorba v kartico e-SIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Prenos kartice e-SIM v drugo napravo"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# aplikacija}one{# aplikacija}two{# aplikaciji}few{# aplikacije}other{# aplikacij}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Aplikacije, nameščene v ozadju"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Proizvajalec naprave lahko v ozadju namešča aplikacije v napravi ali pa to dovoli operaterju in drugim partnerjem.\n\nNobena od tukaj navedenih aplikacij ni nujna za pravilno delovanje naprave. Neželene aplikacije lahko odmestite."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Ni aplikacij, nameščenih v ozadju"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Odmestitev aplikacije"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Aplikacije, nameščene v zadnjem # mesecu}one{Aplikacije, nameščene v zadnjem # mesecu}two{Aplikacije, nameščene v zadnjih # mesecih}few{Aplikacije, nameščene v zadnjih # mesecih}other{Aplikacije, nameščene v zadnjih # mesecih}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Aplikacije, nameščene pred več kot # mesecem}one{Aplikacije, nameščene pred več kot # mesecem}two{Aplikacije, nameščene pred več kot # mesecema}few{Aplikacije, nameščene pred več kot # meseci}other{Aplikacije, nameščene pred več kot # meseci}}"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Tipalo prstnih odtisov"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Obveščanje z utripanjem"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"O obveščanju z utripanjem"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Izklopljeno"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Vklopljeno / utripanje lučke fotoaparata"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Vklopljeno / utripanje zaslona"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Vklopljeno / utripanje lučke fotoaparata in zaslona"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Utripanje lučke fotoaparata ali zaslona ob prejemu obvestil ali sprožitvi alarma"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Obveščanje z utripanjem uporabljajte previdno, če ste občutljivi na svetlobo."</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Predogled"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Utripanje lučke fotoaparata"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Utripanje zaslona"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Barva utripanja zaslona"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Modra"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azurna"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cijan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Pomladno zelena"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Zelena"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Rumenozelena"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Rumena"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranžna"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Rdeča"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Rožnata"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Vijolična"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Končano"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Prekliči"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"To aplikacijo je mogoče odpreti samo v enem oknu"</string>
</resources>
