<?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">"Jā"</string>
    <string name="no" msgid="5541738710521607130">"Nē"</string>
    <string name="create" msgid="986997212165228751">"Izveidot"</string>
    <string name="allow" msgid="3763244945363657722">"Atļaut"</string>
    <string name="deny" msgid="7326117222944479942">"Aizliegt"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Ieslēgt"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Nezināms"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Lai rādītu informāciju, pieskarieties"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Pēc # pieskāriena būsiet izstrādātājs.}zero{Pēc # pieskārieniem būsiet izstrādātājs.}one{Pēc # pieskāriena būsiet izstrādātājs.}other{Pēc # pieskārieniem būsiet izstrādātājs.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Tagad jūs esat izstrādātājs!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nav nepieciešams, ja jau esat izstrādātājs."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Lūdzu, vispirms iespējojiet izstrādātāju opcijas."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistēma"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Darbojas"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Nedarbojas"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio ir izslēgts"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Viesabonēšana"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Bez viesabonēšanas"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Atvienots"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Notiek savienojuma izveide"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Izveidots savienojums"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Atlikts"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Nezināms"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Priekšskatījums"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Samazināt"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Palielināt"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Automātiska pagriešana"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Sejas noteikšanas funkcija izmanto priekšējo kameru, lai uzlabotu automātiskās pagriešanas precizitāti. Attēli nekad netiek ne glabāti, ne sūtīti uzņēmumam Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Redzams visām tuvumā esošām Bluetooth ier. (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Redzams visām tuvumā esošām Bluetooth ierīcēm"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nav redzams citām Bluetooth ierīcēm"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Redzams tikai pārī savienotām ierīcēm"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth ierīces"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Ierīces nosaukums"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Pārdēvēt ierīci"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Pārdēvēt"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Vai atvienot ierīci?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Savienošana pārī ar jaunu ierīci"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Savienot pārī labo"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Savienot pārī kreiso"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Savienojiet otru aparātu"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Kreisās auss dzirdes aparāts ir pievienots.\n\nLai savienotu pārī labās auss dzirdes aparātu, pārbaudiet, vai tas ir ieslēgts un gatavs savienošanai pārī."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Labās auss dzirdes aparāts ir pievienots.\n\nLai savienotu pārī kreisās auss dzirdes aparātu, pārbaudiet, vai tas ir ieslēgts un gatavs savienošanai pārī."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Savienot pārī labo"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Savienot pārī kreiso"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Visiem pieejamajiem dzirdes aparātiem"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Dzirdes aparāta iestatījumi"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Saīsne, saderība ar dzirdes aparātiem"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Šai ierīcei"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audio izeja"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Par audio izvadi"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Skaņas varat atskaņot dzirdes aparātā vai tālruņa skaļrunī"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Saistīti rīki"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Zvana un pulksteņa signāli"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Audio zvanu laikā"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Multivide"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Paziņojumi un sistēmas signāli"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Pēc noklusējuma audio izvadi nosaka katra konkrētā lietotne"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Nenosaukta Bluetooth ierīce"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Notiek meklēšana"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Tuvumā nav atrastas Bluetooth ierīces."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Bluetooth pāra izveidošanas pieprasījums"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Pāra izveides pieprasījums"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Pieskarieties, lai izveidotu savienojumu pārī ar ierīci “<xliff:g id="DEVICE_NAME">%1$s</xliff:g>”."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth ir izslēgts"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Pieskarieties, lai to ieslēgtu."</string>
    <string name="device_picker" msgid="2427027896389445414">"Izvēlēties Bluetooth ierīci"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"Lietotnē <xliff:g id="APP_NAME">%1$s</xliff:g> tiek mēģināts ieslēgt Bluetooth savienojumu."</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"Lietotnē <xliff:g id="APP_NAME">%1$s</xliff:g> tiek mēģināts izslēgt Bluetooth savienojumu."</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Lietotnē tiek mēģināts ieslēgt Bluetooth savienojumu."</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Lietotnē tiek mēģināts izslēgt Bluetooth savienojumu."</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Tiek ieslēgta tehnoloģija Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Notiek Bluetooth savienojuma izslēgšana…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Bluetooth savienojuma pieprasījums"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Pieprasījums piekļūt tālruņu grāmatai"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Pieprasījums piekļūt ziņojumam"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Citām ierīcēm redzama kā “<xliff:g id="DEVICE_NAME">^1</xliff:g>”"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Ieslēdziet Bluetooth, lai izveidotu savienojumu ar citām ierīcēm."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Jūsu ierīces"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Savienošana pārī ar jaunu ierīci"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Atspējot Bluetooth A2DP aparatūras izlādi"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Atspējot Bluetooth LE audio aparatūras izlādi"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Vai restartēt ierīci?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Lai mainītu šo iestatījumu, jums jārestartē ierīce."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Restartēt"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Atcelt"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Atspējot Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Tiek atspējota Bluetooth LE Audio funkcija, ja ierīcē tiek atbalstītas LE Audio aparatūras iespējas."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"LE Audio slēdzis informācijā par ierīci"</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Iespējot Bluetooth LE audio atļaušanas sarakstu"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Iespējojiet funkciju “Bluetooth LE audio atļaušanas saraksts”."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Multivides ierīces"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Zvanīšanas ierīces"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Citas ierīces"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Saglabātās ierīces"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Tiks ieslēgts Bluetooth un izveidots savienojums pārī."</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Savienojuma preferences"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Ierīces, ar kurām savienojums tika izveidots iepriekš"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth savienojums ir ieslēgts"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Skatīt visas"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Skārienekrāna pildspalva"</string>
    <string name="stylus_default_notes_app" msgid="3896158797687806941">"Noklusējuma piezīmju lietotne"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Rakstīšana teksta laukos"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Vienmēr ignorēt skārienekrāna pildspalvas pogu nospiešanu"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Skārienekrāna pildspalva"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datums un laiks"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Starpniekserveris"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Notīrīt"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Starpniekservera ports"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Apiet starpniekserveri:"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Atjaunot noklusējuma iestatījumus"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Gatavs"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Starpniekservera saimniekdatora nosaukums"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Uzmanību!"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Labi"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Ierakstītais saimniekdatora nosaukums nav derīgs."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Ierakstītais izslēgšanas saraksts nav pareizi formatēts. Ierakstiet ar komatiem atdalītu izslēgto domēnu sarakstu."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Aizpildiet lauku Ports."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Ja saimniekdatora lauks ir tukšs, porta laukam jābūt tukšam."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Ierakstītais porta numurs nav derīgs."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"HTTP starpniekserveris tiek izmantots pārlūkprogrammā, taču, iespējams, netiek izmantots citās lietotnēs."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Ehotestēšanas saimniekdatora nosaukuma (www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP klienta tests:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Veikt ehotestēšanu"</string>
    <string name="skip_label" msgid="6380034601349015895">"Izlaist"</string>
    <string name="next_label" msgid="1248293387735652187">"Tālāk"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Valodas"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Vēlamo valodu secība"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Sistēmas valoda"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Noņemt"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Pievienot valodu"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Valoda"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Vēlamā valoda"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Lietotņu valodas"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Iestatiet katras lietotnes valodu"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Lietotnes valoda"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Ieteiktās valodas"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Visas valodas"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Sistēmas valoda"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Sistēmas noklusējums"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Iestatījumos nav pieejama valodas atlase šai lietotnei."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Valoda var atšķirties no lietotnē pieejamās valodas. Dažās lietotnēs šis iestatījums var netikt atbalstīts."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Iestatiet valodu katrai lietotnei."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Sistēmā, lietotnēs un tīmekļa vietnēs tiek izmantota pirmā atbalstītā valoda no jūsu vēlamajām valodām."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Lai atlasītu valodu katrai lietotnei, pārejiet uz lietotnes valodas iestatījumiem."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Plašāka informācija par lietotņu valodām"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Vai mainīt sistēmas valodu uz šādu: %s?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Tiks mainīti jūsu ierīces iestatījumi un reģionālās preferences."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Mainīt"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"Šī valoda nav pieejama: %s"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Šo valodu nevar lietot kā sistēmas valodu, bet esat norādījis lietotnēm un vietnēm, ka dodat priekšroku šai valodai."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Reģionālās preferences"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Iestatiet vienību un skaitļu preferences."</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Atklājiet lietotnēm savas reģionālās preferences, lai lietotnes varētu personalizēt jums pieejamās iespējas."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Lietotnēs tiks izmantotas jūsu reģionālās preferences, kad tas būs iespējams."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatūra"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Pirmā nedēļas diena"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Skaitļu preferences"</string>
    <string name="default_string_of_regional_preference" msgid="7662581547334113719">"Izmantot lietotnes noklusējuma iestatījumus"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsija skala (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fārenheita skala (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Svētdiena"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Pirmdiena"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Otrdiena"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Trešdiena"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Ceturtdiena"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Piektdiena"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Sestdiena"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Ja kādā lietotnē netiek atbalstītas reģionālās preferences, tiks izmantoti tās noklusējuma lokalizācijas iestatījumi."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Uzziniet vairāk par valodas preferencēm."</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Vai noņemt atlasīto valodu?}zero{Vai noņemt atlasītās valodas?}one{Vai noņemt atlasītās valodas?}other{Vai noņemt atlasītās valodas?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Teksts tiks rādīts citā valodā."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Nevar noņemt visas valodas"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Paturiet vismaz vienu vēlamo valodu"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Nav pieejama kā sistēmas valoda"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Pārvietot uz augšu"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Pārvietot uz leju"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Pārvietot uz sākumu"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Pārvietot uz beigām"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Noņemt valodu"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Darbības izvēle"</string>
    <string name="cancel" msgid="5780102414089664898">"Atcelt"</string>
    <string name="okay" msgid="4827099303045669054">"LABI"</string>
    <string name="forget" msgid="3754013654135912783">"Aizmirst"</string>
    <string name="save" msgid="3125033126936493822">"Saglabāt"</string>
    <string name="done" msgid="7497982645646431310">"Gatavs"</string>
    <string name="apply" msgid="7834684883190163536">"Lietot"</string>
    <string name="share" msgid="8502235338607613795">"Koplietot"</string>
    <string name="add" msgid="8335206931421683426">"Pievienot"</string>
    <string name="remove" msgid="1028414219245072102">"Noņemt"</string>
    <string name="settings_label" msgid="943294133671632976">"Iestatījumi"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Iestatījumi"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Saīsne Iestatījumi"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Lidojuma režīms"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Bezvadu sakari un tīkli"</string>
    <string name="roaming" msgid="3055365654530847985">"Viesabonēšana"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Viesabonēšanas laikā izveidot savienojumu ar datu pakalpojumiem"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Viesabonēšanas laikā izveidot savienojumu ar datu pakalpojumiem"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Var tikt piemērota maksa par viesabonēšanu."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Iestatīt laiku automātiski"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Iestatīt automātiski"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Ja šis slēdzis būs ieslēgts, atrašanās vietas dati tiks izmantoti, lai iestatītu laika joslu"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Izmantot lokalizācijas noklusējuma vērtību"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Izmantot 24 stundu formātu"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Laiks"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Laika formāts"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Laika josla"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Laika josla"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datums"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Meklēšanas reģions"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Reģions"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"UTC nobīdes atlase"</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">"Izmantotā laika josla: <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> sākas šajā datumā: <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Tiek izmantots: <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Nav vasaras laika."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Vasaras laiks"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standarta laiks"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Atlasīt pēc reģiona"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Atlasīt pēc UTC nobīdes"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Bloķēt pēc ekrāna noildzes"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pēc noildzes"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Uzreiz pēc noildzes, ja vien bloķēšanu neliedz <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> pēc noildzes, ja vien bloķēšanu neliedz <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Pievien. tekstu bloķēš. ekrānā"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Nav"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Piem., Jāņa Android ierīce"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Atrašanās vieta"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Izmantot atrašanās vietu"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Izslēgta"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{Ieslēgta — # lietotnei ir piekļuve atrašanās vietai.}zero{Ieslēgta — # lietotnēm ir piekļuve atrašanās vietai.}one{Ieslēgta — # lietotnei ir piekļuve atrašanās vietai.}other{Ieslēgta — # lietotnēm ir piekļuve atrašanās vietai.}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Notiek ielāde…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Lietotnes, kurām ir atļauja noteikt tuvumā esošās ierīces, var noteikt pievienoto ierīču relatīvo pozīciju."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Lietotnēm un pakalpojumiem nav atļaujas piekļūt atrašanās vietai. Jūsu ierīces atrašanās vietas datus joprojām var nosūtīt ārkārtas dienestiem, ja zvanīsiet vai sūtīsiet īsziņu uz ārkārtas numuru."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Uzzināt vairāk par atrašanās vietas iestatījumiem."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Konti"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Drošība"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Šifrēšana un akreditācijas dati"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Bloķēšanas ekrāns"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Ko rādīt"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nav pieejama"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Drošības statuss"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Ekrāna bloķēšana, pakalpojums “Atrast ierīci”, lietotņu drošība"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Drošība un konfidencialitāte"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Lietotnes drošība, ierīces bloķēšana, atļaujas"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Seja pievienota"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Nepieciešama iestatīšana"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Autorizācija pēc sejas"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Autorizācija pēc sejas darba profilam"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Kā iestatīt autorizāciju pēc sejas"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Autorizācijas pēc sejas iestatīšana"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Autentificēšana, izmantojot seju"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Sākt"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Ja autorizācijai pēc sejas ir izslēgta pieejamības versija, noteiktas iestatīšanas darbības var nedarboties pareizi ar TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Atpakaļ"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Turpināt iestatīšanu"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Izmantot pieejamības iestatīšanu"</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">"Atcelt"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nē, paldies"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Piekrītu"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Vairāk"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Autorizācija pēc sejas"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Autorizācijas pēc sejas atļaušana"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Autentificēšana, izmantojot seju"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Izmantojiet sejas atpazīšanu, lai atbloķētu savu tālruni vai apstiprinātu pirkumus.\n\nPiezīme. Sejas atpazīšanu nevar izmantot šīs ierīces atbloķēšanai. Lai iegūtu plašāku informāciju, sazinieties ar savas organizācijas administratoru."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Varat izmantot seju, lai atbloķētu tālruni, apstiprinātu pirkumus un pierakstītos lietotnēs"</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">"Centrējiet seju aplī"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Izlaist"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Jūs esat pievienojis maksimālo seju skaitu."</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Nevar pievienot vairāk seju"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Reģistrēšana netika pabeigta."</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"LABI"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Ir sasniegts sejas reģistrēšanas laika ierobežojums. Mēģiniet vēlreiz."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Neizdevās reģistrēt seju."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Viss gatavs!"</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Gatavs"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Autorizācijas pēc sejas veiktspējas uzlabošana"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Vēlreiz iestatiet autorizāciju pēc sejas"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Autorizācijas pēc sejas atkārtota iestatīšana"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Drošības un veiktspējas uzlabošana"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Autorizācijas pēc sejas iestatīšana"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Lai vēlreiz iestatītu autorizāciju pēc sejas, izdzēsiet pašreizējo sejas modeli.\n\nSejas modelis tiks neatgriezeniski un droši izdzēsts.\n\nPēc izdzēšanas jums būs jāizmanto PIN, kombinācija vai parole, lai atbloķētu tālruni vai veiktu autentificēšanu lietotnēs."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Lai vēlreiz iestatītu autorizāciju pēc sejas, izdzēsiet pašreizējo sejas modeli.\n\nSejas modelis tiks neatgriezeniski un droši izdzēsts.\n\nPēc izdzēšanas jums būs jāizmanto pirksta nospiedums, PIN, kombinācija vai parole, lai atbloķētu tālruni vai veiktu autentificēšanu lietotnēs."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Autoriz. pēc sejas:"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Iestatījumi autorizācijai pēc sejas"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Jābūt atvērtām acīm"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Lai atbloķētu tālruni, jūsu acīm ir jābūt atvērtām"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Vienmēr pieprasīt apstiprinājumu"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Autorizācijai pēc sejas lietotnēs vienmēr pieprasīt apstiprinājumu"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Dzēst sejas modeli"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Iestatīt autorizāciju pēc sejas"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Vai dzēst sejas modeli?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Jūsu sejas modelis tiks neatgriezeniski un droši izdzēsts.\n\nPēc tā dzēšanas jums būs jāizmanto PIN, kombinācija vai parole, lai atbloķētu savu tālruni vai veiktu autentifikāciju lietotnēs."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Jūsu sejas modelis tiks neatgriezeniski un droši izdzēsts.\n\nPēc tā dzēšanas jums būs jāizmanto PIN, kombinācija vai parole, lai atbloķētu savu tālruni."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Jūsu sejas modelis tiks neatgriezeniski un droši dzēsts.\n\nPēc tā dzēšanas jums būs jāizmanto pirksta nospiedums, PIN, kombinācija vai parole, lai atbloķētu savu tālruni vai veiktu autentifikāciju lietotnēs."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Jūsu sejas modelis tiks neatgriezeniski un droši dzēsts.\n\nPēc tā dzēšanas jums būs jāizmanto pirksta nospiedums, PIN, kombinācija vai parole, lai atbloķētu savu tālruni."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Izmantot tālruņa atbloķēšanai autorizāciju pēc sejas"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Pirksta nospiedums"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Pirkstu nospiedumi"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Autorizācijas ar pirksta nospiedumu izmantošana"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Pirksta nospiedums darbam"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Pievienot pirksta nospiedumu"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Pievienots pirksta nospiedums.}zero{Pievienoti # pirkstu nospiedumi.}one{Pievienots # pirkstu nospiedums.}other{Pievienoti # pirkstu nospiedumi.}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Nepieciešama iestatīšana"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Pirksta nospied. iestatīšana"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Autorizācija ar pirksta nospiedumu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Pirksta nospieduma lietošana"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Plašāka informācija par autorizāciju ar pirksta nospiedumu"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Viss ir jūsu pārziņā"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Visu nosakāt jūs un jūsu bērns"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Svarīga informācija"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Izmantojiet pirksta nospiedumu, lai autorizētu tālruni vai apstiprinātu pirkumu.\n\nPiezīme. Pirksta nospiedumu nevar izmantot šīs ierīces atbloķēšanai. Lai iegūtu plašāku informāciju, sazinieties ar savas organizācijas administratoru."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Atcelt"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nē, paldies"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Piekrītu"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Izlaist pirksta nospiedumu?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Pirksta nospieduma iestatīšana ilgst tikai pāris minūtes. Ja to izlaidīsiet, varēsiet pirksta nospiedumu pievienot vēlāk iestatījumos."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Kad redzat šo ikonu, autentifikācijai izmantojiet pirksta nospiedumu, piemēram, kad reģistrējaties lietotnēs vai apstiprināt pirkumus"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Svarīga informācija"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Darbības principi"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Iestatot autorizāciju ar pirksta nospiedumu, tiek izveidots unikāls jūsu pirksta nospieduma modelis jūsu identitātes apstiprināšanai. Lai iestatīšanas laikā izveidotu šo pirksta nospieduma modeli, jūs uzņemsiet pirksta nospieduma attēlus no dažādām pozīcijām."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Iestatot autorizāciju ar pirksta nospiedumu, tiek izveidots unikāls jūsu bērna pirksta nospieduma modelis viņa identitātes apstiprināšanai. Lai iestatīšanas laikā izveidotu šo pirksta nospieduma modeli, jūsu bērns uzņems pirksta nospieduma attēlus no dažādām pozīcijām."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Lai iegūtu vislabākos rezultātus, izmantojiet ekrāna aizsargplēvi, kam ir “Made for Google” sertifikāts. Ar citām ekrāna aizsargplēvēm jūsu pirksta nospiedums, iespējams, nedarbosies."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Lai iegūtu vislabākos rezultātus, izmantojiet ekrāna aizsargplēvi, kam ir “Made for Google” sertifikāts. Ar citām ekrāna aizsargplēvēm jūsu bērna pirksta nospiedums, iespējams, nedarbosies."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Atbloķēšana ar pulksteni"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Ja iestatīsiet autorizāciju pēc sejas un autorizāciju ar pirksta nospiedumu, tālrunī tiks pieprasīts pirksta nospiedums, kad valkāsiet masku vai atradīsieties tumšā vietā.\n\nJa seja vai pirksta nospiedums netiek atpazīts, atbloķēšanai varat izmantot pulksteni."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Ja pirksta nospiedums netiek atpazīts, atbloķēšanai varat izmantot pulksteni."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Ja seja netiek atpazīta, atbloķēšanai varat izmantot pulksteni."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Izmantojiet pirksta nospiedumu vai pulksteni, lai"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Izmantojiet seju vai pulksteni, lai"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Izmantojiet seju, pirksta nospiedumu vai pulksteni, lai"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Izmantojiet pulksteni, lai"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Sejas vai pulksteņa lietošana"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Pirksta nospieduma vai pulksteņa lietošana"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Sejas, pirksta nospieduma vai pulksteņa lietošana"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Pulksteņa lietošana"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Iestatiet autorizāciju pēc sejas vai pirksta nospieduma"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Ja seja vai pirksta nospiedums netiek atpazīts, atbloķēšanai varat izmantot pulksteni"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Vispirms iestatiet autorizāciju ar pirksta nospiedumu"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Ja pirksta nospiedums netiek atpazīts, atbloķēšanai varat izmantot pulksteni"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Vispirms iestatiet autorizāciju pēc sejas"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Ja seja netiek atpazīta, atbloķēšanai varat izmantot pulksteni"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Iestatīt"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Pievienots pirksta nospiedums un pulkstenis <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Pievienoti pirkstu nospiedumi un pulkstenis <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Pievienota seja un pulkstenis <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Pievienota seja, pirksta nospiedums un pulkstenis <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Pievienota seja, pirkstu nospiedumi un pulkstenis <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Autorizācija pēc sejas un pirksta nospieduma"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Autorizācija pēc sejas un pirksta nospieduma darba profilam"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Nepieciešama iestatīšana"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Seja un pirksta nospiedumi ir pievienoti"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Seja un pirksta nospiedums ir pievienots"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Ja iestatīsiet autorizāciju pēc sejas un autorizāciju ar pirksta nospiedumu, tālrunī tiks pieprasīts pirksta nospiedums, kad valkāsiet masku vai atradīsieties tumšā vietā."</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Atbloķēšanas iespējas"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Izmantojot seju vai pirksta nospiedumu"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Atbloķēt tālruni"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Lietotnēs verificēt jūsu identitāti"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Izmantojot autorizāciju pēc sejas"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Izmantojot autorizāciju ar pirksta nospiedumu"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Izmantojot seju/pirksta nospiedumu"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"Labi"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Nevar iestatīt autorizāciju pēc sejas"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Izejiet no ekrāna sadalīšanas režīma, lai iestatītu autorizāciju pēc sejas."</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Nevar iestatīt pirksta nospiedumu"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Izejiet no ekrāna sadalīšanas režīma, lai iestatītu autorizāciju ar pirksta nospiedumu."</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"Labi"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Vai izlaist ekrāna bloķēšanu?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Tomēr izlaist"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Atpakaļ"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Izlaist"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Atcelt"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Pieskarieties sensoram"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Pieskarieties barošanas pogai, bet nenospiediet to"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Pirksta nospieduma iestatīšana"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Tas atrodas tālruņa aizmugurē. Izmantojiet rādītājpirkstu."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Pirksta nospieduma sensors atrodas uz ekrāna. Nākamajā ekrānā tiks tverts viss pirksta nospiedums."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Sākt"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Lai atrastu sensoru, pārvietojiet pirkstu pa ekrānu. Pieskarieties pirksta nospieduma sensoram un turiet to."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Attēls ar ierīci un pirkstu nospiedumu sensora atrašanās vietu uz tās"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nosaukums"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Labi"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Mēģināt vēlreiz"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Dzēst"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Pieskarieties sensoram"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Novietojiet pirkstu uz sensora un paceliet to pēc tam, kad sajūtat vibrāciju"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Turiet pirkstu plakaniski uz sensora, līdz sajūtat vibrāciju."</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Nenospiežot pogu, turiet pirkstu uz sensora, līdz sajūtat vibrāciju.\n\nIkreiz, kad sajūtat vibrāciju, nedaudz pārvietojiet savu pirkstu. Tādējādi tiks tverta plašāka pirksta nospieduma daļa."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Pieskarieties pirksta nospieduma sensoram un turiet to"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Pieskarieties vēlreiz"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Vēlreiz…"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Atkārtota pieskaršanās pirksta nospieduma ikonai"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Atkārtoti uzlieciet pirkstu, lai pievienotu dažādas pirksta nospieduma daļas."</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Pieskarieties pirksta nospieduma ikonai un turiet to ikreiz, kad tā pārvietojas. Tādējādi tiks tverts plašāks pirksta nospiedums."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Novietojiet pirksta galu uz sensora"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Novietojiet pirksta kreiso sānu"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Novietojiet pirksta labo sānu"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Novietojiet pirksta vidusdaļu uz sensora"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Novietojiet pirksta galu uz sensora"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Novietojiet uz sensora pirksta kreiso sānu"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Visbeidzot novietojiet uz sensora pirksta labo sānu"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Novietojiet pirksta sānu uz sensora un turiet, pēc tam novietojiet otru pirksta sānu."</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Tādējādi tiks tverts plašāks pirksta nospiedums."</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Pirksta nospieduma reģistrēšana: <xliff:g id="PERCENTAGE">%d</xliff:g> procenti"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Reģistrēšanas progresa procenti: <xliff:g id="PERCENTAGE">%d</xliff:g>"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Pirksta nospieduma reģistrēšana: <xliff:g id="PERCENTAGE">%d</xliff:g> procenti"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Pirksta nospiedums pievienots"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Pieskarieties un atbloķējiet jebkurā laikā"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Pieskarieties sensoram, lai atbloķētu ierīci, pat ja ekrāns ir izslēgts. Tādējādi tiek palielināta nejaušas atbloķēšanas iespējamība."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Ekrāns, atbloķēšana"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Vēlāk"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Paceliet un vēlreiz pieskarieties"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Novietojiet pirksta sānu uz sensora un turiet, bet pēc tam novietojiet otru pirksta sānu"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Izlaist pirksta nospieduma iestatīšanu?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Jūs izvēlējāties pirksta nospiedumu kā vienu no tālruņa autorizācijas iespējām. Ja izlaidīsiet šo darbību, iestatīšana būs jāveic vēlāk. Iestatīšanai nepieciešama aptuveni viena minūte."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"<xliff:g id="OPTIONS">%s</xliff:g>: vai izlaist iestatīšanu?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Vai izlaist PIN iestatīšanu?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Vai neiestatīt PIN un seju?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Vai neiestatīt PIN un pirksta nospiedumu?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Vai neiestatīt PIN, seju un pirksta nospiedumu?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Vai izlaist paroles iestatīšanu?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Vai neiestatīt paroli un seju?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Vai neiestatīt paroli un pirksta nospiedumu?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Vai neiestatīt paroli, seju un pirksta nospiedumu?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Vai izlaist kombinācijas iestatīšanu?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Vai neiestatīt kombināciju un seju?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Vai neiestatīt kombināciju un pirksta nospied.?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Vai neiestatīt kombināciju, seju un nospiedumu?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Iestatīt ekrāna bloķēšanu"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Gatavs"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Tas nav sensors!"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Pieskarieties sensoram tālruņa aizmugurē ar rādītājpirkstu."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Nevar pabeigt nospieduma iestatīšanu"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Varat mēģināt vēlreiz tūlīt vai iestatīt pirksta nospiedumu vēlāk sadaļā Iestatījumi."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Varat mēģināt vēlreiz tūlīt vai iestatīt pirksta nospiedumu vēlāk."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Iestatot pirksta nospiedumu, iestājās noildze"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Varat vēlāk iestatīt pirksta nospiedumu sadaļā Iestatījumi."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Radās problēma. Varat vēlāk iestatīt pirksta nospiedumu sadaļā Iestatījumi."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Varat iestatīt pirksta nospiedumu vēlāk."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Radās problēma. Varat vēlāk iestatīt pirksta nospiedumu."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Pievienot citu"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Tālāk"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Ekrāna bloķēšanas opcija ir atspējota. Lai uzzinātu vairāk, sazinieties ar organizācijas administratoru."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Jūs joprojām varat izmantot pirksta nospiedumu, lai apstiprinātu pirkumus un lietotņu piekļuvi."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Paceliet pirkstu un pēc tam vēlreiz pieskarieties sensoram."</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Nevar izmantot pirksta nospieduma sensoru"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Sazinieties ar remonta pakalpojumu sniedzēju."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Vairāk drošības iestatījumu"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Darba profila bloķēšana, šifrēšana u.c."</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Šifrēšana, akreditācijas dati u.c."</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"drošība, vairāk drošības iestatījumu, vairāk iestatījumu, papildu drošības iestatījumi"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Citi konfidencialitātes iestatījumi"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Citi drošības un konfidencialitātes iestatījumi"</string>
    <string name="security_header" msgid="961514795852103424">"Drošība"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Konfidencialitāte"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Darba profils"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Varat pievienot līdz <xliff:g id="COUNT">%d</xliff:g> pirkstu nospiedumiem."</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Jūs esat pievienojis maksimālo pirkstu nospiedumu skaitu."</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nevar pievienot citus pirkstu nospiedumus."</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Pirksta nospieduma “<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>” dzēšana"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Jūs nevarēsiet izmantot pirksta nospiedumu, lai atbloķētu darba profilu, autorizētu pirkumus vai pierakstītos darba lietotnēs."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Šifrēšana"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Šifrēts"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Iestatiet ekrāna bloķēšanu"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Papildu drošībai iestatiet šajā ierīcē PIN, kombināciju vai paroli."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Iestatīt ekrāna bloķēšanu"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Iestatiet ekrāna bloķēšanu"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Papildu drošībai iestatiet šajā ierīcē PIN, kombināciju vai paroli."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Tālruņa drošība"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Lai autorizētu, pievienojiet pirksta nospiedumu"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Ekrāna bloķēšana"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Ekrāna bloķēšanas veids"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Jauns ekr. bloķēšanas veids"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Darba lietotņu bloķēšana"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Jauns bloķēš. veids darbam"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Papildu drošībai iestatiet rezerves ekrāna bloķēšanu"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Izvēlieties rezerves ekrāna bloķēšanas metodi"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Ja aizmirsīsiet savu ekrāna bloķēšanas opciju, IT administrators nevarēs to atiestatīt."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Iestatīt atsevišķu bloķēšanas opciju darba lietotnēm"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Ja aizmirsīsiet, kā atbloķēt, lūdziet IT administratoram atiestatīt bloķēšanu"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Ekrāna bloķēšanas opcijas"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Ekrāna bloķēšanas opcijas"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Atbloķēt, izmantojot automātisko apstiprināšanu"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Var automātiski atbloķēt ierīci, ja jūs ievadāt pareizu PIN, kura garums ir vismaz 6 cipari. Tas ir mazliet mazāk droši nekā apstiprināt, pieskaroties ievadīšanas pogai."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Automātiski apstiprināt pareizo PIN"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"PIN apstiprināšana, pieskaroties ievadīšanas pogai, ir drošāka nekā automātiskā apstiprināšana."</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Lai iespējotu automātisko apstiprināšanu, ievadiet ierīces PIN."</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Lai atspējotu automātisko apstiprināšanu, ievadiet ierīces PIN."</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Ekrāna bloķēšana"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Darba profila bloķēšana"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Nav"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Vilkšana"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Kombinācija"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Parole"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ne tagad"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Pašreizējais ekrāna bloķēšanas iestatījums"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Kombinācija • Pirksta nospiedums"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Pirksta nospiedums"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Parole • Pirksta nospiedums"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Turpināt bez pirksta nospieduma"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Kombinācija • Seja"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Seja"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Parole • Seja"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Turpināt bez autorizācijas pēc sejas"</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Kombinācija • seja • pirksta nospiedums"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"PIN • seja • pirksta nospiedums"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Parole • seja • pirksta nospiedums"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Turpināt, neiestatot seju vai pirksta nospiedumu"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Nav"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Vilkšana"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Kombinācija"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Parole"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Vai atspējot ekrāna bloķēšanu?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Vai noņemt profila aizsardzību?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Kombinācija aizsargā tālruni, ja tas tiek nozaudēts vai nozagts"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Kombinācija aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Veicot šo darbību, tiks izdzēsts arī ierīcē saglabātais pirksta nospieduma modelis. Lietotnēs nevarēsiet izmantot pirksta nospiedumu autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Kombinācija aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Arī sejas modelis tiks neatgriezeniski un droši izdzēsts. Lietotnēs nevarēsiet izmantot seju autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Kombinācija aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Veicot šo darbību, tiks izdzēsts ierīcē saglabātais pirksta nospieduma modelis. Arī sejas modelis tiks neatgriezeniski un droši izdzēsts. Lietotnēs nevarēsiet izmantot seju vai pirksta nospiedumu autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"PIN aizsargā tālruni, ja tas tiek nozaudēts vai nozagts"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"PIN aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Veicot šo darbību, tiks izdzēsts arī ierīcē saglabātais pirksta nospieduma modelis. Lietotnēs nevarēsiet izmantot pirksta nospiedumu autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"PIN aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Arī sejas modelis tiks neatgriezeniski un droši izdzēsts. Lietotnēs nevarēsiet izmantot seju autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"PIN aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Veicot šo darbību, tiks izdzēsts ierīcē saglabātais pirksta nospieduma modelis. Arī sejas modelis tiks neatgriezeniski un droši izdzēsts. Lietotnēs nevarēsiet izmantot seju vai pirksta nospiedumu autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Parole aizsargā tālruni, ja tas tiek nozaudēts vai nozagts"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Parole aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Veicot šo darbību, tiks izdzēsts arī ierīcē saglabātais pirksta nospieduma modelis. Lietotnēs nevarēsiet izmantot pirksta nospiedumu autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Parole aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Arī sejas modelis tiks neatgriezeniski un droši izdzēsts. Lietotnēs nevarēsiet izmantot seju autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Parole aizsargā tālruni, ja tas tiek nozaudēts vai nozagts.<xliff:g id="EMPTY_LINE">

</xliff:g>Veicot šo darbību, tiks izdzēsts ierīcē saglabātais pirksta nospieduma modelis. Arī sejas modelis tiks neatgriezeniski un droši izdzēsts. Lietotnēs nevarēsiet izmantot seju vai pirksta nospiedumu autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Ja tiks atspējota ekrāna bloķēšana, ierīces aizsardzības funkcijas nedarbosies."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Ja tiks atspējota ekrāna bloķēšana, ierīces aizsardzības funkcijas nedarbosies.<xliff:g id="EMPTY_LINE">

</xliff:g>Veicot šo darbību, tiks izdzēsts arī ierīcē saglabātais pirksta nospieduma modelis. Lietotnēs nevarēsiet izmantot pirksta nospiedumu autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Ja tiks atspējota ekrāna bloķēšana, ierīces aizsardzības funkcijas nedarbosies.<xliff:g id="EMPTY_LINE">

</xliff:g>Arī sejas modelis tiks neatgriezeniski un droši izdzēsts. Lietotnēs nevarēsiet izmantot seju autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Ja tiks atspējota ekrāna bloķēšana, ierīces aizsardzības funkcijas nedarbosies.<xliff:g id="EMPTY_LINE">

</xliff:g>Veicot šo darbību, tiks izdzēsts ierīcē saglabātais pirksta nospieduma modelis. Arī sejas modelis tiks neatgriezeniski un droši izdzēsts. Lietotnēs nevarēsiet izmantot seju vai pirksta nospiedumu autentifikācijai."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Dzēst"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> iesaka izmantot drošu PIN vai paroli un bez tās var nedarboties, kā paredzēts"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> iesaka izmantot jaunu PIN vai paroli un bez tās var nedarboties, kā paredzēts"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> iesaka izmantot jaunu kombināciju, PIN vai paroli un bez tās var nedarboties, kā paredzēts"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> iesaka jaunu ekrāna bloķēšanas iespēju"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Mēģiniet vēlreiz (<xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>. mēģinājums no <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>)."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Jūsu dati tiks dzēsti."</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Ja nākamajā mēģinājumā ievadīsiet nepareizu kombināciju, dati šajā ierīcē tiks dzēsti."</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Ja nākamajā mēģinājumā ievadīsiet nepareizu PIN, dati šajā ierīcē tiks dzēsti."</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Ja nākamajā mēģinājumā ievadīsiet nepareizu paroli, dati šajā ierīcē tiks dzēsti."</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Ja nākamajā mēģinājumā ievadīsiet nepareizu kombināciju, šis lietotājs tiks dzēsts."</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Ja nākamajā mēģinājumā ievadīsiet nepareizu PIN, šis lietotājs tiks dzēsts."</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Ja nākamajā mēģinājumā ievadīsiet nepareizu paroli, šis lietotājs tiks dzēsts."</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Ja nākamajā mēģinājumā ievadīsiet nepareizu kombināciju, jūsu darba profils un ar to saistītie dati tiks dzēsti."</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Ja nākamajā mēģinājumā ievadīsiet nepareizu PIN, jūsu darba profils un ar to saistītie dati tiks dzēsti."</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Ja nākamajā mēģinājumā ievadīsiet nepareizu paroli, jūsu darba profils un ar to saistītie dati tiks dzēsti."</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Ir jābūt vismaz # rakstzīmei.}zero{Ir jābūt vismaz # rakstzīmēm.}one{Ir jābūt vismaz # rakstzīmei.}other{Ir jābūt vismaz # rakstzīmēm.}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Ja izmantojat tikai ciparus, parolē ir jābūt vismaz 1 ciparam.}zero{Ja izmantojat tikai ciparus, parolē ir jābūt vismaz # cipariem.}one{Ja izmantojat tikai ciparus, parolē ir jābūt vismaz # ciparam.}other{Ja izmantojat tikai ciparus, parolē ir jābūt vismaz # cipariem.}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN kodā ir jābūt vismaz # ciparam.}zero{PIN kodā ir jābūt vismaz # cipariem.}one{PIN kodā ir jābūt vismaz # ciparam.}other{PIN kodā ir jābūt vismaz # cipariem.}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN kodā ir jābūt vismaz # ciparam, taču papildu drošībai ieteicams izmantot vismaz {minAutoConfirmLen} ciparu PIN kodu.}zero{PIN kodā ir jābūt vismaz # cipariem, taču papildu drošībai ieteicams izmantot vismaz {minAutoConfirmLen} ciparu PIN kodu.}one{PIN kodā ir jābūt vismaz # ciparam, taču papildu drošībai ieteicams izmantot vismaz {minAutoConfirmLen} ciparu PIN kodu.}other{PIN kodā ir jābūt vismaz # cipariem, taču papildu drošībai ieteicams izmantot vismaz {minAutoConfirmLen} ciparu PIN kodu.}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Ir jābūt mazāk nekā # rakstzīmei.}zero{Ir jābūt mazāk nekā # rakstzīmēm.}one{Ir jābūt mazāk nekā # rakstzīmei.}other{Ir jābūt mazāk nekā # rakstzīmēm.}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Ir jābūt mazāk nekā # ciparam.}zero{Ir jābūt mazāk nekā # cipariem.}one{Ir jābūt mazāk nekā # ciparam.}other{Ir jābūt mazāk nekā # cipariem.}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Ierīces administrators neļauj izmantot nesen izveidotu PIN."</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Nedrīkst ietvert nederīgu rakstzīmi."</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Ir jāietver vismaz viens burts.}zero{Ir jāietver vismaz # burti.}one{Ir jāietver vismaz # burts.}other{Ir jāietver vismaz # burti.}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Ir jāietver vismaz viens mazais burts.}zero{Ir jāietver vismaz # mazie burti.}one{Ir jāietver vismaz # mazais burts.}other{Ir jāietver vismaz # mazie burti.}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Ir jāietver vismaz viens lielais burts.}zero{Ir jāietver vismaz # lielie burti.}one{Ir jāietver vismaz # lielais burts.}other{Ir jāietver vismaz # lielie burti.}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Ir jāietver vismaz viens cipars.}zero{Ir jāietver vismaz # cipari.}one{Ir jāietver vismaz # cipars.}other{Ir jāietver vismaz # cipari.}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Ir jāietver vismaz viena speciālā rakstzīme.}zero{Ir jāietver vismaz # speciālās rakstzīmes.}one{Ir jāietver vismaz # speciālā rakstzīme.}other{Ir jāietver vismaz # speciālās rakstzīmes.}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Ir jāietver vismaz viena rakstzīme, kas nav burts.}zero{Ir jāietver vismaz # rakstzīmes, kas nav burti.}one{Ir jāietver vismaz # rakstzīme, kas nav burti.}other{Ir jāietver vismaz # rakstzīmes, kas nav burti.}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Ir jāietver vismaz viena rakstzīme, kas nav cipars.}zero{Ir jāietver vismaz # rakstzīmes, kas nav cipari.}one{Ir jāietver vismaz # rakstzīme, kas nav cipari.}other{Ir jāietver vismaz # rakstzīmes, kas nav cipari.}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Ierīces administrators neļauj izmantot nesen izveidotu paroli."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Augoša, dilstoša vai atkārtota ciparu secība nav atļauta."</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Apstiprināt"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Labi"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Ekrāna bloķēšanas parole jau tika nomainīta. Mēģiniet vēlreiz, norādot jauno ekrāna bloķēšanas paroli."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Atcelt"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Tālāk"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Ierīces administratora lietotnes"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Nav aktīvu lietotņu"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktīva lietotne}zero{# aktīvu lietotņu}one{# aktīva lietotne}other{# aktīvas lietotnes}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Uzticamie aģenti"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Lai to izmantotu, vispirms ir jāiestata ekrāna bloķēšana"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Nav"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{Viena aktīva uzticamības pārbaudes programma}zero{# aktīvu uzticamības pārbaudes programmu}one{# aktīva uzticamības pārbaudes programma}other{# aktīvas uzticamības pārbaudes programmas}}"</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">"Vai savienot pārī ar ierīci <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Pievienojiet jaunu ierīci esošajai koordinētajai kopai"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetooth kods savienošanai pārī"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Ierakstiet kodu savienošanai pārī un pēc tam nospiediet ievadīšanas taustiņu."</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN ietver burtus un simbolus."</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Parasti 0000 vai 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Jābūt 16 cipariem"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Iespējams, šis PIN būs jāievada arī otrā ierīcē."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Iespējams, šī ieejas atslēga būs jāievada arī otrā ierīcē."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Apstipriniet, lai savienotu pārī ar koordinēto kopu."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Atļaut piekļuvi jūsu kontaktpersonām un zvanu vēsturei"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nevarēja izveidot savienojumu ar ierīci <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Pieejamās ierīces"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Izveidot savienojumu"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Atvienot"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Izveidot pāri un savienojumu"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Kad Bluetooth ir ieslēgts, ierīce var sazināties ar citām Bluetooth ierīcēm tuvumā."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Kad ir ieslēgts Bluetooth savienojums, jūsu ierīce var sazināties ar tuvumā esošām Bluetooth ierīcēm.\n\nLai uzlabotu ierīču izmantošanas iespējas, lietotnes un pakalpojumi var meklēt tuvumā esošas ierīces jebkurā laikā, pat ja Bluetooth savienojums ir izslēgts. Šo iestatījumu var izmantot, piemēram, lai uzlabotu ar atrašanās vietu saistītas funkcijas un pakalpojumus, un to var mainīt Bluetooth meklēšanas iestatījumos."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Mainīt"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Ierīces dati"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Tastatūras iestatījumi"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Ierīces Bluetooth adrese: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Ierīces Bluetooth adrese:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Vai aizmirst ierīci?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Noņemt saistījumu"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Vai atvienot lietotni?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Lietotne <xliff:g id="APP_NAME">%1$s</xliff:g> vairs netiks savienota ar jūsu ierīci (<xliff:g id="DEVICE_NAME">%2$s</xliff:g>)."</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Eksperimentāla. Uzlabo audio kvalitāti."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Aizmirst ierīci"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Lietotnes atvienošana"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Pievienoto Bluetooth audioierīču maksimālais skaits"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Pievienoto Bluetooth audioierīču maksimālā skaita atlase"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"NFC steka atkļūdošanas žurnāls"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Palielināt NFC steka reģistrēšanas līmeni"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Detalizēti NFC nodrošinātāju atkļūdošanas žurnāli"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Iekļaut kļūdu pārskatos konkrētas ierīces papildu nodrošinātāju žurnālus, kuros var būt ietverta privāta informācija."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"NFC NCI nefiltrētas uzskaites žurnāls"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Tvert detalizētu NFC datu paketes, kurās var būt ietverta privāta informācija."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Vai restartēt ierīci?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Detalizētu NFC datu reģistrēšana ir paredzēta tikai ar izstrādi saistītiem nolūkiem. Papildu NFC dati tiek iekļauti kļūdu pārskatos, un tajos var būt ietverta privāta informācija. Lai mainītu šo iestatījumu, restartējiet ierīci."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Restartēt"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Apraide"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"spogulis"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Bezvadu attēlošanas iespējošana"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Tuvumā nav atrasta neviena ierīce."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Notiek savienojuma izveide."</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Pievienotas"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Tiek lietota"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nav pieejama"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Bezvadu attēlošanas opcijas"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Aizmirst"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Gatavs"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nosaukums"</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">"Pierakstīties"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Atvērt vietni"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Atlikušais laiks: <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Darbības termiņš: <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">"Lietotnē <xliff:g id="REQUESTER">%s</xliff:g> tiek mēģināts ieslēgt Wi-Fi savienojumu."</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"Lietotnē <xliff:g id="REQUESTER">%s</xliff:g> tiek mēģināts izslēgt Wi-Fi savienojumu."</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verificēt atkļūdojamu lietotņu bitu kodu"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Atļaut ART verificēt atkļūdojamu lietotņu bitu kodu"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Rādīt atsvaidzin. biežumu"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Rādīt pašreizējo displeja atsvaidzināšanas biežumu"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Pieprasīt ierīces atbloķēšanu tehnoloģijai NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Gatavs pārraidīt lietotnes saturu, izmantojot NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Izslēgta"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nav pieejams, jo NFC ir izslēgti."</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Ja šī funkcija ir ieslēgta, varat novietot ierīces blakus un kopīgot lietotņu saturu, izmantojot funkciju Beam, citās ierīcēs, kas atbalsta NFC. Piemēram, šādi varat kopīgot tīmekļa lapas, YouTube videoklipus, kontaktpersonas un citu saturu.\n\nVienkārši novietojiet ierīces blakus (parasti saskaroties to aizmugures daļām) un pieskarieties savam ekrānam. Lietotne nosaka, kāds saturs tiek kopīgots, izmantojot funkciju Beam."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Izmantot Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Wi-Fi iestatījumi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Atlasīt Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Notiek Wi-Fi ieslēgšana..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Notiek Wi-Fi izslēgšana..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Kļūda"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz josla nav pieejama šajā valstī."</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Lidmašīnas režīmā"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Paziņojumi par publiskiem tīkliem"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Paziņot, kad ir pieejams augstas kvalitātes publiskais tīkls"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Automātiski ieslēgt Wi‑Fi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi‑Fi tiks automātiski atkārtoti ieslēgts netālu no saglabātiem augstas kvalitātes tīkliem, piemēram, netālu no mājas tīkla."</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nav pieejama, jo ir izslēgta piekļuve atrašanās vietas datiem. Ieslēgt "<annotation id="link">"piekļuvi atrašanās vietas datiem"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instalēt sertifikātu"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Lai precīzāk noteiktu atrašanās vietu, lietotnes un pakalpojumi varēs meklēs Wi-Fi tīklus, pat ja Wi-Fi būs izslēgts. Šo iestatījumu var izmantot, piemēram, lai uzlabotu ar atrašanās vietu saistītas funkcijas un pakalpojumus. Varat to mainīt <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Wi-Fi meklēšanas iestatījumos<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Lai uzlabotu atrašanās vietas noteikšanas precizitāti, <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Wi-Fi meklēšanas iestatījumos<xliff:g id="LINK_END_1">LINK_END</xliff:g> ieslēdziet Wi-Fi meklēšanu."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automātiski pārslēgties uz mobilajiem datiem"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Izmantojiet mobilo datu savienojumu, kad Wi‑Fi tīklā nav piekļuves internetam. Var tikt piemērota maksa par datu lietojumu."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Pievienot tīklu"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Wi‑Fi preferences"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi savienojums tiek automātiski atkārtoti ieslēgts."</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi savienojums netiek automātiski atkārtoti ieslēgts."</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Lai skatītu pieejamos tīklus, ieslēdziet Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Notiek tīklu meklēšana…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Jums nav atļaujas mainīt Wi‑Fi tīklu."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Vai ieslēgt Wi‑Fi meklēšanu?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Lai automātiski izslēgtu Wi‑Fi, vispirms iespējojiet Wi‑Fi meklēšanu."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Veicot Wi‑Fi meklēšanu, lietotnes un pakalpojumi var meklēt Wi-Fi tīklus vienmēr, pat ja Wi-Fi savienojums ir izslēgts. Šo iestatījumu var izmantot, piemēram, lai uzlabotu atrašanās vietas funkcijas un pakalpojumus."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Ieslēgt"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Wi‑Fi meklēšana ir ieslēgta"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Papildu opcijas"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Nolaižamais saraksts “Papildu opcijas”"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"izvērst"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Tīkla nosaukums"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Ievadiet SSID."</string>
    <string name="wifi_security" msgid="9095934643631406913">"Drošība"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Slēpts tīkls"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Ja maršrutētājs pārraida tīkla ID, bet jūs vēlaties arī turpmāk izveidot ar to savienojumu, iestatiet tīklu kā slēptu.\n\nTādā veidā var tikt radīts drošības apdraudējums, jo tālrunis regulāri pārraidīs signālu, lai atrastu tīklu.\n\nIestatot tīklu kā slēptu, maršrutētāja iestatījumi netiks mainīti."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Signāla stiprums"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Statuss"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Datu pārsūtīšanas ātrums"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Datu saņemšanas ātrums"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Saites izveides ātrums"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Biežums"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP adrese"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Saglabāts, izmantojot"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Lietotāja <xliff:g id="NAME">%1$s</xliff:g> akreditācijas dati"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP metode"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"2. fāzes autentifikācija"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA sertifikāts"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Vecākā atbalstītā TLS versija"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Tiešsaistes sertifikāta statuss"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domēns"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Lietotāja sertifikāts"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identifikācijas dati"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonīmi identifikācijas dati"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Parole"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Rādīt paroli"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4 GHz josla"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Ieteicama 5,0 GHz josla"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP iestatījumi"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Konfidencialitāte"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Abonements"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Skatīt vai mainīt abonementu"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Nejauši atlasīta MAC adr."</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Ierīces pievienošana"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Lai izveidotu ierīces savienojumu ar <xliff:g id="SSID">%1$s</xliff:g>, centrējiet tālāk norādīto kvadrātkodu."</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Kvadrātkoda skenēšana"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Lai izveidotu savienojumu ar <xliff:g id="SSID">%1$s</xliff:g>, centrējiet tālāk norādīto kvadrātkodu."</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Lai pievienotos Wi-Fi tīklam, skenējiet kvadrātkodu."</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Wi‑Fi tīkla koplietošana"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Lai pievienotos tīklam “<xliff:g id="SSID">%1$s</xliff:g>”, skenējiet šo kvadrātkodu, izmantojot citu ierīci."</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Lai izveidotu savienojumu ar tīklu <xliff:g id="SSID">%1$s</xliff:g>, skenējiet šo kvadrātkodu"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Mēģiniet vēlreiz. Ja problēma joprojām pastāv, sazinieties ar ierīces ražotāju."</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Radās problēma"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Ierīcei ir jābūt pievienotai, uzlādētai un ieslēgtai"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Ierīcei ir jābūt pievienotai, uzlādētai un ieslēgtai. Ja problēma joprojām pastāv, sazinieties ar ierīces ražotāju."</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"“<xliff:g id="SSID">%1$s</xliff:g>” pievienošana šajā ierīcē netiek atbalstīta"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Pārvietojiet ierīci tuvāk Wi-Fi piekļuves punktam/ maršrutētājam"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Pārbaudiet paroli un mēģiniet vēlreiz"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Sazinieties ar ierīces ražotāju"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Pārbaudiet savienojumu un mēģiniet vēlreiz"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Tīkla izvēle"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Lai pievienotu ierīci, izvēlieties tīklu."</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Vai pievienot šo ierīci tīklam <xliff:g id="SSID">%1$s</xliff:g>?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi tīkls ir kopīgots ar ierīci"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Pievienot citu ierīci"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Izvēlēties citu tīklu"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Nevarēja pievienot ierīci."</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Atrasta ierīce"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Notiek Wi‑Fi kopīgošana ar šo ierīci…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Notiek savienojuma izveide…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Tīklāja kopīgošana"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Identitātes apstiprināšana"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Wi-Fi tīkla parole: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Tīklāja parole: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automātiski izveidot savienojumu"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Atļaujiet savienojuma izveidi ar šo tīklu, kad tas ir pieejams"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Pievienot ierīci"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Izmantojiet kvadrātkodu, lai pievienotu ierīci šim tīklam"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Kvadrātkoda formāts nav derīgs."</string>
    <string name="retry" msgid="7542103800274026915">"Mēģināt vēlreiz"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Koplietot ar citiem ierīces lietotājiem"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(bez izmaiņām)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Lūdzu, atlasiet"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Pievienoti vairāki sertifikāti)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Izmantot sistēmas sertifikātus"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Nenorādīt"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Uzticēties, lietojot pirmo reizi"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Tīkla nosaukums ir pārāk garš."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Norādiet domēnu."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Nepieciešams sertifikāts."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Lai uzlabotu atrašanās vietu noteikšanas precizitāti, kā arī citas funkcijas, lietotnē <xliff:g id="APP_NAME">%1$s</xliff:g> tiek pieprasīts ieslēgt tīkla skenēšanu, pat ja Wi-Fi savienojums ir izslēgts.\n\nVai atļaut šo darbību visām lietotnēm, kurās tiek pieprasīta skenēšana?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Atrašanās vietas datu precizitātes uzlabošanas un citos nolūkos nezināma lietotne vēlas ieslēgt tīkla meklēšanu, pat ja Wi-Fi ir izslēgts.\n\nAtļaut šo darbību visām lietotnēm, kuras vēlas meklēt tīklu?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Atļaut"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Noraidīt"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Šim tīklam nav interneta piekļuves. Vai turpināt savienojumu?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Ierobežotas savienojamības dēļ dažas lietotnes un pakalpojumi var nedarboties. Vai tomēr lietot?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Vairs nejautāt par šo tīklu"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi‑Fi nav savienots ar internetu."</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Varat pārslēgties uz mobilo tīklu ikreiz, kad ir slikts Wi-Fi savienojums. Var tikt piemērota maksa par datu lietojumu."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Pārslēgties uz mobilo tīklu"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Turpināt izmantot Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Vairs nerādīt"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Izveidot savienojumu"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi ir ieslēgts"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Izveidots savienojums ar tīklu “<xliff:g id="NETWORK_NAME">%1$s</xliff:g>”"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Notiek savienojuma izveide ar tīklu <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Veido savienojumu…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Neizdevās izveidot savienojumu ar tīklu."</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Neesat tīkla sasniedzamības zonā"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Neiegaumēt"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Mainīt"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Neizdevās aizmirst tīklu."</string>
    <string name="wifi_save" msgid="2312643132472226807">"Saglabāt"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Neizdevās saglabāt tīklu."</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Atcelt"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Vai neiegaumēt tīklu?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{Viens tīkls}zero{# tīklu}one{# tīkls}other{# tīkli}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{Viens abonements}zero{# abonementu}one{# abonements}other{# abonementi}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{Viens tīkls un abonements}zero{# tīklu un abonementu}one{# tīkls un abonements}other{# tīkli un abonementi}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Ierīces MAC adrese"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Nejauši atlasīta MAC adrese"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Nejauši atlasīta MAC adrese (pēdējā izmantotā)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Dati par tīklu"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Apakštīkla maska"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Veids"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6 adreses"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Saglabātie tīkli"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Abonementi"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Citi tīkli"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Ierakstiet derīgu IP adresi."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Ierakstiet derīgu vārtejas adresi."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Ierakstiet derīgu sistēmas DNS adresi."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Ierakstiet tīkla prefiksa garumu diapazonā 0–32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (ja vien to neignorē privātā DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (ja vien to neignorē privātā DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Vārteja"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Tīkla prefiksa garums"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Meklēt ierīces"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Notiek meklēšana..."</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Pārdēvēt ierīci"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Vienādranga ierīces"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Iegaumētās grupas"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Nevarēja izveidot savienojumu."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Neizdevās pārdēvēt ierīci."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Vai pārtraukt savienojumu?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Atvienojot tiks pārtraukts savienojums ar ierīci <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Atvienojot tiks pārtraukts savienojums ar ierīci <xliff:g id="PEER_NAME">%1$s</xliff:g> un vēl <xliff:g id="PEER_COUNT">%2$s</xliff:g> citām ierīcēm."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Vai atcelt uzaicinājumu?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Vai vēlaties atcelt uzaicinājumu izveidot savienojumu ar ierīci <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Vai aizmirst šo grupu?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wi-Fi tīklājs"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Internets vai saturs netiek koplietots ar citām ierīcēm"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Nav iestatīta parole"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Tīklāja nosaukums"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Tīklāja parole"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Piekļuves punkta josla"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Automātiski izslēgt tīklāju"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Kad nav pievienota neviena ierīce"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Paplašināt saderību"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Palīdz citām ierīcēm noteikt šo tīklāju. Šī funkcija samazina tīklāja savienojuma ātrumu."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Palīdz citām ierīcēm noteikt šo tīklāju. Šī funkcija palielina akumulatora lietojumu."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Ātrums un saderība"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz. Saderīgs ar vairumu ierīču."</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz. Saderīgs ar daudzām ierīcēm."</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz. Saderīgs tikai ar dažām ierīcēm."</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 un 5 GHz. Saderīgs ar vairumu ierīču."</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Izvēlieties tīklāja frekvenci. Frekvence ietekmē savienojuma ātrumu un to, kāda veida ierīces var uztvert jūsu tīklāju."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Vēlamā frekvence"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Mazāks ātrums. Saderīgs ar vairumu ierīču."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Liels ātrums. Saderīgs ar daudzām ierīcēm."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 un 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Liels ātrums. Šis divjoslu tīklājs ir saderīgs ar vairumu ierīču."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Vislielākais ātrums. Saderīgs tikai ar dažām ierīcēm."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Nav pieejams jūsu valstī vai reģionā"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Ja vēlamā frekvence nav pieejama, tīklājā varat izmantot citu frekvenci. Ja mainīsiet frekvenci, var tikt mainīti tīklāja drošības iestatījumi."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Nav pieejama, izmantojot šādu frekvenci: 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Ja mainīsiet tīklāja frekvenci, var tikt mainīti drošības iestatījumi."</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Notiek tīklāja ieslēgšana…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Notiek tīklāja izslēgšana…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Piesaiste nav pieejama"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Lai iegūtu detalizētu informāciju, sazinieties ar mobilo sakaru operatoru."</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> ir aktīvs"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Vai saglabāt šo tīklu?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Notiek saglabāšana…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Saglabāts"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Nevar saglabāt tīklu. Mēģiniet vēlreiz."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Vai saglabāt tīklus?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Notiek <xliff:g id="NUMBER">%d</xliff:g> tīkla(-u) saglabāšana…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Saglabātie tīkli"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Wi-Fi zvani"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Zvanīšana, izmantojot Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Ieslēdziet Wi‑Fi zvanus, lai paplašinātu pārklājumu"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Zvanu preference"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Zvanu preference"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Viesabonēšanas preference"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Viesabonēšanas preference"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mobilie dati"</item>
    <item msgid="3027927219952052398">"Tikai 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">"Mobilie dati"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Ja Wi-Fi savienojums nav pieejams, izmantot mobilo tīklu"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Ja mobilais tīkls nav pieejams, izmantot Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Zvans Wi-Fi tīklā. Ja Wi-Fi savienojums tiks zaudēts, zvans beigsies."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Kad ir ieslēgti Wi-Fi zvani, tālrunis var novirzīt zvanus, izmantojot Wi-Fi tīklus vai mobilo sakaru operatora tīklu (atkarībā no jūsu iestatījumiem un tā, kurš signāls ir stiprāks). Pirms šīs funkcijas ieslēgšanas noskaidrojiet pie mobilo sakaru operatora par tarifiem un citu informāciju.<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">"Ārkārtas adrese"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Tiks izmantota kā jūsu atrašanās vieta, ja zvanīsiet uz ārkārtas numuru, lietojot Wi‑Fi."</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Uzziniet vairāk"</annotation>" par privātām DNS funkcijām"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Ieslēgts"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivizējiet Wi-Fi zvanus"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Ieslēdziet Wi-Fi zvanus"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Pārtraukts savienojums ar <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Skaņa un vibrācija"</string>
    <string name="account_settings" msgid="255404935489127404">"Konti"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Darba profila konti — <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Personīgā profila konti"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Klona profila konti"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Darba konts — <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Personīgais konts — <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Meklēt"</string>
    <string name="display_settings" msgid="7197750639709493852">"Attēls"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Automātiska ekrāna pagriešana"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Izslēgt"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Ieslēgt"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Ieslēgt (ar sejas noteikšanu)"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Sejas noteikšana"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Uzzināt vairāk par automātisko pagriešanu"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Ekrāna izšķirtspēja"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Augsta izšķirtspēja"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Pilna izšķirtspēja"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Izmantojot pilnu izšķirtspēju, tiek patērēts vairāk akumulatora enerģijas. Ja mainīsiet izšķirtspēju, noteiktas lietotnes var tikt restartētas."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Atlasīta"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Krāsas"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Dabiska"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Paspilgtināta"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Piesātināta"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptīva krāsa"</string>
    <string name="brightness" msgid="6216871641021779698">"Spilgtuma līmenis"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Adaptīvs spilgtums"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Ekrāna spilgtums automātiski tiks pielāgots apkārtējai videi un veiktajām darbībām. Lai adaptīvajam spilgtumam iestatītu savas preferences, pārvietojiet slīdni."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Ieslēgt"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Izslēgts"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Displeja baltās krāsas balanss"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Noteikta satura atsvaidzināšanas biežums tiek automātiski palielināts no 60 līdz <xliff:g id="ID_1">%1$s</xliff:g> Hz. Tas palielina akumulatora lietojumu."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Piespiedu maksimālais atsvaidzināšanas biežums"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Augstākais atsvaidzināšanas biežums uzlabotai reakcijai uz pieskārienu un labākai animācijas kvalitātei. Tas palielina akumulatora lietojumu."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Atpazīšana ekrānā"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Nepieciešama piekļuve kamerai"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Lai izmantotu atpazīšanu ekrānā, nepieciešama piekļuve kamerai. Pieskarieties, lai pārvaldītu atļaujas ierīces personalizēšanas pakalpojumiem."</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Pārvaldīt atļaujas"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Ekrāns netiek izslēgts, ja uz to skatāties."</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Atpazīšanai ekrānā tiek izmantota priekšējā kamera, lai noteiktu, vai kāds skatās uz ekrānu. Šī funkcija darbojas ierīcē, un attēli netiek ne saglabāti, ne nosūtīti uzņēmumam Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Atpazīšanas ekrānā ieslēgšana"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Ekrāns netiek izslēgts, ja uz to skatāties."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera ir bloķēta"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Lai varētu izmanto sejas noteikšanu, kamerai jābūt atbloķētai"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Lai varētu izmantot atpazīšanu ekrānā, kamerai jābūt atbloķētai"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Lai varētu izmantot sejas noteikšanu, nepieciešama piekļuve kamerai. Pieskarieties, lai pārvaldītu ierīces personalizēšanas pakalpojumu atļaujas."</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Pārvaldīt atļaujas"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nakts režīms"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Nakts režīmā ekrāns iekrāsojas dzintara krāsā, lai jums būtu vieglāk skatīties ekrānā un lasīt blāvā apgaismojumā, kā arī vieglāk iemigt."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Ieplānot"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Nav"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Tiek ieslēgts pielāgotā laikā"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Ieslēgts no rieta līdz lēktam"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Sākuma laiks"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Beigu laiks"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensitāte"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nekad netiks automātiski ieslēgts"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Tiks automātiski ieslēgts plkst. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Tiks automātiski ieslēgts saulrietā"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nekad netiks automātiski izslēgts"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Tiks automātiski izslēgts plkst. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Tiks automātiski izslēgts saullēktā"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nakts režīms nav ieslēgts"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Lai noteiktu saulrieta un saullēkta laiku, nepieciešama ierīces atrašanās vietas informācija."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Atrašanās vietas iestatījumi"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Ieslēgt tūlīt"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Izslēgt tūlīt"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Ieslēgt līdz saullēktam"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Izslēgt līdz saulrietam"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Tumšais režīms"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Grafiks"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nav"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Ieslēgts no rieta līdz lēktam"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Tiek ieslēgts pielāgotā laikā"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Tiek ieslēgts pirms gulētiešanas"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Statuss"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nekad netiks automātiski ieslēgts"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Tiks automātiski ieslēgts saulrietā"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Tiks automātiski ieslēgts plkst. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Tiks automātiski ieslēgts pirms gulētiešanas."</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nekad netiks automātiski izslēgts"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Tiks automātiski izslēgts saullēktā"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Tiks automātiski izslēgts plkst. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Tiks automātiski izslēgts pēc pamošanās."</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tumšajā motīvā tiek izmantots melns fons noteiktos ekrānos, lai paildzinātu akumulatora darbību. Turklāt jūs varat iestatīt, kad ieslēgt un izslēgt tumšo motīvu."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tumšā motīva pamatā pašlaik ir jūsu gulēšanas režīma grafiks."</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Gulēšanas režīma iestatījumi"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Ekrāna noildze"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Pēc <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> neaktivitātes"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nav iestatīts"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Fona tapete"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Fona tapete un stils"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Sākuma ekrāns, bloķēšanas ekrāns"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Mainīt fona tapeti"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Ekrāna personalizēšana"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Fona tapetes izvēle no"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Tālruņa pielāgošana"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Izmēģiniet dažādus stilus, fona tapetes utt."</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Ekrānsaudzētājs"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"ekrānsaudzētājs"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nav pieejams, jo ir ieslēgts naktsmiera režīms"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Izmantot ekrānsaudzētāju"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Uzlādes vai dokošanas laikā"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Kad ierīce dokota un notiek uzlāde"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Uzlādes laikā"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Kamēr tiek dokots"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nekad"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Ieslēgts/<xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Izslēgts"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Kad sākt"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Pacelt, lai ieslēgtu"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Gaidstāves ekrāns"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Kad rādīt"</string>
    <string name="doze_title" msgid="1523090408230862316">"Aktivizēt ekrānu paziņojumiem"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Kad ekrāns ir tumšs, tas tiek ieslēgts, saņemot jaunus paziņojumus"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Vienmēr rādīt laiku un inform."</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Palielināts akumulatora lietojums"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Teksts treknrakstā"</string>
    <string name="title_font_size" msgid="570613010306330622">"Fonta lielums"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Palieliniet vai samaziniet tekstu"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"SIM kartes bloķēšanas iestatījumi"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"SIM kartes bloķēšana"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Bloķēt SIM karti"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Mainīt SIM kartes PIN kodu"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"SIM kartes PIN kods"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Bloķēt SIM karti"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Atbloķēt SIM karti"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Vecais SIM kartes PIN kods"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Jauns SIM PIN"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Atkārtoti ievadiet jauno PIN."</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"SIM kartes PIN kods"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Ievadiet PIN (no 4 līdz 8 cipariem)."</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN kodi ir atšķirīgi"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"SIM PIN ir veiksmīgi nomainīts"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Nevar atspējot PIN."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Nevar iespējot PIN."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Labi"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Atcelt"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Vai lietot <xliff:g id="CARRIER">%1$s</xliff:g> mobilajiem datiem?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Jūs izmantojat mobilajiem datiem <xliff:g id="CARRIER2_0">%2$s</xliff:g>. Pārslēdzoties uz <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> SIM vairs netiks izmantota mobilajiem datiem."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Izmantot operatoru <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Atjaunināt vēlamo SIM karti?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> ir vienīgā SIM karte jūsu ierīcē. Vai vēlaties izmantot šo SIM karti mobilajiem datiem, zvaniem un īsziņām?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Uzlabot mob. datu savienojumu?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Ļaujiet ierīcē automātiski pārslēgt mobilo sakaru operatoru uz <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> mobilajiem datiem, ja tas nodrošina labāku savienojumu."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Iespējams, jūsu organizācija varēs redzēt jūsu zvanus, ziņojumus un tīkla datplūsmu."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Nepareizs SIM kartes PIN kods. Lai atbloķētu ierīci, sazinieties ar mobilo sakaru operatoru."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Nepareizs SIM kartes PIN. Varat mēģināt vēl # reizi. Kļūdas gadījumā būs jāsazinās ar mobilo sakaru operatoru, lai tas atbloķētu jūsu ierīci.}zero{Nepareizs SIM kartes PIN. Varat mēģināt vēl # reizes.}one{Nepareizs SIM kartes PIN. Varat mēģināt vēl # reizi.}other{Nepareizs SIM kartes PIN. Varat mēģināt vēl # reizes.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Nepareizs SIM kartes PIN. Varat mēģināt vēl 1 reizi. Kļūdas gadījumā būs jāsazinās ar mobilo sakaru operatoru, lai tas atbloķētu jūsu ierīci."</string>
    <string name="pin_failed" msgid="3726505565797352255">"SIM kartes PIN koda ievadīšana neizdevās."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Sistēmas atjauninājumi"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Android versija"</string>
    <string name="security_patch" msgid="4071756145347865382">"Android drošības atjauninājums"</string>
    <string name="model_info" msgid="8997566254717810904">"Modelis"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Aparatūras versija"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Ražošanas gads"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Iekārtas ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Pamatjoslas versija"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Kernel versija"</string>
    <string name="build_number" msgid="9009733242117579826">"Būvējuma numurs"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play sistēmas atjauninājums"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nav pieejams"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Krātuve"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Krātuve un kešatmiņa"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Krātuves iestatījumi"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (SIM slots <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (<xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>. SIM kartes slots)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (<xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>. SIM kartes slots) (galvenais)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Skatīšanai izvēlieties saglabātu tīklu."</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"PRL versija"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (<xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>. SIM kartes slots)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (<xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>. SIM kartes slots) (galvenais)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Ieslēgta"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Izslēgta"</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">"Mobilo datu tīkla veids"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Ar balsi pārvaldāmas mobilās ierīces tīkla veids"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Mobilo sakaru operatora informācija"</string>
    <string name="status_data_state" msgid="525196229491743487">"Mobilo sakaru tīkla statuss"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Pakalpojuma statuss"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signāla stiprums"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Viesabonēšana"</string>
    <string name="status_operator" msgid="4335640583552058491">"Tīkls"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Wi-Fi MAC adrese"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Ierīces Wi‑Fi MAC adrese"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetooth adrese"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Sērijas numurs"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Darbības laiks"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Notiek aprēķināšana..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Pārdēvēt"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Pievienot"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Noņemt"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatēt SD karti pārnēsājamai krātuvei"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatēt karti"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatēt kā pārnesamu"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatēt"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrēt datus"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Noņemt"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Iestatīt"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Atbrīvot vietu"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Pārvaldīt krātuvi"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Atbrīvot vietu"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Pārejiet uz lietotni Faili, lai pārvaldītu krātuvi un atbrīvotu vietu tajā."</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Citi lietotāji"</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">"<xliff:g id="NAME">%1$s</xliff:g> ir pievienota"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Nevarēja pievienot: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> tika droši noņemta"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Nevarēja droši noņemt: <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Pārdēvējiet atmiņu"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Šī ierīce (<xliff:g id="NAME_0">^1</xliff:g>) ir bojāta.\n\nLai varētu lietot šo ierīci (<xliff:g id="NAME_1">^1</xliff:g>), tā vispirms ir jāiestata."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Varat formatēt šo SD karti, lai glabātu fotoattēlus, videoklipus, mūziku un citu saturu citās ierīcēs. \n\n"<b>"Visi dati šajā SD kartē tiks dzēsti."</b>" \n\n"<b>"Pirms formatēšanas"</b>" \n\n"<b>"Dublējiet fotoattēlus un citu multividi"</b>" \nPārvietojiet multivides failus uz citu krātuvi šajā ierīcē vai pārsūtiet tos uz datoru, izmantojot USB vadu. \n\n"<b>"Dublējiet lietotnes"</b>" \nVisas šeit (<xliff:g id="NAME">^1</xliff:g>) uzglabātās lietotnes tiks atinstalētas un to dati tiks dzēsti. Lai paturētu šīs lietotnes, pārvietojiet tās uz citu krātuvi šajā ierīcē."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Izņemot ierīci <xliff:g id="NAME_0">^1</xliff:g>, tajā glabātās lietotnes vairs nedarbosies un tajā glabātie faili nebūs pieejami, kamēr tā netiks ievietota atpakaļ."</b>\n\n"<xliff:g id="NAME_1">^1</xliff:g> ir formatēta tā, lai darbotos tikai šajā ierīcē, un tā nedarbosies citās ierīcēs."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Lai izmantotu lietotnes, fotoattēlus vai datus, kas saglabāti ierīcē <xliff:g id="NAME">^1</xliff:g>, ievietojiet to atkārtoti.\n\nVarat arī noņemt šo krātuvi, ja ierīce nav pieejama.\n\nŠādā gadījumā visi ierīcē esošie dati tiks neatgriezeniski zaudēti.\n\nVēlāk varēsiet atkārtoti instalēt lietotnes, taču to dati, kas saglabāti šajā ierīcē, vairs nebūs pieejami."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"<xliff:g id="NAME">^1</xliff:g>: vai noņemt?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Visas lietotnes, fotoattēli un dati, kas saglabāti šajā ierīcē (<xliff:g id="NAME">^1</xliff:g>), vairs nebūs pieejami."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Sistēmā ir ietverti faili, kas tiek izmantoti Android versijai <xliff:g id="VERSION">%s</xliff:g>."</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Viesa režīma lietotāji nevar formatēt SD kartes"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Notiek <xliff:g id="NAME">^1</xliff:g> formatēšana…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Formatēšanas laikā neizņemiet: <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g>: formatēts"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Pārvietojiet lietotni <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Lietotnes <xliff:g id="APP">^1</xliff:g> un tās datu pārvietošana uz <xliff:g id="NAME_0">^2</xliff:g> aizņems tikai neilgu brīdi. Kamēr pārvietošana nebūs pabeigta, nevarēsiet izmantot lietotni. \n\nNeizņemiet <xliff:g id="NAME_1">^2</xliff:g>, kamēr tiek pārvietoti faili."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Lai pārvietotu datus, jums ir jāatbloķē lietotājs: <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Notiek lietotnes <xliff:g id="APP">^1</xliff:g> pārvietošana…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Neizņemiet <xliff:g id="NAME">^1</xliff:g>, kamēr tiek pārvietoti faili. \n\nKamēr failu pārvietošana nebūs pabeigta, lietotne <xliff:g id="APP">^2</xliff:g> šajā ierīcē nebūs pieejama."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Kā tiks izmantota ierīce <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Vai"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formatēt SD karti pārnēsājamai krātuvei"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Uzglabājiet fotoattēlus, videoklipus, mūziku un citu saturu, lai varētu tam piekļūt no citām ierīcēm. &lt;a href=https://support.google.com/android/answer/12153449&gt;Uzziniet vairāk par SD kartes iestatīšanu&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatēt"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Iestatīt vēlāk"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Vai formatēt šo: <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Lai saglabātu lietotnes, failus un multivides saturu, SD karte <xliff:g id="NAME_0">^1</xliff:g> ir jāformatē. \n\nFormatējot tiks dzēsts viss saturs, kas saglabāts šeit: <xliff:g id="NAME_1">^2</xliff:g>. Lai nezaudētu saturu, dublējiet to citā datu nesējā <xliff:g id="NAME_2">^3</xliff:g> vai citā ierīcē."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Lai saglabātu fotoattēlus, videoklipus, mūziku un citu saturu, <xliff:g id="NAME_0">^1</xliff:g> ir jāformatē. \n\nFormatējot tiks dzēsts viss saturs, kas saglabāts šeit: <xliff:g id="NAME_1">^2</xliff:g>. Lai nezaudētu saturu, dublējiet to citā datu nesējā <xliff:g id="NAME_2">^3</xliff:g> vai citā ierīcē."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatēt <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Vai pārvietot saturu uz ierīci <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Pārvietošanas laikā"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Neizņemiet ierīci <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Dažas lietotnes nedarbosies"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Pārvietot saturu"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Pārvietot saturu vēlāk"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Notiek satura pārvietošana…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> lēni darbojas"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Varat turpināt lietot ierīci <xliff:g id="NAME_0">^1</xliff:g>, tomēr tā var darboties lēni. \n\nIerīcē <xliff:g id="NAME_1">^2</xliff:g> saglabātās lietotnes var darboties neatbilstoši un satura pārsūtīšanai var būt nepieciešams ilgs laiks. \n\nMēģiniet izmantot ierīci <xliff:g id="NAME_2">^3</xliff:g> ar ātrāku darbību, vai arī šo ierīci <xliff:g id="NAME_3">^4</xliff:g> izmantojiet kā pārnesamu krātuvi."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Sākt vēlreiz"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Tālāk"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Varat sākt izmantot: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Varat sākt izmantot: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Varat sākt izmantot: <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Akumulatora statuss"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Akumulatora uzlādes līmenis"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Kopīgie"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Kopīgie iestatījumi"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Rediģēt piekļuves punktu"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nav iestatīts"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Nav iestatīts"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nosaukums"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Starpniekserveris"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Ports"</string>
    <string name="apn_user" msgid="5831763936428279228">"Lietotājvārds"</string>
    <string name="apn_password" msgid="7435086635953953029">"Parole"</string>
    <string name="apn_server" msgid="6997704279138388384">"Serveris"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS starpniekserveris"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS ports"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Autentifikācijas veids"</string>
    <string name="apn_type" msgid="1835573305077788773">"APN veids"</string>
    <string name="apn_protocol" msgid="181529867160380010">"APN protokols"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"APN viesabonēšanas protokols"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Iespējot/atspējot APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN ir iespējots"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN ir atspējots"</string>
    <string name="bearer" msgid="3231443241639159358">"Nesējs"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO veids"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO vērtība"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Dzēst APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"Jauns APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Saglabāt"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Atcelt"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Lauks Nosaukums nedrīkst būt tukšs."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN nedrīkst būt tukšs."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC laukā jābūt 3 cipariem."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC laukā jābūt diviem vai trim cipariem."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Mobilo sakaru operators neatļauj pievienot šāda veida APN: %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Notiek APN noklusējuma iestatījumu atjaunošana."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Atiestatīt noklusējuma vērtības"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Noklusējuma APN iestatījumu atiestatīšana ir pabeigta."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Atiestatīšanas opcijas"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Atiestatīt mobilā tīkla iestatījumus"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Tādējādi tiks atiestatīti visi mobilā tīkla iestatījumi."</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Vai atiestatīt mobilo tīklu?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Bluetooth un Wi‑Fi iestatījumu atiestatīšana"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Tādējādi tiks atiestatīti visi Wi‑Fi un Bluetooth iestatījumi. Šo darbību nevar atsaukt."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Atiestatīt"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth un Wi‑Fi iestatījumi ir atiestatīti"</string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Dzēst"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Dzēst eSIM kartes"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Ar šo darbību netiks anulēti mobilo sakaru pakalpojumu plāni. Lai lejupielādētu nomaiņas SIM kartes, sazinieties ar mobilo sakaru operatoru."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Atiestatīt iestatījumus"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Vai vēlaties atiestatīt visus tīkla iestatījumus? Šo darbību nevar atsaukt."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Vai atiestatīt visus tīkla iestatījumus un dzēst eSIM kartes? Šo darbību nevar atsaukt."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Atiestatīt iestatījumus"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Vai atiestatīt?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Šim lietotājam nav pieejama tīkla atiestatīšana."</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Tīklu iestatījumi ir atiestatīti."</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Nevar izdzēst SIM kartes"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"Nevar izdzēst eSIM kartes, jo radās kļūda.\n\nRestartējiet ierīci un mēģiniet vēlreiz."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Dzēst visus datus (atiestatīt rūpnīcas datus)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Atiestatīt rūpnīcas datus"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"mūzika"</li>\n<li>"fotoattēli"</li>\n<li>"citi lietotāja dati"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM kartes"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Veicot šo darbību, netiks atcelts jūsu mobilo pakalpojumu plāns."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Tiks izdzēsta visa jūsu personas informācija un lejupielādētās lietotnes. Šo darbību nevar atsaukt."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Tiks izdzēsta visa jūsu personas informācija, tostarp lejupielādētās lietotnes un SIM kartes. Šo darbību nevar atsaukt."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Vai dzēst visus datus?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Šim lietotājam nav pieejama rūpnīcas datu atiestatīšana."</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Notiek dzēšana"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Lūdzu, uzgaidiet…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Zvanu iestatījumi"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Balss pasta, zvanu pāradresācijas, zvana gaidīšanas, zvanītāja ID iestatīšana"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB saistīšana"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Pārnēsājams tīklājs"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Bluetooth piesaiste"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Saistīšana"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Tīklājs un piesaiste"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Tīklājs ir ieslēgts, piesaiste ir aktīva"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Tīklājs ir ieslēgts"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Piesaiste"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Kamēr ir ieslēgts datu lietojuma samazinātājs, nevar veikt piesaisti vai izmantot pārnēsājamus tīklājus"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Tikai tīklājs"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Tikai USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Tikai Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Tikai Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Tīklājs, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Tīklājs, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Tīklājs, 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">"Tīklājs, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Tīklājs, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Tīklājs, 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">"Tīklājs, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internets netiek koplietots ar citām ierīcēm"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Izslēgts"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Piesaiste"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Neizmantot Wi‑Fi tīklāju"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Kopīgot interneta savienojumu, tikai izmantojot USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Kopīgot interneta savienojumu, tikai izmantojot Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Kopīgot interneta savienojumu, tikai izmantojot Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Kopīgot interneta savienojumu, tikai izmantojot USB un Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Kopīgot interneta savienojumu, tikai izmantojot USB un Ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Kopīgot interneta savienojumu, tikai izmantojot Bluetooth un Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Kopīgot interneta savienojumu, tikai izmantojot USB, Bluetooth un Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"USB piesaiste"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Bluetooth piesaiste"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ethernet piesaiste"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Izmantojiet tīklāju un piesaisti, lai varētu lietot internetu citās ierīcēs, izveidojot mobilo datu savienojumu. Lietotnes var arī izveidot tīklāju satura kopīgošanai ar tuvumā esošajām ierīcēm."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Izmantojot tīklāju un piesaisti, jūsu ierīces Wi-Fi vai mobilo datu savienojums var nodrošināt interneta savienojumu citām ierīcēm. Lietotnes var arī izveidot tīklāju satura kopīgošanai ar tuvumā esošajām ierīcēm."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Palīdzība"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilais tīkls"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobilo sakaru pakalpojumu plāns"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Īsziņu lietotne"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Vai mainīt īsziņu lietotni?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Vai īsziņām izmantot lietotni <xliff:g id="NEW_APP">%1$s</xliff:g>, nevis <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Vai izmantot lietotni <xliff:g id="NEW_APP">%s</xliff:g> kā īsziņu lietotni?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Vai mainīt Wi-Fi palīgu?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Vai tīkla savienojumu pārvaldībai izmantot lietotni <xliff:g id="NEW_APP">%1$s</xliff:g>, nevis <xliff:g id="CURRENT_APP">%2$s</xliff:g>?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Vai tīkla savienojumu pārvaldībai izmantot lietotni <xliff:g id="NEW_APP">%s</xliff:g>?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Nezināms SIM operators"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"Operatoram <xliff:g id="OPERATOR">%1$s</xliff:g> nav zināmas nodrošināšanas vietnes."</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Lūdzu, ievietojiet SIM karti un restartējiet."</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Lūdzu, izveidojiet savienojumu ar internetu."</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Neseni vietu pieprasījumi"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Darba profila atrašanās vieta"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Lietotņu atraš. vietu atļaujas"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Atrašanās vieta ir izslēgta"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# lietotnei no {total} ir piekļuve atrašanās vietai}zero{# lietotnēm no {total} ir piekļuve atrašanās vietai}one{# lietotnei no {total} ir piekļuve atrašanās vietai}other{# lietotnēm no {total} ir piekļuve atrašanās vietai}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Nesena piekļuve"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Skatīt visu"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Skatīt detalizētu informāciju"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Pēdējā laikā nevienā lietotnē nav pieprasīta atrašanās vietas informācija."</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Neviena lietotne pēdējā laikā nav piekļuvusi atrašanās vietas informācijai"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Augsts akumulatora patēriņš"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Zems akumulatora patēriņš"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Wi‑Fi meklēšana"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Ļauj lietotnēm un pakalpojumiem meklēt Wi-Fi tīklus vienmēr, pat ja Wi-Fi ir izslēgts. Šo iestatījumu var izmantot, piemēram, lai uzlabotu atrašanās vietas funkcijas un pakalpojumus."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetooth meklēšana"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Ļauj lietotnēm un pakalpojumiem meklēt tuvumā esošas ierīces vienmēr, pat ja Bluetooth ir izslēgts. Šo iestatījumu var izmantot, piemēram, lai uzlabotu atrašanās vietas funkcijas un pakalpojumus."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Atrašanās vietu pakalpojumi"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Atrašanās vietu pakalpojumi"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Izmantot atrašanās vietu"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Nevar automātiski iestatīt laika joslu"</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">"Atrašanās vietas atļauja/pakalpojumi ir izslēgti"</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">"Nepieciešama ierīces atrašanās vieta"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Lai iestatītu laika joslu atbilstoši atrašanās vietai, ieslēdziet atrašanās vietas noteikšanu un pēc tam atjauniniet laika joslas iestatījumus"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Atrašanās vietas iestatījumi"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Novērst problēmu"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Atcelt"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automātiskā laika josla ir izslēgta."</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Atrašanās vietas laika joslas noteikšana ir atspējota."</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Atrašanās vietas laika joslas noteikšana netiek atbalstīta."</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Atrašanās vietas laika joslas noteikšanas izmaiņas nav atļautas."</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Atrašanās vietu var izmantot, lai iestatītu laika joslu"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Skatīt juridisko informāciju, statusu, programmatūras versiju"</string>
    <string name="legal_information" msgid="7509900979811934843">"Juridiskā informācija"</string>
    <string name="manual" msgid="3651593989906084868">"Rokasgrāmata"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Norādījumu uzlīmes"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Drošības un regulējošā informācija"</string>
    <string name="copyright_title" msgid="83245306827757857">"Autortiesības"</string>
    <string name="license_title" msgid="8745742085916617540">"Licence"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Google Play sistēmas atjauninājumu licences"</string>
    <string name="terms_title" msgid="2071742973672326073">"Pakalpojumu sniegšanas noteikumi"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Sistēmas WebView licence"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Fona tapetes autors"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Satelītuzņēmumu nodrošinātāji:\n©2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Rokasgrāmata"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Radās ar rokasgrāmatas ielādi saistīta problēma."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Trešo pušu licences"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Radās ar licenču ielādi saistīta problēma."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Notiek ielāde…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Notiek ielāde…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Paroles iestatīšana"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Darba paroles iestatīšana"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"PIN iestatīšana"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Darba PIN iestatīšana"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Iestatiet kombināciju"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Papildu drošībai iestatiet kombināciju šīs ierīces atbloķēšanai"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Darba kombinācijas iestatīšana"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Parole pirksta nosp. lietošanai"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Kombinācijas iestatīšana"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Drošības nolūkos iestatiet PIN kodu."</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Iestatiet PIN kodu"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Atkārtoti ievadiet paroli"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Atkārtoti ievadiet darba paroli"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Ievadiet darba profila paroli"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Apstipriniet kombināciju"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Ievadiet darba profila kombināciju"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Atkārtoti ievadiet PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Atkārtoti ievadiet darba PIN"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Ievadiet darba profila PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Paroles nav vienādas"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN kodi ir atšķirīgi"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Vēlreiz uzzīmējiet kombināciju"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Atbloķēšanas atlase"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Parole ir iestatīta"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN kods ir iestatīts"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Kombinācija ir iestatīta"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Autorizācijai pēc sejas iestatiet paroli"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Autorizācijai pēc sejas iestatiet komb."</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Autorizācijai pēc sejas iestatiet PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Iestatiet papildu paroli"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Iestatiet papildu kombināciju"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Iestatiet papildu PIN"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Vai aizmirsāt paroli?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Vai aizmirsāt kombināciju?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Vai aizmirsāt PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Lai turpinātu, izmantojiet ierīces kombināciju."</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Lai turpinātu, ievadiet ierīces PIN kodu."</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Lai turpinātu, ievadiet savas ierīces paroli."</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Lai turpinātu, izmantojiet darba profila kombināciju."</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Lai turpinātu, ievadiet darba profila PIN kodu."</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Lai turpinātu, ievadiet darba profila paroli."</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Papildu drošībai izmantojiet ierīces kombināciju."</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Papildu drošībai ievadiet ierīces PIN."</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Papildu drošībai ievadiet ierīces paroli."</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Papildu drošībai izmantojiet darba profila kombināciju."</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Papildu drošībai ievadiet darba profila PIN."</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Papildu drošībai ievadiet darba profila paroli."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verificējiet kombināciju"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verificējiet PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verificējiet paroli"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Verifikācija"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Lai pārsūtītu Google kontus, iestatījumus un citu informāciju, ievadiet savas otras ierīces kombināciju. Kombinācija tiks šifrēta."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Lai pārsūtītu Google kontus, iestatījumus un citu informāciju, ievadiet savas otras ierīces PIN kodu. PIN kods tiks šifrēts."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Lai pārsūtītu Google kontus, iestatījumus un citu informāciju, ievadiet savas otras ierīces paroli. Parole tiks šifrēta."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Atbloķēt šo ierīci arī ar kombināciju"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Atbloķēt šo ierīci arī ar PIN"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Atbloķēt šo ierīci arī ar paroli"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Nepareizs PIN kods"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Nepareiza parole"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Nepareiza kombinācija"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Ārkārtas situācija"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Ierīces drošība"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Atbloķēšanas kombinācijas maiņa"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Mainīt atbloķēšanas PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Zīmēt atbloķēšanas kombināciju"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Lai saņemtu palīdzību, nospiediet Izvēlne."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Atlaidiet pirkstu, kad esat pabeidzis."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Pievienojiet vismaz <xliff:g id="NUMBER">%d</xliff:g> punktus. Mēģiniet vēlreiz."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Kombinācija ir ierakstīta"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Vēlreiz zīmējiet kombināciju."</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Jaunā atbloķēšanas kombinācija"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Apstiprināt"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Uzvilkt atkārtoti"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Notīrīt"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Turpināt"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Atbloķēšanas kombinācija"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Jāzīmē kombinācija"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Lai atbloķētu ekrānu, jāzīmē kombinācija."</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Padarīt kombināciju redzamu"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Uzlabota PIN koda konfidencialitāte"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Atspējot animācijas PIN koda ievades laikā"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Padarīt profila kombināciju redzamu"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrēt pieskaroties"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Barošanas poga bloķē uzreiz"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Ja vien bloķēšanu neliedz <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Iestatīt atbloķēšanas kombināciju"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Atbloķēšanas kombinācijas maiņa"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Kā zīmēt atbloķēšanas kombināciju"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Pārāk daudz neveiksmīgu mēģinājumu. Mēģiniet vēlreiz pēc <xliff:g id="NUMBER">%d</xliff:g> sekundēm."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Lietojumprogramma jūsu tālrunī nav instalēta."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Darba profila drošība"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Darba profila ekrāna bloķēšanas režīms"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Izmantot vienu bloķēšanas režīmu"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Darba profilam un ierīces ekrānam izmantot vienu bloķēšanas režīmu"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Vai izmantot vienu bloķēšanas režīmu?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Ierīcē tiks izmantota darba profila ekrāna bloķēšana. Darba politikas attieksies uz abiem bloķēšanas režīmiem."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Jūsu darba profila bloķēšanas režīms neatbilst jūsu organizācijas drošības prasībām. Ierīces ekrānam var izmantot to pašu bloķēšanas režīmu, ko darba profilam, taču būs spēkā visas darba profila bloķēšanas politikas."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Izmantot vienu bloķēšanas režīmu"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Izmantot vienu bloķēšanas režīmu"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Tāds pats kā ierīces bloķēšanas režīms"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Pārvaldīt lietotnes"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informācija par lietotni"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Lietotnes iestatījumi"</string>
    <string name="install_applications" msgid="3921609656584369901">"Nezināmi avoti"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Atļaut visus lietotņu avotus"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Nesen atvērtās lietotnes"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Skatīt visas lietotnes}zero{Skatīt visas # lietotnes}one{Skatīt visas lietotnes (kopā #)}other{Skatīt visas # lietotnes}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Sazinieties ar savu IT administratoru"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Administrators var palīdzēt atiestatīt PIN, kombināciju vai paroli."</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Papildu iestatījumi"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Iespējot papildu iestatījumu opcijas"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Informācija par lietotni"</string>
    <string name="storage_label" msgid="2522307545547515733">"Krātuve"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Atvēršana pēc noklusējuma"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Noklusējuma iestatījumi"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Ekrāna saderība"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Atļaujas"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Kešatmiņa"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Notīrīt kešatmiņu"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Kešatmiņa"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{Viens vienums}zero{# vienumu}one{# vienums}other{# vienumi}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Atcelt piekļuvi"</string>
    <string name="controls_label" msgid="8671492254263626383">"Vadīklas"</string>
    <string name="force_stop" msgid="2681771622136916280">"Forsēt apturēšanu"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Kopā"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Lietotnes lielums"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"USB atmiņas lietotne"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Lietotāja dati"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Atinstalēt"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Atinstalēt visiem lietotājiem"</string>
    <string name="install_text" msgid="4558333621516996473">"Instalēt"</string>
    <string name="disable_text" msgid="5146002260857428005">"Atspējot"</string>
    <string name="enable_text" msgid="8570798764647110430">"Iespējot"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Notīrīt krātuvi"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Atinstalēt atjauninājumus"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Atļaut ierobežotos iestatījumus"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Dažas no jūsu atlasītajām darbībām pēc noklusējuma tiks veiktas šajā lietotnē."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Jūs esat izvēlējies šai lietotnei ļaut veidot logrīkus un piekļūt to datiem."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nav iestatīti noklusējumi."</string>
    <string name="clear_activities" msgid="488089228657585700">"Notīrīt noklusējuma preferences"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Iespējams, ka šī lietotne nav paredzēta jūsu ierīces ekrānam. Šeit varat norādīt, kā lietotne jārāda jūsu ekrānā."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Jautāt palaišanas laikā"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Mērogot lietotni"</string>
    <string name="unknown" msgid="8192160131923461175">"Nezināms"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Kārtot pēc nosaukuma"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Kārtot pēc izmēra"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Visnesenāk"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Visbiežāk"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Rādīt aktīvos pakalp."</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Rādīt kešatmiņā iev. pr."</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Ārkārtas izsaukumu lietotne"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Atiest. lietotnes prefer."</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Vai atiest. liet. pref.?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Šādi tiks atiestatītas visas preferences, kas saistītas ar:\n\n"<li>"atspējotām lietotnēm;"</li>\n<li>"atspējotu lietotņu paziņojumiem;"</li>\n<li>"noklusējuma lietojumprogrammām konkrētu darbību veikšanai;"</li>\n<li>"lietotņu fona datu ierobežojumiem;"</li>\n<li>"visiem atļauju ierobežojumiem;"</li>\n<li>"akumulatora lietojuma iestatījumiem."</li>\n\n"Jūs nezaudēsiet lietotņu datus."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Atiestatīt lietotnes"</string>
    <string name="filter" msgid="9039576690686251462">"Filtrs"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Izvēlēties filtra opcijas"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Visas lietotnes"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Atspējotās lietotnes"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Lejupielādēts"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Darbojas"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nav instalēta šim lietotājam"</string>
    <string name="installed" msgid="2837449358488825884">"Instalēta"</string>
    <string name="no_applications" msgid="985069304755391640">"Nav lietotņu"</string>
    <string name="internal_storage" msgid="999496851424448809">"Iekšējā krātuve"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Notiek izmēra pārrēķināšana..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Vai dzēst lietotnes datus?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Šīs lietotnes dati, tostarp faili un iestatījumi, tiks neatgriezeniski dzēsti no šīs ierīces."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Labi"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Atcelt"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Dzēst"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Šī lietotne netika atrasta instalēto lietotņu sarakstā."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Neizdevās notīrīt krātuvi lietotnei."</string>
    <string name="computing_size" msgid="4915310659841174866">"Notiek aprēķināšana..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nevar aprēķināt pakotnes izmēru."</string>
    <string name="version_text" msgid="7628938665256107608">"versija <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Pārvietot"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Jau norisinās cita migrēšanas darbība."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Atmiņā nepietiek vietas."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Lietotne nepastāv."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Instalēšanas vieta nav derīga."</string>
    <string name="system_package" msgid="7559476279008519360">"Sistēmas atjauninājumus nevar instalēt ārējā datu nesējā."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Ierīces administratora lietotni nevar instalēt ārējā datu nesējā."</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Vai veikt piespiedu apturēšanu?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Piespiedu kārtā apturot lietotnes darbību, var rasties šīs lietotnes darbības traucējumi."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Atspējot lietotni"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Ja atspējosiet šo lietotni, Android un citas lietotnes, iespējams, vairs nedarbosies, kā paredzēts. Ņemiet vērā, ka šo lietotni nevar izdzēst, jo tā bija iepriekš instalēta ierīcē. Ja atspējosiet lietotni, tā tiks izslēgta un paslēpta jūsu ierīcē."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Veikals"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Lietotnes informācija"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Lietotne instalēta, izmantojot <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Papildinformācija par <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Darbojas"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nekad nav izmantots)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Krātuves lietojums"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Atsākšana"</string>
    <string name="cached" msgid="5379485147573438201">"Kešatmiņā ievietots fona process"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nekas nedarbojas."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Startēja lietotne."</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"Brīvs: <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"Aizņemts: <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">"Lietotājs: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Noņemts lietotājs"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> process un <xliff:g id="NUMSERVICES">%2$d</xliff:g> pakalpojums"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> process un <xliff:g id="NUMSERVICES">%2$d</xliff:g> pakalpojumi"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesi un <xliff:g id="NUMSERVICES">%2$d</xliff:g> pakalpojums"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesi un <xliff:g id="NUMSERVICES">%2$d</xliff:g> pakalpojumi"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Ierīces atmiņa"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Lietotnes RAM lietojums"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistēma"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Lietotnes"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Brīva"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Izmantota"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Saglabāts kešatmiņā"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aktīvā lietotne"</string>
    <string name="no_services" msgid="3898812785511572899">"Nav aktīvs"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Pakalpojumi"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesi"</string>
    <string name="service_stop" msgid="5712522600201308795">"Apturēt"</string>
    <string name="service_manage" msgid="3896322986828332075">"Iestatījumi"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Šo pakalpojumu palaida tā lietotne. Ja pakalpojums tiks apturēts, var rasties lietotnes kļūme."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Nevar droši apturēt šīs lietotnes darbību. Ja to apturēsiet, iespējams, zaudēsiet daļu pašlaik apstrādāto datu."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Šis ir iepriekš izmantotas lietotnes process, kas joprojām darbojas, lai pēc nepieciešamības to varētu atkārtoti izmantot. Parasti nav nepieciešams to apturēt."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: pašlaik tiek izmantots. Pieskarieties vienumam Iestatījumi, lai to kontrolētu."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Galvenais notiekošais process."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Pakalpojums <xliff:g id="COMP_NAME">%1$s</xliff:g> tiek lietots."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Nodrošinātājs <xliff:g id="COMP_NAME">%1$s</xliff:g> tiek lietots."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Vai apturēt sistēmas pakalpojumu?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Valodas, ievade un žesti"</string>
    <string name="language_settings" msgid="8700174277543875046">"Valodas un ievade"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Valodas"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Tastatūra"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Jums nav atļaujas mainīt ierīces valodu."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Valodas un ievade"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Rīki"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastatūra un ievades metodes"</string>
    <string name="system_language" msgid="1146762166579643257">"Sistēmas valodas"</string>
    <string name="phone_language" msgid="5986939176239963826">"Valodas"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automātiski aizstāt"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Izlabot nepareizi uzrakstītos vārdus"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Automātisks lielo burtu lietojums"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Lielais sākuma burts teikuma pirmajam vārdam"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automātiski likt pieturzīmes"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Fiziskās tastatūras iestatījumi"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Divreiz nospiediet atstarpes taustiņu, lai ievietotu “.”"</string>
    <string name="show_password" msgid="7101900779571040117">"Rādīt paroles"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Rakstot tiek īslaicīgi rādītas rakstzīmes"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Izmantojot šo pareizrakstības pārbaudītāju, var tikt vākta informācija par visu ierakstīto tekstu, tostarp personīgiem datiem, piemēram, parolēm un kredītkaršu numuriem. Šis pareizrakstības pārbaudītājs ir saistīts ar lietotni <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Vai izmantot šo pareizrakstības pārbaudītāju?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Iestatījumi"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Valoda"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastatūras"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Ekrāna tastatūra"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Pieejamā ekrāna tastatūra"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Pārvaldīt ekrāna tastatūru"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opcijas"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fiziskā tastatūra"</string>
    <string name="show_ime" msgid="4334255501724746849">"Izmantot ekrāna tastatūru"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Paturēt ekrānā, kamēr ir aktīva fiziskā tastatūra"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Īsinājumtaustiņi"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Rādīt īsinājumtaustiņu sarakstu"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatūras un rīki darba profilā"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Ekrāna tastatūra darbam"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Noklusējums"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Skārienpaliktnis"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Skārienpaliktnis un pele"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Rādītāja ātrums, žesti"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Pieskaršanās, lai noklikšķinātu"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Skārienpaliktņa žesti"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Varat pielāgot atsevišķus skārienpaliktņa navigācijas žestus"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Ritināšana atpakaļgaitā"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Ritinot lejup, saturs pārvietosies augšup"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Pieskaršanās apakšā pa labi"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Citas iespējas: skārienpaliktņa labais apakšējais stūris"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Rādītāja ātrums"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Apgūt skārienpaliktņa žestus"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Došanās uz sākuma ekrānu"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Ar trīs pirkstiem velciet augšup pa skārienpaliktni"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Došanās atpakaļ"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Ar trīs pirkstiem velciet no kreisās vai labās puses"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Nesen izmantoto lietotņu skatīšana"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Ar trīs pirkstiem velciet augšup, turiet un tad atlaidiet"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Paziņ. un ātro iestat. skatīšana"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Ar trīs pirkstiem velciet lejup sākuma ekrānā"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Lietotņu pārslēgšana"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Ar četriem pirkstiem velciet pa kreisi vai pa labi"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Izlaist"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Tālāk"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Restartēt"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Gatavs"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Atpakaļ"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Ar trīs pirkstiem velciet pa kreisi vai pa labi"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Uz sākuma ekrānu"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Ar trīs pirkstiem velciet augšup"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Pēdējās izmantotās lietotnes"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Ar trīs pirkstiem velciet augšup un pēc tam turiet"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Paziņojumi"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Ar trīs pirkstiem velciet lejup"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Lietotņu pārslēgšana"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Ar četriem pirkstiem velciet pa kreisi vai pa labi"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modificētājtaustiņi"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Šeit varat mainīt taustiņu darbību."</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Atiestatīt visus"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Noklusējums"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Vai tiešām vēlaties atiestatīt visus modificētājtaustiņus uz noklusējuma vērtībām?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Gatavs"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Atcelt"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Atiestatīt"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Modificētājtaustiņa izvēle"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Izvēlieties jaunu taustiņu — <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Noklusējums"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Runa"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Rādītāja ātrums"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Spēļu vadība"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Vibrācijas novirzīšana"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Novirzīt vibrāciju uz spēles vadāmierīci, kad ir izveidots savienojums"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Tastatūras izkārtojuma izvēle"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Iestatīt tastatūras izkārtojumus"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Lai pārsl., nosp. Ctrl + atst. t."</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Noklusējums"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Tastatūras izkārtojumi"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Fiziski tastatūras izkārtojumi"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Personiskā vārdnīca"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Personiskā vārdnīca darbam"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Pievienot vārdus izmantošanai lietotnēs, piemēram, pareizrakstības pārbaudītājā"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Pievienot"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Pievienot vārdnīcai"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Frāze"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Vairāk opciju"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Mazāk opciju"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Labi"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Vārds:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Saīsne:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Valoda:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Ierakstiet vārdu."</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Izvēles saīsne"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Vārda rediģēšana"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Rediģēt"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Dzēst"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Lietotāja vārdnīcā nav neviena vārda. Lai pievienotu vārdu, pieskarieties pogai Pievienot (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Visās valodās"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Citas valodas..."</string>
    <string name="testing" msgid="6294172343766732037">"Testēšana"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Ekrāna tastatūra, rīki"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Ekrāna tastatūra, fiziskā tastatūra, rīki"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fiziskā tastatūra"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Izkārtojums"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Izvēlēties sīkrīku"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Izvēlēties logrīku"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Vai izveidot logrīku un atļaut piekļuvi?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Kad būsiet izveidojis logrīku, lietojumprogramma varēs piekļūt visam attēlotajam saturam.\n\nLietojumprogramma: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nLogrīks: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Vienmēr ļaut <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> veidot logrīkus un piekļūt to datiem."</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Lietojuma statistika"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Kārtot pēc lietojuma laika"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Kārtot pēc pēdējās lietošanas"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Kārtot pēc lietotnes nosaukuma"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Pēdējo reizi izmantots"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Lietojuma laiks"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Pieejamība"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Pieejamības iestatījumi"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Displejs, mijiedarbība, audio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Redzes iestatījumi"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Varat pielāgot šo ierīci savām vajadzībām. Šīs pieejamības funkcijas var mainīt vēlāk sadaļā Iestatījumi."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Mainīt fonta lielumu"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Ekrāna lasītājs"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Subtitri"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Vispārīgi"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Attēlojums"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Krāsa un kustība"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Ekrāna aptumšošana"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Mijiedarbības vadīklas"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Laika vadīklas"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Sistēmas vadīklas"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Lejupielādētās lietotnes"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimentāla"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Funkciju karodziņi"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Bluetooth HCI okšķerēšanas žurnāla filtrēšana"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Iestatīt filtrus"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Atspējojiet un iespējojiet Bluetooth, lai izmaiņas stātos spēkā."</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Bluetooth HCI okšķerēšanas žurnāla filtrēšanas PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Bluetooth HCI okšķerēšanas žurnāla filtrēšanas MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Iestatiet filtrēšanas režīmu. (Atspējojiet un iespējojiet Bluetooth, lai izmaiņas stātos spēkā.)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Lai mainītu šo opciju, iestatiet Bluetooth HCI okšķerēšanas žurnāla režīmu “Iespējot filtrētos”."</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Ekrāna lasītājs, kas galvenokārt paredzēts akliem un vājredzīgiem lietotājiem"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Pieskarieties vienumiem ekrānā, lai tie tiktu skaļi nolasīti."</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Subtitru preferences"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Par subtitru preferencēm"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Uzzināt vairāk par subtitru preferencēm"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Palielinājums"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Palielinājuma saīsne"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Palielināt rakstīšanas laikā"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Rakstīšanas laikā lupa seko tekstam"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Neizslēgt, pārslēdzot lietotnes"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Pārslēdzot lietotnes, lupa paliks ieslēgta un tiks veikta tālināšana"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Kursorsvira"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Lai aktivizētu un pārvietotu lupu, izmantojiet ekrānā redzamo kursorsviru. Pieskarieties un turiet, pēc tam velciet kursorsviru, lai kontrolētu lupu. Lai pārvietotu kursorsviru, pieskarieties tai un velciet."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Par palielinājumu"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Uzzināt vairāk par palielinājumu"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Palielinājuma veids"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Varat palielināt visu ekrānu vai noteiktu apgabalu vai pāriet starp abām iespējām"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Pilnekrāna režīms"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Ekrāna daļa"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Pārslēdziet palielinājuma režīmu no visa ekrāna uz ekrāna daļu un otrādi"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Palielinājuma iespēju izvēle"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Palielināt visu ekrānu"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Palielināt ekrāna daļu"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Pārslēgties starp visa ekrāna/tā daļas palielināšanu"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Pieskarieties slēdža pogai, lai pārslēgtos starp abām opcijām."</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Vai pārslēgties uz pieejamības pogu?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Izmantojot trīskāršo skārienu, lai palielinātu ekrāna daļu, tiek aizkavēta rakstīšana un citas darbības.\n\nPieejamības poga peld ekrānā virs pārējām lietotnēm. Lai veiktu palielināšanu, pieskarieties tai."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Pārslēgties uz pieejamības pogu"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Izmantot trīskāršo skārienu"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Tādējādi var tikt palēnināta tastatūras darbība"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Trīsreiz pieskaroties, lai palielinātu ekrāna daļu, iespējams, pamanīsiet problēmas ar tastatūru.\n\nLai to novērstu, varat mainīt palielinājuma saīsni, izmantojot citu opciju, nevis trīskāršo skārienu.\n"<annotation id="link">"Mainīt iestatījumu"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Tomēr turpināt"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Atcelt"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Palielināšanas iestatījumi"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Palielināt, trīsreiz pieskaroties"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Palielināšana ar saīsni"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Palieliniet, lietojot saīsni un trīskāršu skārienu"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Par pakalpojumu <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Displeja lielums un teksts"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Teksta attēlojuma mainīšana"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Temats: gaisa balonu dizaini"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"No: Roberts"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Labrīt!\n\nEs tikai vēlos noskaidrot, kā sokas ar dizainiem. Vai tie būs gatavi līdz brīdim, kad sāksim būvēt jaunos balonus?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Atiestatīt iestatījumus"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Attēlojuma lieluma un teksta iestatījumi ir atiestatīti"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Vai atiestatīt displeja izmērus un tekstu?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Atiestatīt"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Vai ir kādi plāni nedēļas nogalei?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Es došos uz pludmali. Vai vēlies pievienoties?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opcijas"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Tuvināt ekrānā"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Pieskarieties 3 reizes, lai veiktu tālummaiņu"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Pieskarieties pogai, lai palielinātu"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Ātri tuviniet ekrānu, lai palielinātu saturu"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Tuvināšana&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Izmantojiet īsinājumtaustiņu, lai sāktu palielināšanu.&lt;br/&gt; {1,number,integer}. Pieskarieties ekrānam.&lt;br/&gt; {2,number,integer}. Lai pārvietotos ekrānā, velciet ar diviem pirkstiem.&lt;br/&gt; {3,number,integer}. Lai regulētu tālummaiņu, savelciet ar diviem pirkstiem.&lt;br/&gt; {4,number,integer}. Izmantojiet īsinājumtaustiņu, lai pārtrauktu palielināšanu.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Īslaicīga tuvināšana&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Pārliecinieties, vai iestatītais palielinājuma veids ir “Pilnekrāna režīms”.&lt;br/&gt; {1,number,integer}. Izmantojiet īsinājumtaustiņu, lai sāktu palielināšanu.&lt;br/&gt; {2,number,integer}. Pieskarieties un turiet jebkurā ekrāna vietā.&lt;br/&gt; {3,number,integer}. Lai pārvietotos ekrānā, velciet ar pirkstu.&lt;br/&gt; {4,number,integer}. Paceliet pirkstu, lai pārtrauktu palielināšanu."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Kad ir ieslēgts palielinājums, ekrānā varat izmantot tuvināšanu.\n\n"<b>"Lai izmantotu tālummaiņu"</b>", aktivizējiet palielinājumu un pēc tam pieskarieties jebkur ekrānā.\n"<ul><li>"Velciet ar vismaz 2 pirkstiem, lai ritinātu."</li>\n<li>"Savelciet kopā vismaz 2 pirkstus, lai pielāgotu tālummaiņu."</li></ul>\n\n<b>"Lai veiktu īslaicīgu tālummaiņu"</b>", aktivizējiet palielinājumu un pēc tam pieskarieties jebkurai vietai ekrānā un turiet to.\n"<ul><li>"Velciet ar pirkstu, lai pārvietotos pa ekrānu."</li>\n<li>"Paceliet pirkstu, lai veiktu tālināšanu."</li></ul>\n\n"Tastatūrā vai navigācijas joslā nevarat veikt tuvināšanu."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"<xliff:g id="CURRENT_PAGE">%1$d</xliff:g>. lapa no <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Pieejamības pogas izmantošana atvēršanai"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Lai atvērtu, turiet nospiestas skaļuma pogas"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Lai atvērtu, trīsreiz pieskarieties ekrānam"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Žesta izmantošana atvēršanai"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Pieejamības žesta izmantošana"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Lai izmantotu šo funkciju, ekrāna apakšdaļā pieskarieties pieejamības pogai <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nLai pārslēgtu funkcijas, pieskarieties pieejamības pogai un turiet to."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Lai izmantotu šo funkciju, pieskarieties ekrānā esošajai pieejamības pogai."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Lai izmantotu šo funkciju, nospiediet un turiet abas skaļuma pogas."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Lai sāktu un apturētu palielināšanu, trīsreiz pieskarieties jebkurā ekrāna vietā."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Lai izmantotu šo funkciju, ar diviem pirkstiem velciet augšup no ekrāna apakšdaļas.\n\nLai pārslēgtu funkcijas, velciet augšup ar diviem pirkstiem un turiet."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Lai izmantotu šo funkciju, ar trīs pirkstiem velciet augšup no ekrāna apakšdaļas.\n\nLai pārslēgtu funkcijas, velciet augšup ar trīs pirkstiem un turiet."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Lai izmantotu pieejamības funkciju, ar diviem pirkstiem velciet augšup no ekrāna apakšdaļas.\n\nLai pārslēgtu funkcijas, velciet augšup ar diviem pirkstiem un turiet."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Lai izmantotu pieejamības funkciju, ar trīs pirkstiem velciet augšup no ekrāna apakšdaļas.\n\nLai pārslēgtu funkcijas, velciet augšup ar trīs pirkstiem un turiet."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Labi"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Pieejamības pogas iestatījumi"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Pakalpojuma <xliff:g id="SERVICE">%1$s</xliff:g> saīsne"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Pieejamības poga"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Pieejamības žests"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Vilkšana augšup ar 2 pirkstiem"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Vilkšana augšup ar 3 pirkstiem"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Pieskarties pieejamības pogai"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Izmantot pieejamības žestu"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Ekrāna apakšdaļā pieskarieties pieejamības pogai <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nLai pārslēgtu funkcijas, pieskarieties pieejamības pogai un turiet to."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Velciet ar 2 pirkstiem augšup no ekrāna apakšdaļas.\n\nLai pārslēgtu funkcijas, velciet ar 2 pirkstiem augšup un turiet."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Velciet ar 3 pirkstiem augšup no ekrāna apakšdaļas.\n\nLai pārslēgtu funkcijas, velciet ar 3 pirkstiem augšup un turiet."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Citas opcijas"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Plašāka informācija par: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Turēt nospiestas skaļuma pogas"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"turiet nospiestus skaļuma pogas"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Nospiediet un turiet abas skaļuma pogas"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Pieskaršanās ekrānam 3 reizes"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"trīsreiz pieskarieties ekrānam"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Ātri pieskarieties ekrānam {0,number,integer} reizes. Šī saīsne var palēnināt ierīces darbību."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Papildu"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Pieejamības pogai ir iestatīts pakalpojums <xliff:g id="SERVICE">%1$s</xliff:g>. Lai izmantotu palielināšanu, pieskarieties pieejamības pogai un pēc tam atlasiet palielināšanu."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Pieejamības žestam ir iestatīts <xliff:g id="SERVICE">%1$s</xliff:g>. Lai izmantotu palielinājumu, velciet ar diviem pirkstiem no ekrāna apakšdaļas un turiet. Pēc tam atlasiet palielinājumu."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Skaļuma pogu saīsne"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Saīšņu iestatījumi"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Saīsne no bloķēšanas ekrāna"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Atļaut funkcijas saīsni ieslēgt no bloķēšanas ekrāna. Turiet abas skaļuma pogas dažas sekundes."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Pieejamības poga"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Pieejamības poga un žests"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Ātri piekļūstiet pieejamības funkcijām no jebkura ekrāna"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Par pieejamības pogu"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Par pieejamības pogu un žestu"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Uzzināt vairāk par pieejamības pogu un žestu"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Tiek izmantota pieejamības poga. Žests nav pieejams, izmantojot 3 pogu navigāciju."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Ātri piekļūt pieejamības funkcijām"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Lai sāktu darbu, veiciet tālāk norādītās darbības."</b>\n"1. Pārejiet uz pieejamības iestatījumiem.\n2. Atlasiet funkciju un pieskarieties saīsnei.\n3. Izvēlieties, vai izmantot pogu vai žestu, lai piekļūtu funkcijai."</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Lai sāktu darbu, veiciet tālāk norādītās darbības."</b>\n"1. Pārejiet uz pieejamības iestatījumiem.\n2. Atlasiet funkciju un pieskarieties saīsnei.\n3. Izvēlieties pogu, lai piekļūtu funkcijai."</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Izmantot pogu vai žestu"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Atrašanās vieta"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Lielums"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Neizmantojot poga kļūst neskaidra"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Poga pēc dažām sekundēm kļūst neskaidra, lai būtu vieglāk redzēt ekrānu"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Caurspīdīgums, kad poga netiek izmantota"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Caurspīdīga"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Necaurspīdīga"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Liela kontrasta teksts"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mainīt teksta krāsu uz melnu vai baltu, lai palielinātu kontrastu ar fonu."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Ekrāna palielinājuma autom. atjaun."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Atjaunināt ekrāna palielinājumu lietotņu pārejās"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Barošanas poga beidz zvanu"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Liela rādītāja ikona"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Padariet peles rādītāju pamanāmāku"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Noņemt animācijas"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Samazināt kustību ekrānā"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Mono audio"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Apvienot kanālus, ja tiek atskaņots audio"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Audio balanss"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Pa kreisi"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Pa labi"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Noklusējums"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekundes"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekundes"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minūte"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minūtes"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Laiks darbībai (pieejamības noildze)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Par laiku veikt darbību (pieejamības noildze)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Uzzināt vairāk par laiku veikt darbību (pieejamības noildze)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Laiks veikt darbību"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Ne visas lietotnes atbalsta šo laika preferenci"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Izvēlieties, cik ilgi jārāda īslaicīgi ziņojumi, kuros ir iekļauts aicinājums uz darbību"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Aizkave, pieskaroties un turot"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Krāsu inversija"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Izmantot krāsu inversiju"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Krāsu inversijas saīsne"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Izmantojot krāsu inversiju, gaišs ekrāna saturs tiek rādīts tumšā krāsā, bet tumšs — gaišā."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Svarīga informācija&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Mainīsies krāsas multivides saturā un attēlos.&lt;/li&gt; &lt;li&gt; Krāsu inversija darbojas visās lietotnēs.&lt;/li&gt; &lt;li&gt; Lai rādītu tumšu fonu, tās vietā var izmantot tumšo motīvu.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automātiska klikšķināšana (pārdomu laiks)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Par autom. klikšķ. (pārdomu laiks)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Uzzināt vairāk par automātisku klikšķināšanu (pārdomu laiks)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Varat iestatīt, ka ikreiz, kad kursors noteiktu laiku ir nekustīgs, automātiski jānoklikšķina ar pievienotu peli"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Automātiskā klikšķināšana var būt noderīga, ja ir grūti noklikšķināt ar peli"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automātiskā klikšķināšana ir izslēgta"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Īss"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekundes"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Vidēji"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekundes"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Ilgi"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekunde"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Pielāgoti"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Īsāks"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Ilgāks"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Automātiskās klikšķināšanas laiks"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibrācija un vibrācija pieskaroties"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Pārvaldiet vibrācijas stiprumu dažādai lietošanai."</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Ieslēgts"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Izslēgts"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Iestatījums ir atspējots, jo ierīcē ir iestatīts klusuma režīms"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Zvani"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Paziņojumi un signāli"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktīva vibrācija"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Izmantot vibrāciju un vibrāciju pieskaroties"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Signāla vibrācija"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Multivides atskaņošanas vibrācija"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Zvana vibrācija"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Paziņojuma vibrācija"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Pieskarieties vienumam Atsauksmes"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Izmantot lietotni <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Atvērt lietotni <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"Lietotne <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> ir pievienota ātrajiem iestatījumiem. Jebkurā laikā varat to ieslēgt vai izslēgt, velkot lejup."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Varat arī pievienot lietotni <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> ātrajiem iestatījumiem ekrāna augšdaļā"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Krāsu korekcija ir pievienota ātrajiem iestatījumiem. Jebkurā laikā varat to ieslēgt vai izslēgt, velkot lejup."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Varat arī pievienot krāsu korekciju ātrajiem iestatījumiem ekrāna augšdaļā"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Krāsu inversija ir pievienota ātrajiem iestatījumiem. Jebkurā laikā varat to ieslēgt vai izslēgt, velkot lejup."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Varat arī pievienot krāsu inversiju ātrajiem iestatījumiem ekrāna augšdaļā"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Papildu aptumšošana ir pievienota ātrajiem iestatījumiem. Jebkurā laikā varat to ieslēgt vai izslēgt, velkot lejup."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Varat arī pievienot papildu aptumšošanu ātrajiem iestatījumiem ekrāna augšdaļā"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Vienas rokas režīms ir pievienots ātrajiem iestatījumiem. Jebkurā laikā varat to ieslēgt vai izslēgt, velkot lejup."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Varat arī pievienot vienas rokas režīmu ātrajiem iestatījumiem ekrāna augšdaļā"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Fonta lielums ir pievienots ātrajiem iestatījumiem. Jebkurā brīdī velciet lejup, lai mainītu fonta lielumu."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Nerādīt"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Izmantot krāsu korekciju"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Krāsu korekcijas saīsne"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Par krāsu korekciju"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Uzzināt vairāk par krāsu korekciju"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Par krāsu inversiju"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Uzzināt vairāk par krāsu inversiju"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Rādīt subtitrus"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Tikai atbalstītai lietotnei"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Subtitru lielums un stils"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"<xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g> teksta lielums"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Citas iespējas"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Pielāgojiet subtitru lielumu un stilu, lai atvieglotu to lasīšanu"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Ne visas multivides lietotnes atbalsta šīs subtitru preferences"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Pieejamības poga"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Velciet augšup ar diviem pirkstiem no apakšdaļas"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Turēt nospiestas skaļuma pogas"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trīsreiz pieskarieties ekrānam"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Turpināt"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Dzirdes aparāti"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Kopā ar savu tālruni varat izmantot dzirdes aparātus, kohleāros implantus un citas skaņas pastiprināšanas ierīces"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nav pievienots neviens dzirdes aparāts"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Pievienot dzirdes aparātus"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Dzirdes aparātu sav. pārī"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Nākamajā ekrānā atlasiet savus dzirdes aparātus. Iespējams, kreisās un labās auss ierīces būs jāsavieno pārī atsevišķi.\n\nPārbaudiet, vai dzirdes aparāti ir ieslēgti un gatavi savienošanai pārī."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"Ierīce <xliff:g id="DEVICE_NAME">%1$s</xliff:g> ir aktīva"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, tikai kreisā auss"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, tikai labā auss"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, kreisā un labā auss"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> un vēl 1 ierīce"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Jauna ierīce"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Par savienošanu pārī ar jaunu ierīci"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Dzirdes aparāti"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Saglabātās ierīces"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Dzirdes aparāta vadīklas"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Dzirdes aparāta saīsne"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Saderība ar dzirdes aparātiem"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Uzlabo saderību ar indukcijas spolēm un samazina nevēlamo trokšņu skaļumu"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Par dzirdes aparātiem"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Dzirdes aparātam jābūt ieslēgtam un gatavam izveidot savienojumu pārī"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Savienošana pārī"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Pieejamie dzirdes aparāti"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Vai neredzat savu dzirdes aparātu?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Skatiet citas ierīces"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Audio korekcija"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Audio apraksts"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Klausieties aprakstu par to, kas notiek atbalstītajās filmās un pārraidēs"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"audio apraksts, audio, apraksts, vājredzība,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Saīsne ieslēgta"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Izslēgta"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Ieslēgts"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Izslēgts"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Nedarbojas. Pieskarieties, lai skatītu informāciju."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Šis pakalpojums nedarbojas pareizi."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Pieejamības saīsnes"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Rādīt ātrajos iestatījumos"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Sarkana/zaļa krāsa"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Sarkana/zaļa krāsa"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Zila/dzeltena krāsa"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Pelēktoņu iestatījums"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Vāja jutība pret zaļo krāsu, deiteranomālija"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Vāja jutība pret sarkano krāsu, protanomālija"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomālija"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Papildu aptumšošana"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Izmantot ekrāna papildu aptumšošanu"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Papildu aptumšošanas saīsne"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Par papildu aptumšošanu"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Aptumšojiet ekrānu, lai būtu ērtāk lasīt"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensitāte"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Tumšāks"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Gaišāks"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Pēc ierīces restartēšanas atstāt ieslēgtu"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Īsa aizkave ({time} sekunde)}zero{Īsa aizkave ({time} sekunžu)}one{Īsa aizkave ({time} sekunde)}other{Īsa aizkave ({time} sekundes)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Vidēja aizkave ({time} sekunde)}zero{Vidēja aizkave ({time} sekunžu)}one{Vidēja aizkave ({time} sekunde)}other{Vidēja aizkave ({time} sekundes)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Ilga aizkave ({time} sekunde)}zero{Ilga aizkave ({time} sekunžu)}one{Ilga aizkave ({time} sekunde)}other{Ilga aizkave ({time} sekundes)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekunde}zero{{time} sekunžu}one{{time} sekunde}other{{time} sekundes}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Iestatījumi"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Ieslēgta"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Izslēgta"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Priekšskatījums"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standarta opcijas"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Valoda"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Teksta lielums"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Subtitru stils"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Pielāgotas opcijas"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Fona krāsa"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Fona necaurredzamība"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Parakstu loga krāsa"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Parakstu loga necaurredzamība"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Teksta krāsa"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Teksta necaurredzamība"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Malu krāsa"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Malu veids"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Fontu saime"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Subtitri izskatīsies šādi:"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Noklusējums"</string>
    <string name="color_title" msgid="2511586788643787427">"Krāsa"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Noklusējuma"</string>
    <string name="color_none" msgid="3703632796520710651">"Nav"</string>
    <string name="color_white" msgid="1896703263492828323">"Balta"</string>
    <string name="color_gray" msgid="8554077329905747877">"Pelēka"</string>
    <string name="color_black" msgid="9006830401670410387">"Melna"</string>
    <string name="color_red" msgid="5210756997426500693">"Sarkana"</string>
    <string name="color_green" msgid="4400462091250882271">"Zaļa"</string>
    <string name="color_blue" msgid="4997784644979140261">"Zila"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Ciānzila"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Dzeltena"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Fuksīnsarkana"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Vai atļaut pakalpojumam <xliff:g id="SERVICE">%1$s</xliff:g> pilnībā kontrolēt jūsu ierīci?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"Pakalpojumam <xliff:g id="SERVICE">%1$s</xliff:g> nepieciešams:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Lietotne Iestatījumi nevar verificēt jūsu atbildi, jo cita lietotne aizsedz atļaujas pieprasījumu."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"Pakalpojums <xliff:g id="SERVICE">%1$s</xliff:g> pieprasa pilnīgu šīs ierīces kontroli. Pakalpojums var piekļūt ekrānā redzamajai informācijai un veikt darbības to lietotāju vārdā, kuriem ir īpašas vajadzības. Šāda līmeņa kontrole vairākumam lietotņu nav nepieciešama."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Pilnīga kontrole ir piemērota lietotnēm, kas nepieciešamas lietotājiem ar īpašām vajadzībām, taču ne lielākajai daļai lietotņu."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Ekrāna skatīšana un pārvaldīšana"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Tā var nolasīt visu ekrānā esošo saturu un attēlot saturu citām lietotnēm."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Darbību skatīšana un veikšana"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Tā var izsekot jūsu mijiedarbību ar lietotni vai aparatūras sensoru un mijiedarboties ar lietotnēm jūsu vārdā."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Atļaut"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Neatļaut"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Apturēt"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Atcelt"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Vai apturēt <xliff:g id="SERVICE">%1$s</xliff:g> darbību?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Pieskaroties vienumam <xliff:g id="STOP">%1$s</xliff:g>, tiks apturēts pakalpojums <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nav instalēts neviens pakalpojums."</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nav atlasīts neviens pakalpojums"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Apraksts nav sniegts."</string>
    <string name="settings_button" msgid="2195468788019730377">"Iestatījumi"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"jutīgums pret gaismu, fotofobija, tumšais motīvs, migrēna, galvassāpes, lasīšanas režīms, nakts režīms, samazināt spilgtumu, baltais punkts"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Ērta lietošana, ērta piekļuve, atbalsts, papildu darbības"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Loga palielināšana, tālummaiņa, palielinājums, vājredzība, palielināt, padarīt lielāku"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Titri, slēptie subtitri, subtitri, tieša transkripcija, vājdzirdība, nedzirdība, stenogrāfija reāllaikā, runas pārvēršana tekstā, runas teksts"</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">"ekrāna lielums, liels ekrāns"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Augsts kontrasts, vājredzība, fonti treknrakstā, treknraksts"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"pielāgot krāsu"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"ieslēgt tumšu ekrānu, ieslēgt gaišu ekrānu"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"krāsu kontrasts"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motorika, pele"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"dzirdes aparāti, vājdzirdība, nedzirdība, kohleārie implanti, skaņas pastiprināšanas ierīces, skaņu apstrādātāji"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"vājdzirdība, nedzirdība, subtitri, teletaips, teksta tālrunis"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Drukāšana"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Izslēgts"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{Ieslēgts 1 drukāšanas pakalpojums}zero{Ieslēgti # drukāšanas pakalpojumi}one{Ieslēgts # drukāšanas pakalpojums}other{Ieslēgti # drukāšanas pakalpojumi}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 drukas uzdevums}zero{# drukas uzdevumu}one{# drukas uzdevums}other{# drukas uzdevumi}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Drukāšanas pakalpojumi"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nav instalēts neviens pakalpojums"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nav atrasts neviens printeris."</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Iestatījumi"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Pievienot printerus"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Ieslēgta"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Izslēgta"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Pievienot pakalpojumu"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Pievienot printeri"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Meklēt"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Printeru meklēšana"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Pakalpojums ir atspējots"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Drukas darbi"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Drukas darbs"</string>
    <string name="print_restart" msgid="4424096106141083945">"Restartēt"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Atcelt"</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">"Notiek <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> konfigurēšana"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Notiek darba <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> drukāšana"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Pārtrauc drukas darbu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>…"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Printera kļūda ar darbu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printeris bloķēja darbu <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Meklēšanas lodziņš ir redzams"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Meklēšanas lodziņš ir paslēpts"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Plašāka informācija par šo printeri"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Akumulators"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Kas patērējis akumulatoru"</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">"Vēl <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"Atlikušais uzlādes laiks: <xliff:g id="UNTIL_CHARGED">%1$s</xliff:g>"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Zems akumulatora uzlādes līmenis"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Atļaut lietotnei darboties fonā"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Vai ierobežot darbību fonā?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Ierobežojot lietotnes darbību fonā, var rasties šīs lietotnes darbības traucējumi."</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Lietotnei nav iestatīta akumulatora optimizācija, tāpēc to nevar ierobežot.\n\nVispirms iestatiet akumulatora optimizāciju."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Neierobežots"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimizēts"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Ierobežoti"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Atļaut akumulatora lietojumu fonā bez ierobežojumiem. Var tikt izmantots vairāk akumulatora enerģijas."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimizēt, pamatojoties uz lietojumu. Ieteicams lielākajai daļai lietotņu."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Ierobežot akumulatora lietojumu, kad darbība notiek fonā. Lietotne var nedarboties, kā paredzēts. Paziņojumi var tikt aizkavēti."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Mainot to, kā lietotne izmanto jūsu akumulatora enerģiju, var tikt ietekmēta tās veiktspēja."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Šai lietotnei ir nepieciešams <xliff:g id="STATE">%1$s</xliff:g> akumulatora lietojums."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"neierobežots"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimizēts"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Uzziniet vairāk par akumulatora lietojuma iespējām."</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Ekrāna lietojums kopš pilnas uzlādes"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Akumulatora lietojums"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Vēstures dati"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Akumulatora lietojums"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Skatīt lietojumu pēdējo 24 stundu laikā"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Lietojums kopš pēdējās pilnas uzlādes"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Akumulatora lietojums lietotnēm"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Izmantot detaļas"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Noregulēt strāvas patēriņu"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Iekļautās pakotnes"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Lietotnes darbojas normāli"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Zems akumulatora uzlādes līmenis"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Lai paildzinātu akumulatora darbību, ieslēdziet akumulatora enerģijas taupīšanas režīmu"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Akumulatora darbības paildzināšana"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Ieslēgt akumulatora enerģijas taupīšanas režīmu"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Ieslēgt akumulatora enerģijas taupīšanas režīmu"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Akumulators var izlādēties ātrāk nekā parasti."</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Akumulatora enerģijas taupīšanas režīms ieslēgts"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Uzzināt vairāk par akumulatora enerģijas taupīšanas režīmu"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Dažu funkciju darbība var tikt ierobežota."</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Lielāks akumulatora lietojums"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Skatiet lietotnes, kas patērē visvairāk akumulatora enerģijas"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Uzlāde optimizēta, lai saudzētu jūsu akumulatoru"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Lai paildzinātu jūsu akumulatora darbmūžu, uzlāde tiek optimizēta."</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Uzlāde optimizēta, lai saudzētu jūsu akumulatoru"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Lai paildzinātu jūsu akumulatora darbmūžu, dokošanas laikā uzlāde tiek optimizēta."</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Uzlāde optimizēta, lai saudzētu jūsu akumulatoru"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Lai paildzinātu jūsu akumulatora darbmūžu, dokošanas laikā uzlāde tiek optimizēta."</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Pilnīga uzlāde"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Lai saudzētu jūsu akumulatoru, uzlāde tiks optimizēta, kad jūsu planšetdators nākamreiz būs dokots."</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Uzziniet vairāk par paziņojumu “Uzlāde ir apturēta”"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Atsākt uzlādi"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Iekļautas lieljaudas fona darbības"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Jāierobežo # lietotnes darbība}zero{Jāierobežo # lietotņu darbība}one{Jāierobežo # lietotnes darbība}other{Jāierobežo # lietotņu darbība}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{Nesen tika ierobežota lietotnes {label} darbība}zero{Nesen tika ierobežota # lietotņu darbība}one{Nesen tika ierobežota # lietotnes darbība}other{Nesen tika ierobežota # lietotņu darbība}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{Lietotne {label} fonā patērē daudz akumulatora enerģijas.}zero{# lietotnes fonā patērē daudz akumulatora enerģijas.}one{# lietotne fonā patērē daudz akumulatora enerģijas.}other{# lietotnes fonā patērē daudz akumulatora enerģijas.}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Šī lietotne nevar darboties fonā.}zero{Šīs lietotnes nevar darboties fonā.}one{Šīs lietotnes nevar darboties fonā.}other{Šīs lietotnes nevar darboties fonā.}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Vai ierobežot lietotnes darbību?}zero{Vai ierobežot # lietotņu darbību?}one{Vai ierobežot # lietotnes darbību?}other{Vai ierobežot # lietotņu darbību?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Lai taupītu akumulatora jaudu, neļaujiet lietotnei <xliff:g id="APP">%1$s</xliff:g> fonā patērēt akumulatora enerģiju. Šī lietotne var darboties neatbilstoši, un paziņojumi var tikt parādīti aizkavēti."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Lai taupītu akumulatora jaudu, neļaujiet norādītajām lietotnēm fonā patērēt akumulatora enerģiju. Lietotnes ar ierobežotu darbību var darboties neatbilstoši, un paziņojumi var tikt parādīti aizkavēti.\n\nLietotnes:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Lai taupītu akumulatora jaudu, neļaujiet norādītajām lietotnēm fonā patērēt akumulatora enerģiju. Lietotnes ar ierobežotu darbību var darboties neatbilstoši, un paziņojumi var tikt parādīti aizkavēti.\n\nLietotnes:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Ierobežot"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Vai noņemt ierobežojumu?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Šī lietotne varēs izmantot akumulatora enerģiju fonā. Tādējādi akumulators var izlādēties ātrāk nekā parasti."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Noņemt"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Atcelt"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Pilnībā uzlādēt"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problēma ar uzlādes ierīci"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Uzzināt vairāk par uzlādi ar nesaderīgu lādētāju"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Akumulatora pārvaldnieks"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Automātiska akumulatora enerģijas patēriņa pārvaldība"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Ja akumulatora pārvaldnieks konstatēs, ka lietotnes patērē daudz akumulatora enerģijas, varēsiet ierobežot šo lietotņu darbību. Šīs lietotnes var darboties neatbilstoši, un paziņojumi var tikt parādīti aizkavēti."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Lietotnes ar ierobežotu darbību"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Tiks ierobežots akumulatora lietojums # lietotnei.}zero{Tiks ierobežots akumulatora lietojums # lietotnēm.}one{Tiks ierobežots akumulatora lietojums # lietotnei.}other{Tiks ierobežots akumulatora lietojums # lietotnēm.}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Ierobežota <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Šīs lietotnes nedrīkst fonā patērēt akumulatora enerģiju. Tās var nedarboties, kā paredzēts, un paziņojumi var tikt parādīti aizkavēti."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Izmantot akumulatora pārvaldnieku"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Nosaka lietotnes, kas patērē daudz akumulatora enerģijas"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Tādu lietotņu noteikšana, kas patērē daudz akumulatora enerģijas"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Tādu lietotņu noteikšana, kas patērē daudz akumulatora enerģijas"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{Ierobežota # lietotnes darbība.}zero{Ierobežota # lietotņu darbība.}one{Ierobežota # lietotnes darbība.}other{Ierobežota # lietotņu darbība.}}"</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">"Nevar iegūt informāciju par akumulatora uzlādes līmeni."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Pieskarieties, lai uzzinātu vairāk par šo kļūdu."</string>
    <string name="power_screen" msgid="4596900105850963806">"Ekrāns"</string>
    <string name="power_cpu" msgid="1820472721627148746">"Centrālais procesors"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Lukturītis"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</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">"Mobilais tīkls"</string>
    <string name="power_phone" msgid="2768396619208561670">"Balss zvani"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Ekrāna lietojums: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> izmanto lietotne <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> no vispārējā akumulatora lietojuma"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Sadalījums kopš pēdējās pilnās uzlādes"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Pēdējā pilnā uzlāde"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Darbības ilgums pēc pilnas uzlādes"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Atlikušais akumulatora darbības ilgums ir aptuvens un var mainīties atkarībā no lietojuma."</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Akumulatora lietojums"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Nav lietots kopš pēdējās pilnās uzlādes"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Nav lietots pēdējo 24 h laikā"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"kopš pēdējās pilnās uzlādes"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Sistēmas lietotnes"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Citi"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Plānotais atlikušais laiks"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Līdz pilnai uzlādei"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Aprēķinātais laiks var mainīties atkarībā no lietojuma"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Lietotnes optimizācija"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Piesaiste"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Noņemtās lietotnes"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Akumulatora enerģijas taupīšanas režīms"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Automātiska ieslēgšana"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Nav grafika"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Atbilstoši jūsu ikdienas grafikam"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Tiks ieslēgts, ņemot vērā darbību secību"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Atbilstoši uzlādes līmenim"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Akumulatora enerģijas taupīšanas režīms ieslēgsies, ja akumulators var izlādēties vēl pirms ierastā uzlādes laika."</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Ieslēgsies uzlādes līmenim sasniedzot <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Iestatīt grafiku"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Akumulatora darbības laika paildzināšana"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Izslēgt, kad uzlādējies"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Izslēgt, kad uzlāde ir <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Akumulatora enerģijas taupīšanas režīms tiek izslēgts, kad akumulatora uzlādes līmenis sasniedz <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">"Ieslēgt"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Izmantot akumulatora enerģijas taupīšanas režīmu"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Ieslēgt automātiski"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nekad"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"ar akumulatora uzlādes līmeni <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Akumulatora uzlādes līmenis procentos"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Statusa joslā rādīt akumulatora uzlādes līmeni procentos"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Akumulatora uzlādes līmenis kopš pēdējās pilnās uzlādes"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Akumulatora līmenis pēdējo 24 h laikā"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Lietotnes lietojums kopš pēdējās pilnās uzlādes"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Lietotnes izmantojums pēdējo 24 h laikā"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Sistēmas lietojums kopš pēdējās pilnās uzlādes"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Sistēmas lietojums pēdējo 24 h laikā"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Sistēmas izmantojums: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Lietotnes izmantojums: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Sistēmas izmantojums kopš pēdējās pilnās uzlādes līdz: <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Lietotnes izmantojums kopš pēdējās pilnās uzlādes līdz: <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Kopā: mazāk par minūti"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Fonā: mazāk par minūti"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Izmantošanas ilgums: mazāk par minūti"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Kopā: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Fonā: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Izmantošanas ilgums: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Akumulatora lietojuma dati būs pieejami pēc dažām stundām, kad ierīce būs pilnīgi uzlādēta"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"tagad"</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> plkst. <xliff:g id="HOUR">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Akumulatora lietojuma diagramma"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Diagramma ar datiem par akumulatora lietojumu dienā"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Diagramma ar datiem par akumulatora lietojumu stundā"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Akumulatora lietojums kopš pēdējās pilnās uzlādes"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Akumulatora lietojums: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Izmantošanas ilgums kopš pēdējās pilnās uzlādes"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Izmantošanas ilgums: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Skatīt pēc lietotnes"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Skatīt pēc sistēmas"</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">"Procesu statistika"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Statistika par darbības procesiem"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Atmiņas lietojums"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Pēdējās <xliff:g id="TIMEDURATION">%3$s</xliff:g> izmantoti <xliff:g id="USEDRAM">%1$s</xliff:g> no <xliff:g id="TOTALRAM">%2$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="TIMEDURATION">%2$s</xliff:g> izmantots <xliff:g id="PERCENT">%1$s</xliff:g> RAM"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Fons"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Priekšplāns"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Saglabāts kešatmiņā"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Vietējie"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kodols"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Kešatmiņas"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM lietojums"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM lietojums (fonā)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Ilgums"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesi"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Pakalpojumi"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Ilgums"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Informācija par atmiņu"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 stundas"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 stundas"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 stundas"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 diena"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Rādīt sistēmas procesus"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Slēpt sistēmu"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Procentu rādīšana"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Lietot unikālo kopas lielumu"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistikas veids"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Fons"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Priekšplāns"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Saglabāts kešatmiņā"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Balss ievade un izvade"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Balss ievades un izvades iestatījumi"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Meklēšana ar balsi"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android tastatūra"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Balss ievades iestatījumi"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Balss ievade"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Balss ievades pakalpojumi"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Pilna īsinājumvārdu un mijiedarbības funkcionalitāte"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Vienkārša runas pārvēršana tekstā"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Šis balss ievades pakalpojums varēs jūsu vietā nepārtraukti veikt balss pārraudzību un pārvaldīt lietojumprogrammas, kurās iespējota balss ievade. Tas ir saistīts ar lietojumprogrammu <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Vai iespējot šo pakalpojumu?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Ierīcē izpildāmās atpazīšanas iestatījumi"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Atpazīšana ierīcē"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Runas atpazīšana ierīcē"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Vēlamā programma"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Programmas iestatījumi"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Runas ātrums un augstums"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Programma"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Balsis"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Runātā valoda"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Balsu instalēšana"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Pārejiet uz lietotni <xliff:g id="TTS_APP_NAME">%s</xliff:g>, lai instalētu balsis."</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Atvērt lietotni"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Atcelt"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Atiestatīt"</string>
    <string name="tts_play" msgid="2945513377250757221">"Atskaņot"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Nedrošs tīkls"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"Nedrošo tīklu skaits: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"Nedrošo tīklu skaits: <xliff:g id="VPN_COUNT">%d</xliff:g>"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Adaptīvā savienojamība"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Tiek paildzināts akumulatora darbības ilgums un uzlabota ierīces veiktspēja, automātiski pārvaldot jūsu tīkla savienojumus."</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Ieslēgta"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Izslēgta"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Adaptīvās savienojamības lietošana"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Akreditācijas datu krātuve"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Sertifikāta instalēšana"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Notīrīt akreditācijas datus"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Noņemt visus sertifikātus"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Uzticami akredit. dati"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Attēlot uzticamus CA sertifikātus"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Lietotāja akreditācijas dati"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Saglabāto akreditācijas datu skatīšana un pārvaldīšana"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Papildu"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Šim lietotājam nav pieejami akreditācijas dati."</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Instalēts VPN konfigurācijai un lietotnēm"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Instalēts Wi-Fi konfigurācijai"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Instalēts Wi-Fi konfigurācijai (tiek lietots)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Vai noņemt visu saturu?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Akreditācijas datu krātuve ir izdzēsta."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Akred. datus nevarēja izdzēst"</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Piekļuve lietojuma datiem"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA sertifikāts"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN un lietotnes liet. sertif."</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Wi‑Fi sertifikāts"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Jūsu dati nebūs privāti"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA sertifikāti tiek izmantoti vietnēs, lietotnēs un VPN tīklos, lai nodrošinātu šifrēšanu. Instalējiet CA sertifikātus tikai no uzticamām organizācijām. \n\nJa instalējat CA sertifikātu, sertifikāta īpašnieks var piekļūt jūsu datiem, piemēram, parolēm vai kredītkartes informācijai, no jūsu apmeklētajām vietnēm vai izmantotajām lietotnēm (pat ja šie dati ir šifrēti)."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Neinstalēt"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Tik un tā instalēt"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Sertifikāts nav instalēts"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Vai atļaut lietotnei "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" instalēt sertifikātus šajā ierīcē?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Šie sertifikāti jūs identificēs, kopīgojot jūsu ierīces unikālo ID ar tālāk norādītajām lietotnēm un vietrāžiem URL."</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Neatļaut"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Atļaut"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Rādīt vairāk"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Sertifikātu pārvaldības lietotne"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Nav"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Sertifikāti jūs identificēs, kad izmantosiet tālāk norādītās lietotnes un vietrāžus URL."</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Atinstalēt sertifikātus"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Noņemt lietotni"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Vai noņemt šo lietotni?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Šī lietotne nepārvaldīs sertifikātus, taču joprojām atradīsies jūsu ierīcē. Lietotnes instalētie sertifikāti tiks atinstalēti."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}zero{# URL}one{# URL}other{# URL}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Ārkārtas zvana signāls"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Iestatīt uzvedību, kad tiek veikts ārkārtas zvans"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Dublēšana"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Ieslēgts"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Izslēgts"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Dublēšana un atjaunošana"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Personīgie dati"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Dublēt manus datus"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Dublēt lietotnes datus, Wi-Fi paroles un citus iestatījumus Google serveros"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Rezerves konts"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Pārvaldīt dublēšanas kontu"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Lietotņu datu iekļaušana"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automātiska atjaunošana"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Atkārtoti instalējot lietotni, atjaunot dublētos iestatījumus un datus"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Dublēšanas pakalpojums nav aktīvs"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Pašlaik nevienā kontā netiek uzglabāti dublēti dati."</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Vai pārtraukt Wi-Fi paroļu, grāmatzīmju, lietotņu datu un citu iestatījumu dublēšanu un dzēst visas to kopijas Google serveros?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Vai pārtraukt ierīces datu (piemēram, Wi-Fi paroļu un zvanu vēstures) un lietotņu datu (piemēram, lietotņu iestatījumu un saglabāto failu) dublēšanu un dzēst visas to kopijas attālajos serveros?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Ierīces dati (piemēram, Wi-Fi paroles un zvanu vēsture) un lietotņu dati (piemēram, iestatījumi un lietotnēs uzglabātie faili) tiek automātiski attālināti dublēti.\n\nKad esat ieslēdzis automātisko dublēšanu, ierīces un lietotņu dati tiek regulāri attālināti saglabāti. Lietotņu dati var būt jebkādi lietotnēs saglabātie dati (atkarībā no izstrādātāja iestatījumiem), tostarp potenciāli sensitīvi dati, piemēram, informācija par kontaktpersonām, ziņojumi un fotoattēli."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Ierīces administratora iestatījumi"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Ierīces administratora lietotne"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktivizēt šo ierīces administratora lietotni"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Atinstalēt lietotni"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktivizēt un atinstalēt"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Ierīces administratora lietotnes"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nav pieejama neviena ierīces administratora lietotne."</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nav pieejama neviena uzticamības pārbaudes programma"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Vai aktivizēt administratora lietotni?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktivizēt šo ierīces administratora lietotni"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Ierīces administrators"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Aktivizējot šo administratora lietotni, lietotnei <xliff:g id="APP_NAME">%1$s</xliff:g> tiks atļauts veikt šādas darbības:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Šī ierīce tiks pārvaldīta un pārraudzīta lietotnē <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Šī administratora lietotne ir aktīva un ļauj lietotnei <xliff:g id="APP_NAME">%1$s</xliff:g> veikt šādas darbības:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Vai aktivizēt profila pārvaldnieku?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Vai atļaut uzraudzību?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ja turpināsiet, jūsu lietotāja profilu pārvaldīs administrators. Tādējādi papildus jūsu personas datiem var tikt glabāti arī saistīti dati.\n\nAdministrators var pārraudzīt un pārvaldīt iestatījumus, piekļuvi, lietotnes un datus, kas saistīti ar šo lietotāju, tostarp darbības tīklā un informāciju par ierīces atrašanās vietu."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Citas iespējas ir atspējojis administrators."</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Uzzināt vairāk"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Paziņojumu žurnāls"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Paziņojumu vēsture"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Pēdējās %d stundas"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Atliktas"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nesen noraidītie"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# paziņojums}zero{# paziņojumu}one{# paziņojums}other{# paziņojumi}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Zvana signāls un vibrozvans"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Dati par tīklu"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinhronizācija iespējota"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinhronizācija atspējota"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Notiek sinhronizācija"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Sinhronizācijas kļūda"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinhronizācija neizdevās"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinhronizācija darbojas"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinhronizācija"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Pašreiz ir sinhronizācijas problēmas. Drīz šī darbība atkal būs pieejama."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Pievienot kontu"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Darba profils vēl nav pieejams"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Darba lietotnes"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Noņemt darba profilu"</string>
    <string name="background_data" msgid="321903213000101158">"Fona dati"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Lietotnēs jebkurā brīdī var sinhr., sūtīt un saņemt datus"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Atspējot fona datus?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Atspējojot fona datus, tiek pagarināts akumulatora darbības laiks un samazināts datu lietojums. Dažās lietojumprogrammās joprojām var tikt izmantots fona datu savienojums."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sinhr. ir IESLĒGTA"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinhr. ir IZSLĒGTA"</string>
    <string name="sync_error" msgid="846923369794727644">"Sinhroniz. kļūda"</string>
    <string name="last_synced" msgid="1527008461298110443">"Pēdējoreiz sinhronizēts: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Pašlaik notiek sinhronizācija…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Dublēšanas iestatījumi"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Iestatījumu dublēšana"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinhronizēt tūlīt"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Atcelt sinhronizāciju"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Pieskarieties, lai sinhronizētu tūlīt<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">"Kalendārs"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontaktpersonas"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Lietotnes sinhronizācijas iestatījumi"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Dati un sinhronizācija"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Mainīt paroli"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Konta iestatījumi"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Noņemt kontu"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Pievienot kontu"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Vai noņemt kontu?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Jūsu administrators neļauj veikt šīs izmaiņas."</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Nevar sinhronizēt manuāli"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Pašlaik ir atspējota šī vienuma sinhronizācija. Lai mainītu šo iestatījumu, īslaicīgi ieslēdziet fona datu lietojumu un automātisko sinhronizāciju."</string>
    <string name="delete" msgid="8330605554706263775">"Dzēst"</string>
    <string name="select_all" msgid="7898929601615536401">"Atlasīt visu"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Datu lietojums"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobilie dati un Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Autom. sinhronizēt pers. datus"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Autom. sinhronizēt darba datus"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Mainīt ciklu..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Mēneša diena, kad tiks atiestatīts datu izmantošanas cikls:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Šajā periodā lietotnes neizmantoja datus."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Priekšplāns"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Fons"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"ierobežots"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Vai izslēgt mobilos datus?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Iestatīt mobilo datu ierobež."</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Iestatīt 4G datu ierobežojumu"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Iestatīt 2G–3G datu ierobežojumu"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Iest. Wi-Fi datu ierobež."</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">"Mob. dati"</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">"Mob. tīkli"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Neviens"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobilie dati"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G–3G dati"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G dati"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Viesabonēšana"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Priekšplāns:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Fons:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Lietotnes iestatījumi"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Fona dati"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Iespējot mobilo datu izmantošanu fonā"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Lai ierob. fona d. šai liet., vispirms jāiest. mob. d. ierobež."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Vai ierobežot fona datus?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Ja būs pieejami tikai mobilie tīkli, šī funkcija var pārtraukt tādas lietotnes darbību, kurā tiek izmantoti fona dati.\n\nLietotnē pieejamajos iestatījumos varat skatīt citas piemērotas datu lietojuma vadīklas."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Fona datu ierobežošana ir iespējama tikai tad, ja ir iestatīts mobilo datu ierobežojums."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Vai ieslēgt datu automātisko sinhronizāciju?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Vai izslēgt datu automātisko sinhronizāciju?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Tiks saglabāti dati un akumulatora lietojums, bet jums vajadzēs manuāli sinhronizēt katru kontu, lai vāktu jaunāko informāciju. Un jūs nesaņemsiet paziņojumus par atjauninājumiem."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Izmantošanas cikla atiestatīšanas datums"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Katra mēneša datums:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Iestatīt"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Datu lietošanas brīdinājuma iestatīšana"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Datu lietošanas ierobežojuma iestatīšana"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Datu izmantošanas ierobežošana"</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">"brīdinājums"</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">"ierobežojums"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Noņemtās lietotnes"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Noņemtās lietotnes un lietotāji"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Tīkla lietojums"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Maksas"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nosaukums"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Veids"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Servera adrese"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP šifrējums (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Slepenais L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Protokola IPsec identifikators"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Protokola IPsec iepriekš kopīgotā atsl."</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Protokola IPsec lietotāja sertifikāts"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Protokola IPsec CA sertifikāts"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec servera sertifikāts"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Rādīt papildopcijas"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Sistēmas DNS meklēšanas domēni"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"DNS serveri (piem., 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Pārsūtīšanas ceļi (piem., 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Lietotājvārds"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Parole"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Saglabāt konta informāciju"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(netiek lietots)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(neverificēt serveri)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(saņemts no servera)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Šī veida VPN savienojums nevar būt nepārtraukts."</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Vienmēr ieslēgts VPN atbalsta servera adreses, kurās ir tikai cipari."</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Lai būtu vienmēr ieslēgts VPN, ir jābūt norādītam DNS serverim."</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Lai būtu vienmēr ieslēgts VPN, DNS servera adresē ir jābūt tikai cipariem."</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Ievadītā informācija neatbalsta vienmēr ieslēgtu VPN."</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Atcelt"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Nerādīt"</string>
    <string name="vpn_save" msgid="683868204634860888">"Saglabāt"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Savienot"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Aizstāt"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"VPN profila rediģēšana"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Aizmirst"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Savienojuma izveide ar <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Vai pārtraukt šo VPN savienojumu?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Pārtraukt savienojumu"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versija"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Aizmirst VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Vai aizstāt esošo VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Vai iestatīt vienmēr ieslēgtu VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Kad ir ieslēgts šis iestatījums, jums nebūs interneta savienojuma, kamēr nebūs sekmīgi izveidots VPN savienojums."</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Jūsu esošais VPN tiks aizstāts, un jums nebūs interneta savienojuma, kamēr nebūs sekmīgi izveidots VPN savienojums."</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Jūs jau esat izveidojis savienojumu ar vienmēr ieslēgtu VPN. Ja izveidosiet savienojumu ar citu VPN, esošais VPN tiks aizstāts un režīms “vienmēr ieslēgts” tiks izslēgts."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Jau ir izveidots savienojums ar VPN. Izveidojot savienojumu ar citu VPN, esošais tiks aizstāts."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Ieslēgt"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g>: nevar izveidot savienojumu"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Šajā lietotnē netiek atbalstīts vienmēr ieslēgts VPN."</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Pievienot VPN profilu"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Rediģēt profilu"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Dzēst profilu"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Vienmēr ieslēgts VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nav pievienots neviens VPN."</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Nepārtraukts VPN savienojums"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Netiek atbalstīts šajā lietotnē"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Vienmēr ieslēgta"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Nedrošs tīkls"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Bloķēt savienojumus bez VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Vai nepieciešams VPN savienojums?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Nav drošs. Atjauniniet uz IKEv2 VPN."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Izvēlieties VPN profilu, ar kuru izveidot pastāvīgu savienojumu. Tīkla datplūsma tiks atļauta, tikai esot izveidotam savienojumam ar šo VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Nav"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Vienmēr ieslēgtam VPN ir nepieciešama servera un DNS IP adrese."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nav tīkla savienojuma. Lūdzu, vēlāk mēģiniet vēlreiz."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Atvienots no VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Nav"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Trūkst sertifikāta. Rediģējiet profilu."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistēma"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Lietotājs"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Atspējot"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Iespējot"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Atinstalēt"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Uzticamība"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Vai iespējot sistēmas CA sertifikātu?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Vai atspējot sistēmas CA sertifikātu?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Vai neatgriezeniski noņemt lietotāja CA sertifikātu?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"To izmanto:"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Šajā ierakstā ir:"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 lietotāja atslēga"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 lietotāja sertifikāts"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA sertifikāts"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA sertifikāti"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Akreditācijas dati"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Noņemti akreditācijas dati: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nav instalēti lietotāja akreditācijas dati"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Pareizrakstības pārbaudītājs"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Pareizrakstības pārbaudītājs darbam"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Šeit ierakstiet pašreizējo pilna dublējuma paroli"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Šeit ierakstiet jauno pilna dublējuma paroli"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Šeit atkārtoti ierakstiet jauno pilna dublējuma paroli"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Iestatīt dublējuma paroli"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Atcelt"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Papildu sistēmas atjauninājumi"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Iespējams, tīklā veiktās darbības tiek pārraudzītas."</string>
    <string name="done_button" msgid="6269449526248267">"Gatavs"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Sertifikāta pieņemšana vai noņemšana}zero{Sertifikātu pieņemšana vai noņemšana}one{Sertifikātu pieņemšana vai noņemšana}other{Sertifikātu pieņemšana vai noņemšana}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{Organizācija {orgName} jūsu ierīcē instalēja sertificēšanas iestādes sertifikātu . Šis sertifikāts ļauj organizācijai pārraudzīt jūsu ierīcē veiktās darbības tīklā, tostarp e-pasta kontus, lietotnes un drošās vietnes.\n\nLai iegūtu plašāku informāciju par šo sertifikātu, sazinieties ar administratoru.}zero{Organizācija {orgName} jūsu ierīcē instalēja sertificēšanas iestāžu sertifikātus. Šie sertifikāti ļauj organizācijai pārraudzīt jūsu ierīcē veiktās darbības tīklā, tostarp e-pasta kontus, lietotnes un drošās vietnes.\n\nLai iegūtu plašāku informāciju par šiem sertifikātiem, sazinieties ar administratoru.}one{Organizācija {orgName} jūsu ierīcē instalēja sertificēšanas iestāžu sertifikātus. Šie sertifikāti ļauj organizācijai pārraudzīt jūsu ierīcē veiktās darbības tīklā, tostarp e-pasta kontus, lietotnes un drošās vietnes.\n\nLai iegūtu plašāku informāciju par šiem sertifikātiem, sazinieties ar administratoru.}other{Organizācija {orgName} jūsu ierīcē instalēja sertificēšanas iestāžu sertifikātus. Šie sertifikāti ļauj organizācijai pārraudzīt jūsu ierīcē veiktās darbības tīklā, tostarp e-pasta kontus, lietotnes un drošās vietnes.\n\nLai iegūtu plašāku informāciju par šiem sertifikātiem, sazinieties ar administratoru.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{Organizācija {orgName} instalēja sertificēšanas iestādes sertifikātu jūsu darba profilam. Šis sertifikāts ļauj organizācijai pārraudzīt darbības darba tīklā, tostarp e-pasta kontus, lietotnes un drošās vietnes.\n\nLai iegūtu plašāku informāciju par šo sertifikātu, sazinieties ar administratoru.}zero{Organizācija {orgName} instalēja sertificēšanas iestāžu sertifikātus jūsu darba profilam. Šie sertifikāti ļauj organizācijai pārraudzīt darbības darba tīklā, tostarp e-pasta kontus, lietotnes un drošās vietnes.\n\nLai iegūtu plašāku informāciju par šiem sertifikātiem, sazinieties ar administratoru.}one{Organizācija {orgName} instalēja sertificēšanas iestāžu sertifikātus jūsu darba profilam. Šie sertifikāti ļauj organizācijai pārraudzīt darbības darba tīklā, tostarp e-pasta kontus, lietotnes un drošās vietnes.\n\nLai iegūtu plašāku informāciju par šiem sertifikātiem, sazinieties ar administratoru.}other{Organizācija {orgName} instalēja sertificēšanas iestāžu sertifikātus jūsu darba profilam. Šie sertifikāti ļauj organizācijai pārraudzīt darbības darba tīklā, tostarp e-pasta kontus, lietotnes un drošās vietnes.\n\nLai iegūtu plašāku informāciju par šiem sertifikātiem, sazinieties ar administratoru.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Trešā puse spēj pārraudzīt jūsu darbības tīklā, tostarp e-pastu, lietotnes un drošās vietnes.\n\nŠo pārraudzības iespēju nodrošina jūsu ierīcē instalēts sertifikāts."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Pārbaudīt sertifikātu}zero{Pārbaudīt sertifikātus}one{Pārbaudīt sertifikātus}other{Pārbaudīt sertifikātus}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Vairāki lietotāji"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Lietotāji un profili"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Pievienot lietotāju vai profilu"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Ierobežots profils"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nav iestatīts"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Ierobežots profils — nav iestatīts."</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Darba profils — nav iestatīts"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrators"</string>
    <string name="user_you" msgid="3070562015202859996">"Jūs (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Nevar pievienot vairāk lietotāju. Lai pievienotu jaunu lietotāju, noņemiet kādu no pašreizējiem."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Ierobežoti profili nevar pievienot kontus."</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Dzēst šajā ierīcē: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Bloķēšanas ekrāna iestatījumi"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Pievienot lietotājus no bloķēšanas ekrāna"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Dokošanas laikā iespējot administratora piekļuvi"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Vai dzēst jūsu kontu?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Vai dzēst šo lietotāju?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Vai noņemt šo profilu?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Vai noņemt darba profilu?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Visas lietotnes un dati tiks dzēsti."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Ja turpināsiet, visas lietotnes un dati šajā profilā tiks dzēsti."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Visas lietotnes un dati tiks dzēsti."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Jauna lietotāja pievienošana…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Dzēst lietotāju"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Dzēst"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Tiks dzēstas visas šīs sesijas lietotnes un dati."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Noņemt"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Viesis (jūs)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Lietotāji"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Citi lietotāji"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Dzēst viesa darbības"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Dzēst visas viesa lietotnes un darbības, izejot no viesa režīma"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Vai dzēst viesa darbības?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Šīs viesa sesijas darbības un dati tagad tiks dzēsti, un turpmākās viesu darbības tiks dzēstas katru reizi, kad iziesiet no viesa režīma."</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"dzēst, viesis, darbība, noņemt, dati, apmeklētājs, izdzēst"</string>
    <string name="enable_guest_calling" msgid="8300355036005240911">"Atļauja viesim izmantot tālruni"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Ar viesa lietotāju tiks kopīgota zvanu vēsture."</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Ieslēgt tālruņa zvanus un īsziņas"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Iestatīt šo lietotāju kā administratoru"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Dzēst lietotāju"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Vai ieslēgt tālruņa zvanus un īsziņas?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Ar šo lietotāju tiks kopīgota zvanu un īsziņu vēsture."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Vai noņemt administratora atļaujas?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Ja šim lietotājam noņemsiet administratora privilēģijas, jūs vai cits administrators vēlāk varēsiet tās atkal piešķirt."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Ārkārtas informācija"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"<xliff:g id="USER_NAME">%1$s</xliff:g>: informācija un kontaktpersonas"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Atvērt lietotni <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Lietotņu un satura atļaušana"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Lietojumprogrammas ar ierobežojumiem"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Izvērst lietojumprogr. iestat."</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Instalējamo lietotņu izvēle"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Pieejamo lietotņu instalēšana"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Bezkontakta maksājumi"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Noklusējuma maksājumu lietotne"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Lai veiktu maksājumu ar maksājumu lietotni, turiet ierīces mugurpusi pie maksājumu termināļa"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Uzzināt vairāk"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Iestatīt darba liet. kā nokl.?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Maksājuma veikšana ar darba lietotni"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"Jābūt ieslēgtam darba profilam."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"Jums būs jāievada darba profila PIN, kombinācija vai parole, ja tāda ir."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Plašāka informācija"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Maksājiet veikalos, izmantojot savu tālruni"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Noklusējuma maksājumu lietotne"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nav iestatīta"</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">"Noklusējuma maksājumu lietotnes izmantošana"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Noklus. maksājumu lietotnes izmantošana"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Vienmēr"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Izņemot gadījumus, kad ir atvērta kāda cita maksājumu lietotne"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Bezkontakta terminālī maksājiet, izmantojot:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Maksāšana, izmantojot termināli"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Iestatiet maksājumu lietotni. Pēc tam pietuviniet tālruņa aizmuguri jebkuram terminālim, uz kura redzams bezvadu maksājumu simbols."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Labi"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Vairāk…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Iestatiet noklusējuma maksājumu lietotni"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Atjauniniet noklusējuma maksājumu lietotni"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Bezkontakta terminālī maksājiet, izmantojot lietotni <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Bezkontakta terminālī maksājiet, izmantojot lietotni <xliff:g id="APP_0">%1$s</xliff:g>.\n\nTādējādi tā aizstās jūsu pašreizējo noklusējuma maksājumu lietotni (<xliff:g id="APP_1">%2$s</xliff:g>)."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Iestatīt kā noklusējumu"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Atjaunināt"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Darbs"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Ierobežojumi"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Ierobežojumu atcelšana"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Mainīt PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Palīdzība/atsauksmes"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Konts saturam"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Dokuments ar foto"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Ārkārtas apdraudējums"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Brīdinājumi par ārkārtas apdraudējumu dzīvībai un īpašumam."</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Nopietns apdraudējums"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Brīdinājumi par nopietnu apdraudējumu dzīvībai un īpašumam."</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER brīdinājumi"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Saņemt biļetenus par bērnu nolaupīšanas gadījumiem"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Atkārtošana"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Zvanu pārvaldnieka iespējošana"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Atļaut šim pakalpojumam pārvaldīt, kā tiek veikti zvani."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Zvanu pārvaldnieks"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Bezvadu ārkārtas brīdinājumi"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Tīkla operatori"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Piekļuves punktu nosaukumi"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Paplašinātas zvanu iespējas"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G zvani"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Izmantojiet LTE pakalpojumus, lai uzlabotu balss zvanus (ieteicams)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Izmantojiet 4G pakalpojumus, lai uzlabotu balss zvanus (ieteicams)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Izmantojiet 5G balss zvaniem"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Sūtīt kontaktpersonu informāciju operatoram"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Sūtīt jūsu kontaktpersonu tālruņa numurus, lai nodrošinātu uzlabotās funkcijas"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Vai sūtīt kontaktpersonu informāciju operatoram <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Vai sūtīt kontaktpersonu informāciju operatoram?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Jūsu kontaktpersonu tālruņa numuri tiks periodiski nosūtīti mobilo sakaru operatoram <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Šī informācija nosaka, vai jūsu kontaktpersonas var izmantot noteiktas funkcijas, piemēram, videozvanus vai dažas ziņojumapmaiņas funkcijas."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Jūsu kontaktpersonu tālruņa numuri tiks periodiski nosūtīti jūsu mobilo sakaru operatoram.<xliff:g id="EMPTY_LINE">

</xliff:g>Šī informācija nosaka, vai jūsu kontaktpersonas var izmantot noteiktas funkcijas, piemēram, videozvanus vai dažas ziņojumapmaiņas funkcijas."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Ieteicamais tīkla veids"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (ieteicams)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Multiziņas"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Sūtīt un saņemt multiziņas, kad ir izslēgti mobilie dati"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Automātiski pārslēgt mobilos datus"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Izmantot šo tīklu, ja tas nodrošina labāku savienojumu"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Darba SIM karte"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Piekļuve lietotnēm un saturam"</string>
    <string name="user_rename" msgid="8735940847878484249">"PĀRDĒVĒT"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Iestatīt lietotnes ierobežojumus"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Pārvalda lietotne <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Šī lietotne var piekļūt jūsu kontiem."</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Šī lietotne var piekļūt jūsu kontiem. Kontrolē: <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi un mobilais tīkls"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Atļaut Wi‑Fi un mobilā tīkla iestatījumu pārveidošanu"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Atļaut Bluetooth savienošanas pārī un iestatījumu pārveidošanu"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Atrašanās vieta"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Atļaut lietotnēs izmantot informāciju par atrašanās vietu"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Atpakaļ"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Tālāk"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formatēt citā veidā"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM kartes"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobilie dati nav pieejami"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Pieskarieties, lai atlasītu datu SIM karti."</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Vienmēr izmantot šo iestatījumu zvaniem"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Izvēlieties SIM karti mobilajiem datiem"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Atlasiet SIM karti, ko izmantot īsziņām"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Notiek datu SIM kartes mainīšana. Tas var ilgt kādu minūti…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Vai mobilajiem datiem lietot operatoru <xliff:g id="NEW_SIM">%1$s</xliff:g>?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Pārslēdzoties uz operatoru <xliff:g id="NEW_SIM">%1$s</xliff:g>, operatora <xliff:g id="OLD_SIM">%2$s</xliff:g> SIM karte vairs netiks lietota mobilajiem datiem."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Lietot operatoru <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Izmantot zvaniem"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Ievadiet SIM nosaukumu"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM kartes slots: %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranža"</string>
    <string name="color_purple" msgid="6603701972079904843">"Violeta"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"SIM kartes statuss"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"SIM k. statuss (%1$d. SIM kartes slots)"</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">"SIM kartes ir mainītas."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Pieskarieties, lai iestatītu."</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Vaicāt katru reizi"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Nepieciešams veikt atlasi."</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"SIM kartes atlase"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Iestatījumi"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Tīkls un internets"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobilie dati, Wi‑Fi, tīklājs"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi-Fi, tīklājs"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Pievienotās ierīces"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, savienošana pārī"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, braukšanas režīms, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, braukšanas režīms"</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, braukšanas režīms, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, braukšanas režīms"</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">"Nav pieejams, jo tehnoloģija NFC ir izslēgta"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Lai to izmantotu, vispirms instalējiet maksājumu lietotni."</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Pēdējās izmantotās lietotnes, noklusējuma lietotnes"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Piekļuve paziņojumiem nav pieejama darba profila lietotnēm."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Paroles un konti"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Saglabātās paroles, automātiskā aizpilde, sinhronizētie konti"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Noklusējuma lietotnes"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Klonētās lietotnes"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Izveidojiet otru lietotnes instanci, lai varētu vienlaikus izmantot divus kontus."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Šeit norādītas lietotnes, ko var klonēt."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"Klonēto lietotņu skaits: <xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g>, klonēšanai pieejamas: <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g>"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Visu klonēto lietotņu dzēšana"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Neizdevās dzēst visas klonētās lietotnes"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Notiek izveide…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Klonēšana pabeigta"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Notiek <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> klona izveide"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> klons ir izveidots"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Valodas, žesti, laiks, dublēšana"</string>
    <string name="languages_setting_summary" msgid="7963053736715746726">"Sistēmas valodas, lietotņu valodas, runa"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, tīkla savienojums, internets, bezvadu, dati, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Wi‑Fi paziņojumi, WiFi paziņojumi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"datu lietojums"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Izmantot 24 stundu formātu"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Atvērt lietotnē"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Lietojumprogrammas"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"laika josla"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Tērzēšanas galva, sistēma, brīdinājums, logs, dialoglodziņš, displejs, virs citām lietotnēm, vilkt"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Lukturis, lukturītis, apgaismojums"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"Wifi, Wi-Fi, pārslēgt, pārvaldība"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilais, mobilo sakaru operators, bezvadu, dati, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, zvans, zvanīšana"</string>
    <string name="keywords_display" msgid="874738809280751745">"ekrāns, skārienekrāns"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"aptumšot ekrānu, skārienekrāns, akumulators, spilgts"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"aptumšot ekrānu, nakts, tonis, nakts taustiņš, spilgtums, ekrāna krāsa, krāsa, krāsas"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"fons, personalizēt, pielāgot displeju"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"teksta lielums"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projekcija, apraide, ekrāna spoguļošana, ekrāna kopīgošana, spoguļošana, kopīgot ekrānu, ekrāna apraide"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"vieta, disks, cietais disks, ierīces lietojums"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"jaudas lietojums, uzlāde"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"skatīt akumulatora lietojumu, akumulatora lietojums, enerģijas patēriņš"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"akumulatora enerģijas taupīšanas režīms, enerģijas taupīšanas režīms, taupīšanas režīms"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"adaptīvās preferences, adaptīvais akumulators"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"pareizrakstība, vārdnīca, pareizrakstības pārbaude, automātiskā labošana"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"atpazinējs, ievade, runa, runāt, valoda, brīvroku, atpazīšana, aizskarošs, vārds, audio, vēsture, bluetooth austiņas"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"ātrums, valoda, noklusējums, runāt, runāšana, tts, pieejamība, ekrāna lasītājs, neredzīgs"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"pulkstenis, 24 stundu"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"atiestatīt, atjaunot, rūpnīcas iestatījumi"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"notīrīt, dzēst, atjaunot, notīrīšana, noņemt, rūpnīcas iestatījumu atjaunošana"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printeris"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"skaļruņa pīkstiens, skaļrunis, skaļums, izslēgt skaņu, klusums, audio, mūzika, vibrācija, vibrēt"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"netraucēt, pārtraukt, pārtraukums, pauze"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"tuvumā, atrašanās vieta, vēsture, ziņošana, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"konts, pievienot kontu, darba profils, konta pievienošana, noņemt, dzēst"</string>
    <string name="keywords_users" msgid="3497517660077620843">"ierobežojums, ierobežot, ierobežots"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"teksta labojums, labot, skaņa, vibrācija, automātisks, valoda, žests, ieteikt, ieteikums, motīvs, aizvainojošs, vārds, rakstīt, emocijzīmes, starptautisks"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"atiestatīt, preferences, noklusējums"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"lietotnes, lejupielādēt, lietojumprogrammas, sistēma"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"lietotnes, atļaujas, drošība"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"lietotnes, noklusējums"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorēt optimizāciju, snauda, lietotņu gaidstāve"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"spilgts, RGB, sRGB, krāsa, dabisks, standarta"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, izšķirtspēja, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"krāsa, temperatūra, D65, D73, balta, dzeltena, zila, silta, vēsa"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"vilkt, lai atbloķētu, parole, kombinācija, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"ekrāna piespraušana"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"drošības uzdevums darba profilā, darbs, profils"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"darba profils, pārvaldīts profils, apvienot, apvienošana, darbs, profils"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"žesti"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"maks"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"maksāt, pieskarties, maksājumi"</string>
    <string name="keywords_backup" msgid="707735920706667685">"dublēšana, dublēt"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"žests"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"sejas, autorizācija, atbloķēšana, pierakstīšanās"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"seja, autorizācija, autentifikācija, pierakstīšanās, pirksta nospiedums, biometrija"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl versija, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"tīkls, mobilā tīkla statuss, pakalpojuma statuss, signāla stiprums, mobilā tīkla veids, viesabonēšana"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"tīkls, mobilā tīkla statuss, pakalpojuma statuss, signāla stiprums, mobilā tīkla veids, viesabonēšana, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"tīkls, mobilā tīkla statuss, pakalpojuma statuss, signāla stiprums, mobilā tīkla veids, viesabonēšana, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"tīkls, mobilā tīkla statuss, pakalpojuma statuss, signāla stiprums, mobilā tīkla veids, viesabonēšana, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"sērijas numurs, aparatūras versija"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"android drošības ielāpa līmenis, pamatjoslas versija, kodola versija"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"motīvs, gaišs, tumšs, režīms, jutīgums pret gaismu, fotofobija, padarīt tumšāku, aptumšot, tumšais režīms, migrēna"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tumšs motīvs"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"kļūda"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Gaidstāves ekrāns, bloķēšanas ekrāna attēlojums"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"paziņojumi bloķēšanas ekrānā, paziņojumi"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"seja"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"pirksta nospiedums, pievienot pirksta nospiedumu"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"seja, pirksta nospiedums, pievienot pirksta nospiedumu"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"atbloķēšana ar pulksteni, pievienot atbloķēšanu ar pulksteni"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"aptumšots ekrāns, skārienekrāns, akumulators, viedais spilgtums, dinamiskais spilgtums, automātisks spilgtums"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"vieds, ekrāna aptumšošana, miega režīms, akumulators, noildze, uzmanība, displejs, ekrāns, bezdarbība"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, vieds, automātiska pagriešana, automātiski pagriezt, pagriezt, apvērst, pagriešana, portrets, ainava, virziens, vertikāls, horizontāls"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"jaunināt, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, grafiks, paziņojumi, bloķēt, klusums, vibrēt, miega režīms, darbs, izcelt, skaņa, izslēgt skaņu, diena, nedēļas diena, nedēļas nogale, vakars, notikums"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"ekrāns, bloķēšanas laiks, noildze, bloķēšanas ekrāns"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"atmiņa, kešatmiņa, dati, dzēst, notīrīt, atbrīvot, vieta"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"pievienots, ierīce, austiņas, ieauši, skaļrunis, bezvadu, pārī, ieausis, mūzika, multivide"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"fons, motīvs, režģis, pielāgot, personalizēt"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikona, akcents, krāsa, sākuma ekrāns, bloķēšanas ekrāns, saīsne, pulksteņa izmērs"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"noklusējuma, palīgs"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"maksājums, noklusējuma"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"ienākošs paziņojums"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb piesaiste, bluetooth piesaiste, wi-fi tīklājs"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"skārienjutīgs, vibrēt, vibrācija"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptisks, vibrēt, ekrāns, jutīgums"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"skārienjutīgs, vibrācija, tālrunis, zvans, jutīgums, zvanīšana"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"skārienjutīgs, vibrācija, tālrunis, zvans, zvanīt, pakāpeniski"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"vibrācija, vibrēt, jutīgums, paziņojums"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"vibrācija, vibrēt, jutīgums, signāls"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"vibrācija, vibrēt, jutīgums, multivide"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"skārienjutīgs, vibrēt, vibrācija"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"akumulatora enerģijas taupīšanas režīms, fiksēts, saglabāties, enerģijas taupīšanas režīms, akumulators"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"darbību secība, grafiks, akumulatora enerģijas taupīšanas režīms, enerģijas taupīšanas režīms, akumulators, automātiski, procenti"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"VoLTE, paplašinātas zvanu iespējas, 4G zvani"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, paplašinātas zvanu iespējas, 5g zvani"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"pievienot valodu, valodas pievienošana"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"teksta lielums, lieli burti, lieli fonti, liels teksts, vājredzība, padarīt tekstu lielāku, fontu palielinātājs, fontu palielināšana"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"vienmēr ieslēgts ambientajā režīmā, nepārtraukti aktīvs displejs"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, atzīme, lasītājs"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Skaļums, vibrācija, režīms “Netraucēt”"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Multivides skaļums"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Apraides skaļums"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Zvana skaļums"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Signāla skaļums"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Zvanu/paziņojumu sign. skaļums"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Zvana skaļums"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Paziņojumu skaļums"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Zvanītājs klusuma režīmā"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Zvanītājs vibrācijas režīmā"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Paziņojumu skaņa ir izslēgta; ierīce vibrēs, saņemot paziņojumus."</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> — izslēgta skaņa"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Iestatījums nav pieejams, jo skaņas signāls ir izslēgts."</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Tālruņa zvana signāls"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Paziņojuma noklusējuma skaņa"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Lietotnes nodrošinātā skaņa"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Paziņojuma noklusējuma skaņa"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Signāla noklusējuma skaņa"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vispirms vibrēt, tad pakāpeniski zvanīt"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Telpiskais audio"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Numura sast. tastatūras skaņas"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Ekrāna bloķēšanas skaņa"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Uzlādes skaņas un vibrācija"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Dokošanas skaņas"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Pieskāriena un klikšķa skaņas"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Rādīt ikonu, kad ieslēgts vibrācijas režīms"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Dokoto skaļruņu skaņa"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Visas skaņas"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Tikai multivides audio"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Klusums"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Signāli"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrācija"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Ieslēgšanas skaņas"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Subtitri reāllaikā"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automātiskie paraksti multividei"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Tālruņa skaļrunis"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Vadu austiņas"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Audio no saderīga multivides satura kļūst iekļaujošāks"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Izslēgts"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Ieslēgts (<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>)"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Ieslēgts (<xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> un <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>)"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Varat arī ieslēgt funkciju “Telpiskais audio” Bluetooth ierīcēm."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Saistītie ierīces iestatījumi"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Nav}=1{Iestatīts viens grafiks}zero{Iestatīti # grafiki}one{Iestatīts # grafiks}other{Iestatīti # grafiki}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Netraucēt"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Saņemt paziņojumus tikai no svarīgām personām un lietotnēm"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Traucējumu ierobežošana"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Režīma “Netraucēt” ieslēgšana"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Modinātāji un multivides skaņas, kam atļauts pārtraukt"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Grafiki"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Grafiku dzēšana"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Dzēst"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Rediģēt"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Grafiki"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Grafiks"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Grafiks"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Skaņas izslēgšana noteiktā laikā"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Iestatīt režīma “Netraucēt” kārtulas"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Grafiks"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Izmantot grafiku"</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">"Atļaut pārtraukumus ar skaņas signālu"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Bloķēt vizuālos traucējumus"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Vizuālu signālu atļaušana"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Slēpto paziņojumu attēlojuma opcijas"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Kad ir ieslēgts režīms “Netraucēt”"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Nav skaņas signālu no paziņojumiem"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Jūs redzēsiet paziņojumus ekrānā."</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Saņemot paziņojumus, nebūs tālruņa skaņas signāla vai vibrācijas."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Nav vizuālo vai skaņas signālu no paziņojumiem"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Jūs neredzēsiet vai nedzirdēsiet paziņojumus."</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Tālrunī netiks rādīti ne jauni, ne iepriekš saņemti paziņojumi, turklāt netiks atskaņots šiem paziņojumiem atbilstošs signāls un aktivizēta vibrācija. Ņemiet vērā, ka joprojām tiks rādīti ierīces darbībai vai statusam svarīgi paziņojumi.\n\nKad izslēgsiet režīmu “Netraucēt”, varēsiet atrast neskatītos paziņojumus, velkot lejup no ekrāna augšdaļas."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Pielāgoti"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Iespējot pielāgoto iestatījumu"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Noņemt pielāgoto iestatījumu"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Nav skaņas signālu no paziņojumiem"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Daļēji paslēpti"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Nav vizuālo vai skaņas signālu no paziņojumiem"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Pielāgoti ierobežojumi"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Kad ekrāns ir ieslēgts"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Kad ekrāns ir izslēgts"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Izslēgt skaņu un vibrāciju"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Neieslēgt ekrānu"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Nemirgot"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Nerādīt paziņojumus ekrānā"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Nerādīt statusa joslas ikonas ekrāna augšdaļā"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Nerādīt paziņojumu punktus uz lietotņu ikonām"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Neaktivizēt ierīci paziņojumu dēļ"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Nerādīt nolaižamajā panelī"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nekad"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Kad ekrāns ir izslēgts"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Kad ekrāns ir ieslēgts"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Skaņa un vibrācija"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Paziņojumu skaņa, vibrācija un dažas vizuālās zīmes"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Paziņojumu skaņa, vibrācija un vizuālās zīmes"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Nekad netiks paslēpti paziņojumi, kas nepieciešami ierīces pamatdarbībām un statusam."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Nav"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"citas opcijas"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Pievienot"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Ieslēgt"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Ieslēgt tūlīt"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Izslēgt tūlīt"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Režīms “Netraucēt” ir ieslēgts līdz: <xliff:g id="FORMATTED_TIME">%s</xliff:g>."</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Režīms “Netraucēt” būs ieslēgts līdz brīdim, kad to izslēgsiet."</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Režīmu “Netraucēt” automātiski ieslēdza grafiks (<xliff:g id="RULE_NAME">%s</xliff:g>)."</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Režīmu “Netraucēt” automātiski ieslēdza lietotne (<xliff:g id="APP_NAME">%s</xliff:g>)."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Ir ieslēgts režīms “Netraucēt”: <xliff:g id="RULE_NAMES">%s</xliff:g> (ar pielāgotiem iestatījumiem)."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Skatīt pielāgotus iestatījumus"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Tikai prioritārie pārtraukumi"</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">"Ieslēgts / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Ieslēgts"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Vaicāt katru reizi"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Līdz brīdim, kad izslēgsiet"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{Viena stunda}zero{# stundu}one{# stunda}other{# stundas}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{Viena minūte}zero{# minūšu}one{# minūte}other{# minūtes}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Izslēgts}=1{Izslēgts; viens grafiks var tikt ieslēgts automātiski}zero{Izslēgts; # grafiki var tikt ieslēgti automātiski}one{Izslēgts; # grafiks var tikt ieslēgts automātiski}other{Izslēgts; # grafiki var tikt ieslēgti automātiski}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Atļauts pārtraukt režīmā Netraucēt"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Personas"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Lietotnes"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Modinātāja signāli un citi signāli"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Grafiki"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Ilgums, ieslēdzot izvēlnē Ātrie iestatījumi"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Vispārīgi"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Esot ieslēgtam režīmam Netraucēt, tiks izslēgta skaņa un vibrācija, izņemot jūsu atļautajiem vienumiem."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Pielāgoti iestatījumi"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Pārskatīt grafiku"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Labi"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Paziņojumi"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Ilgums"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Ziņojumi, pasākumi un atgādinājumi"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Kad ir ieslēgts režīms Netraucēt, netiks rādīti ziņojumi, atgādinājumi un paziņojumi par pasākumiem, izņemot vienumus, ko iepriekš būsiet atļāvis. Varat pielāgot ziņojumu iestatījumus, lai draugi, ģimene vai citas kontaktpersonas varētu ar jums sazināties."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Gatavs"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Iestatījumi"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Nav vizuālo vai skaņas signālu no paziņojumiem"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Nav skaņas signālu no paziņojumiem"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Jūs neredzēsiet vai nedzirdēsiet paziņojumus. Ir atļauti zvani no kontaktpersonām, kas atzīmētas ar zvaigznīti, un no atkārtotiem zvanītājiem."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(pašreizējais iestatījums)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Vai mainīt režīma “Netraucēt” paziņojumu iestatījumus?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Darba profila signāli"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Personiskā profila signāli"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Izmantot tos pašus skaņas signālus, kas tiek lietoti personīgajā profilā"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Darba tālruņa zvana signāls"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Noklusējuma darba paziņojuma skaņa"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Darba modinātāja signāla noklusējuma skaņa"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Tādi paši signāli kā personiskajā profilā"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Vai lietot personīgā profila signālus?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Apstiprināt"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Jūsu darba profilam un personīgajam profilam tiks izmantoti vieni un tie paši skaņas signāli"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Paziņojumi"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Paziņojumu vēsture un sarunas"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Saruna"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Pārvaldība"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Lietotņu paziņojumi"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Atsevišķu lietotņu paziņojumu pārvaldība"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Vispārīgi"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Darba paziņojumi"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Darba profils"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Adaptīvo paziņojumu prioritāte"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Automātiski iestatīt zemākas prioritātes paziņojumus kā neuzkrītošus"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Adaptīvo paziņojumu ranžēšana"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Automātiski ranžēt paziņojumus pēc atbilstības"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Atsauksmes par adaptīvajiem paziņojumiem"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Norādīt korekcijas, kas veiktas paziņojumiem, un rādīt opciju iesniegt sistēmā atsauksmes"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Svarīguma paziņojumu atiestatīšana"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Atiestatiet svarīguma iestatījumus, ko mainīja lietotājs, un atļaujiet paziņojumu asistentam piešķirt prioritāti."</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Darbību un atbilžu ieteikumi"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Automātiski rādīt ieteicamās darbības un atbildes"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Rādīt jaunākos un atliktos paziņojumus"</string>
    <string name="notification_history" msgid="8663811361243456201">"Paziņojumu vēsture"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Izmantot paziņojumu vēsturi"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Paziņojumu vēsture izslēgta"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Ieslēdziet paziņojumu vēsturi, lai skatītu jaunākos un atliktos paziņojumus."</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Nav nesenu paziņojumu"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Šeit būs redzami jūsu nesenie un atliktie paziņojumi."</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"skatīt paziņojumu iestatījumus"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"atvērt paziņojumu"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Atļaut paziņojumu atlikšanu"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Paziņojuma punkts lietotnes ikonā"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Burbuļi"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Burbuļi"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Sarunas rādīšana burbulī"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Rādīt peldošu ikonu virs lietotnēm"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Vai ieslēgt burbuļus ierīcē?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Ieslēdzot burbuļus šai lietotnei, tiks ieslēgti arī burbuļi jūsu ierīcei.\n\nTas ietekmēs citas lietotnes vai sarunas, kas var tikt attēlotas burbuļos."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Ieslēgt"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Atcelt"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Ieslēgt / sarunas var tikt rādītas kā peldošas ikonas"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Atļaut lietotnēm rādīt burbuļus"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Dažas sarunas tiks rādītas kā peldošas ikonas virs citām lietotnēm"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Visas sarunas var rādīt burbuļos"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Atlasītās sarunas var rādīt burbuļos"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Saturu nevar rādīt burbuļos"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Sarunas"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Burbuļos var attēlot visas sarunas, izņemot"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Izslēgt burbuļus šai sarunai"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Ieslēgt burbuļus šai sarunai"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Vilkt pa labi, lai paslēptu izvēlni, vilkt pa kreisi, lai rādītu izvēlni"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Velciet pa kreisi, lai paslēptu izvēlni, velciet pa labi, lai to parādītu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Paslēpt klusos paziņojumus statusa joslā"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Mirgojošs gaismas signāls"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Konfidencialitāte"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Izlaist bloķēšanas ekrānu"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Pēc atbloķēšanas pāriesiet tieši uz pēdējo izmantoto ekrānu. Paziņojumi netiks rādīti bloķēšanas ekrānā. Lai tos skatītu, būs jāvelk lejup no augšas."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Bloķēšanas ekrāns, izlaist, apiet"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Kad darba profils ir bloķēts"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Bloķēšanas ekrānā rādīt tikai jaunus paziņojumus"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Automātiski noņemt iepriekš skatītos paziņojumus no bloķēšanas ekrāna"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Paziņojumi bloķēšanas ekrānā"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Rādīt sarunas, noklusējuma un klusos paziņojumus"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Rādīt sarunas, noklusējuma un klusos paziņojumus"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Paslēpt klusās sarunas un paziņojumus"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Nerādīt nekādus paziņojumus"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Paziņojumi par sensitīvu saturu"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Rādīt sensitīvu saturu, kad ekrāns ir bloķēts"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Paziņojumi par sensitīvu darba profila saturu"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Rādīt sensitīvu darba profila saturu, kad ekrāns ir bloķēts"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Rādīt visu paziņojumu saturu"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Rādīt sensitīvu saturu tikai, kad atbloķēts"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Nerādīt paziņojumus vispār"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Kā rādīt paziņojumus bloķēšanas ekrānā?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Bloķēšanas ekrāns"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Rādīt visu saturu darba profila paziņojumos"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Paslēpt sensitīvu darba profila saturu"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Kā ierīcē rādīt profila paziņojumus, kad tā ir bloķēta?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profila paziņojumi"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Paziņojumi"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Lietotņu paziņojumi"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Paziņojuma kategorija"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Rīcība"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Sarunas"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Sarunu sadaļa"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Atļaut lietotnei izmantot sarunu sadaļu"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nav saruna"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Noņemt no sarunu sadaļas"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Šī ir saruna"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Pievienošana sarunu sadaļai"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Nav prioritāru sarunu"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioritāra saruna}zero{# prioritāru sarunu}one{# prioritāra saruna}other{# prioritāras sarunas}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioritāras sarunas"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Tiek rādītas sarunu sadaļas augšdaļā un kā peldoši burbuļi"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Tiek rādītas sarunu sadaļas augšdaļā"</string>
    <string name="other_conversations" msgid="551178916855139870">"Sarunas, kas nav prioritāras"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Sarunas, kurās esat veicis izmaiņas"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Jaunākās sarunas"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Notīrīt pēdējās sarunas"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Jaunākās sarunas ir noņemtas"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Saruna noņemta"</string>
    <string name="clear" msgid="5092178335409471100">"Notīrīt"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Šeit būs redzamas prioritārās un mainītās sarunas"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Tiklīdz atzīmēsiet kādu sarunu kā prioritāru vai veiksiet citas izmaiņas sarunās, tās tiks rādītas šeit. \n\nSarunas iestatījumu mainīšana: \nvelciet lejup no ekrāna augšdaļas, lai atvērtu nolaižamo paneli, pēc tam pieskarieties konkrētai sarunai un turiet to."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimizēt"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Uznirst ekrānā"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Klusums"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Noklusējums"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Atļaut pārtraukšanu"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Ļaut lietotnei atskaņot signālu, aktivizēt vibrozvanu un/vai parādīt paziņojumus ekrānā"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritārs"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Parādās sarunu sadaļas augšdaļā un kā peldošs burbulis, kā arī bloķēšanas ekrānā tiek rādīts profila attēls"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"Lietotnē <xliff:g id="APP_NAME">%1$s</xliff:g> netiek atbalstīta lielākā daļa sarunu funkciju. Jūs nevarat iestatīt sarunu kā prioritāru, kā arī sarunas netiks rādītas kā peldoši burbuļi."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Nolaižamajā panelī sakļaut paziņojumus vienā rindiņā"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Nav skaņas signāla vai vibrācijas"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Nav skaņas signāla vai vibrācijas, kā arī atrodas tālāk sarunu sadaļā"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Atkarībā no ierīces iestatījumiem var zvanīt vai vibrēt"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Rādīt paziņojumus reklāmkarogā ekrāna augšdaļā, ja ierīce ir atbloķēta"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Visi lietotnes <xliff:g id="APP_NAME">%1$s</xliff:g> paziņojumi"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Visi lietotnes <xliff:g id="APP_NAME">%1$s</xliff:g> paziņojumi"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Aptuveni # paziņojums dienā}zero{Aptuveni # paziņojumu dienā}one{Aptuveni # paziņojums dienā}other{Aptuveni # paziņojumi dienā}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Aptuveni # paziņojums nedēļā}zero{Aptuveni # paziņojumu nedēļā}one{Aptuveni # paziņojums nedēļā}other{Aptuveni # paziņojumi nedēļā}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nekad"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Ierīces un lietotņu paziņojumi"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Pārvaldīt, kuras lietotnes un ierīces var lasīt paziņojumus."</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Piekļuve darba profila paziņojumiem ir bloķēta"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Uzlabotie paziņojumi"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Saņemiet darbību un atbilžu ieteikumus un citu saturu"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Nav"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Nevienā instalētajā lietotnē nav pieprasīta piekļuve paziņojumiem."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Atļaut piekļuvi paziņojumiem"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Android adaptīvie paziņojumi ir aizstāti ar funkciju “Uzlabotie paziņojumi” operētājsistēmā Android 12. Šī funkcija parāda ieteiktās darbības un atbildes, kā arī kārto jūsu paziņojumus. \n\nFunkcija “Uzlabotie paziņojumi” var piekļūt paziņojumu saturam, tostarp personas informācijai, piemēram, kontaktpersonu vārdiem un ziņojumiem. Šī funkcija var arī noraidīt paziņojumus vai atbildēt uz tiem, piemēram, atbildēt uz tālruņa zvaniem vai pārvaldīt funkciju “Netraucēt”."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Vai atļaut pakalpojumam <xliff:g id="SERVICE">%1$s</xliff:g> piekļūt paziņojumiem?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Lietotne <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> varēs lasīt visus paziņojumus, tostarp personas informāciju, piemēram, kontaktpersonu vārdus, fotoattēlus un jūsu saņemtos ziņojumus. Šī lietotne varēs arī atlikt vai noraidīt paziņojumus vai izmantot paziņojumos esošās pogas darbību veikšanai, tostarp atbildēt uz tālruņa zvaniem. \n\nLietotne varēs arī ieslēgt vai izslēgt režīmu “Netraucēt” un mainīt saistītos iestatījumus."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Lietotne <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> varēs paveikt tālāk norādītās darbības."</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Paziņojumu lasīšana"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Tā var lasīt jūsu paziņojumus, tostarp personas informāciju, piemēram, kontaktpersonu informāciju, ziņojumus un fotoattēlus."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Atbildēšana uz ziņojumiem"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Tā var atbildēt uz ziņojumiem un izmantot paziņojumos esošās pogas darbību veikšanai, tostarp atlikt vai noraidīt paziņojumus un atbildēt uz zvaniem."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Iestatījumu maiņa"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Tā var ieslēgt vai izslēgt režīmu “Netraucēt” un mainīt saistītos iestatījumus."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Izslēdzot paziņojumu piekļuvi lietotnei <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, iespējams, tiks izslēgta arī piekļuve režīmam “Netraucēt”."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Izslēgt"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Atcelt"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Reāllaika paziņojumi"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Aktīvi paziņojumi par pašlaik izmantotajām lietotnēm, navigāciju, tālruņa zvaniem u.tml."</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Sarunas"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"Īsziņas un citi paziņojumi"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Paziņojumi"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Atkarībā no iestatījumiem var zvanīt vai vibrēt."</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Klusums"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Saņemot šos paziņojumus, nekad netiek atskaņoti signāli un izmantota vibrācija"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Atļauts"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nav atļauts"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Skatīt visas lietotnes"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Varat mainīt iestatījumus katrai lietotnei, kas sūta paziņojumus."</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Ierīcē parādītās lietotnes"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Šajā lietotnē netiek atbalstīti izvērsti iestatījumi."</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Citi iestatījumi"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Lietotnē ir pieejami citi iestatījumi"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"VR palīga pakalpojumi"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nevienai instalētajai lietotnei nav pieprasīta palaišana kā VR palīga pakalpojumam."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Vai atļaut VR pakalpojumam piekļūt pakalpojumam <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"VR klausītāju <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> varēs palaist, kad izmantosiet lietojumprogrammas virtuālās realitātes režīmā."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Preferences virtuālās realitātes režīmā"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Samazināt aizmiglojumu (ieteicams)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Samazināt ņirbēšanu"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Attēls attēlā"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Nevienā no instalētajām lietotnēm netiek atbalstīts režīms “Attēls attēlā”"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"PIP, attēls attēlā"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Attēls attēlā"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Atļaut attēlu attēlā"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Atļaut šai lietotnei izveidot logu ar attēlu attēlā, kad lietotne ir atvērta vai pēc tās aizvēršanas (piemēram, lai turpinātu skatīties video). Šis logs tiek rādīts pāri citām izmantotajām lietotnēm."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Saistītās darba un privātās lietotnes"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Saistītas"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Nav saistītas"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Nav pievienotu lietotņu"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"vairāku profilu saistītā lietotne lietotnes darba un personīgā"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Saistītas"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Saistīt šīs lietotnes"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Saistītās lietotnes koplieto atļaujas un var piekļūt viena otras datiem."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Saistiet tikai uzticamas lietotnes, jo jūsu personas dati var tikt atklāti IT administratoram."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Varat jebkurā laikā atsaistīt lietotnes savas ierīces konfidencialitātes iestatījumos."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Vai uzticat darba lietotnei <xliff:g id="NAME">%1$s</xliff:g> savus personīgos datus?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Saistiet tikai uzticamas lietotnes, jo jūsu personas dati var tikt atklāti IT administratoram."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Lietotņu dati"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Šī lietotne var piekļūt datiem jūsu personīgajā lietotnē <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Atļaujas"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Šī lietotne var izmantot jūsu personīgās lietotnes <xliff:g id="NAME">%1$s</xliff:g> atļaujas, piemēram, piekļuvi atrašanās vietai, krātuvei vai kontaktpersonām."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nav saistīta neviena lietotne"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{Pievienota # lietotne.}zero{Pievienotas # lietotnes.}one{Pievienota # lietotne.}other{Pievienotas # lietotnes.}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Lai saistītu šīs lietotnes, instalējiet lietotni <xliff:g id="NAME">%1$s</xliff:g> savā darba profilā."</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Lai saistītu šīs lietotnes, instalējiet lietotni <xliff:g id="NAME">%1$s</xliff:g> savā personīgajā profilā."</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Pieskarieties, lai iegūtu lietotni"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Piekļuve pie “Netraucēt”"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Atļaut režīmu “Netraucēt”"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Nevienā instalētajā lietotnē nav pieprasīta piekļuve režīmam “Netraucēt”."</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Jūs neesat atļāvis paziņojumus no šīs lietotnes"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Pēc jūsu pieprasījuma Android neatļauj šīs kategorijas paziņojumu rādīšanu šajā ierīcē."</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Pēc jūsu pieprasījuma Android neatļauj šīs grupas paziņojumu rādīšanu šajā ierīcē."</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"No šīs lietotnes netiek sūtīti paziņojumi"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorijas"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Cits"</string>
    <string name="no_channels" msgid="4716199078612071915">"Šai lietotnei nav neviena paziņojuma."</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Lietotnes papildu iestatījumi"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{Izdzēsta # kategorija.}zero{Izdzēstas # kategorijas.}one{Izdzēsta # kategorija.}other{Izdzēstas # kategorijas.}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Bloķēt visus"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Nekad nerādīt šos paziņojumus"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Rādīt paziņojumus"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nekad nerādīt paziņojumus panelī vai perifērijas ierīcēs"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Atļauja rādīt pilnekrāna paziņojumus"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Atļaujiet rādīt paziņojumus pilnekrāna režīmā, kad ierīce ir bloķēta."</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Atļaut paziņojuma punktu"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Rādīt paziņojuma punktu"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Ignorēt režīmu “Netraucēt”"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Ļaut šiem paziņojumiem pārtraukt arī turpmāk, ja ir iestatīts režīms “Netraucēt”"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Bloķēšanas ekrāns"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Gatavs"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Mirgojošs gaismas signāls"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibrācija"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Skaņas signāls"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritārs"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Grafika nosaukums"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Ievadīt grafika nosaukumu"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Grafika nosaukums jau tiek izmantots"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Pievienot vēl"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Pievienot notikumu grafiku"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Pievienot laika grafiku"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Grafika veida izvēle"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Vai dzēst kārtulu “<xliff:g id="RULE">%1$s</xliff:g>”?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Dzēst"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Šos iestatījumus pašlaik nevar mainīt. Lietotnē (<xliff:g id="APP_NAME">%1$s</xliff:g>) ir automātiski ieslēgts režīms “Netraucēt” ar pielāgotu darbību."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Šos iestatījumus pašlaik nevar mainīt. Lietotnē ir automātiski ieslēgts režīms “Netraucēt” ar pielāgotu darbību."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Šos iestatījumus tagad nevar mainīt. Režīms “Netraucēt” tika manuāli ieslēgts ar pielāgotu darbību."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Laiks"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Notikums"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Šāda kalendāra pasākumu laikā:"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Jebkurš kalendārs"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Ja atbilde ir:"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Jā, Varbūt vai Nav atbildes"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Jā vai Varbūt"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Jā"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Kārtula nav atrasta."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Ieslēgts/<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">"Dienas"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Nav"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Signāls var ignorēt beigu laiku"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Grafiks tiek izslēgts, kad tiek atskaņots signāls"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Režīma “Netraucēt” darbība"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Izmantot noklusējuma iestatījumus"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Izveidot pielāgotus iestatījumus šim grafikam"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Grafikam <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">"Sarunas"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Visas sarunas"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioritāras sarunas"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioritārās sarunas"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Nav"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Nav}=1{Viena saruna}zero{# sarunu}one{# saruna}other{# sarunas}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Kas var pārtraukt"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Pat ja ziņojumapmaiņas vai zvanu lietotnes nevar nosūtīt jums paziņojumus, jūsu šeit izvēlētās personas joprojām var sazināties ar jums, izmantojot šīs lietotnes."</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Zvani"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Zvani"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"zvani"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Zvani, kas var pārtraukt"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Lai dzirdētu atļauto zvanu signālus, pārbaudiet, vai ierīcē ir iestatīts zvanīšanas režīms"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Grafikam <xliff:g id="SCHEDULE_NAME">%1$s</xliff:g> ienākošie zvani ir bloķēti. Varat pielāgot iestatījumus, lai draugi, ģimene vai citas kontaktpersonas varētu ar jums sazināties."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Ar zvaigznīti atzīmētas kontaktpersonas"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Nav}=1{{contact_1}}=2{{contact_1} un {contact_2}}=3{{contact_1}, {contact_2} un {contact_3}}zero{{contact_1}, {contact_2} un vēl # kontaktpersonu}one{{contact_1}, {contact_2} un vēl # kontaktpersona}other{{contact_1}, {contact_2} un vēl # kontaktpersonas}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Nav vārda)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Ziņojumi"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"ziņojumi"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Ziņojumi"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Ziņojumi, kas var pārtraukt"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Lai dzirdētu atļauto ziņojumu signālus, pārbaudiet, vai ierīcē ir iestatīts zvanīšanas režīms"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Grafikam “<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>” ienākošie ziņojumi ir bloķēti. Varat pielāgot iestatījumus, lai draugi, ģimene vai citas kontaktpersonas varētu ar jums sazināties."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Jūs saņemsiet visus ziņojumus"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Jūs saņemsiet visus zvanus"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Nav}=1{Viena kontaktpersona}zero{# kontaktpersonu}one{# kontaktpersona}other{# kontaktpersonas}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Ikviens"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontaktpersonas"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Ar zvaigznīti atzīmētas kontaktpersonas"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Neviens"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Neviens"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Signāli"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"No taimeriem, modinātājiem, drošības sistēmām un citām lietotnēm"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"signāli"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Signāli"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Multivides skaņas"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Skaņas no videoklipiem, spēlēm un cita multivides satura"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"multivide"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Multivide"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Pieskāriena skaņas"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Skaņas no tastatūras un citām pogām"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"pieskāriena skaņas"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Pieskāriena skaņas"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Atgādinājumi"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"No uzdevumiem un atgādinājumiem"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"atgādinājumi"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Atgādinājumi"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Kalendāra pasākumi"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"No gaidāmajiem kalendāra pasākumiem"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"pasākumi"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Pasākumi"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Atļaut lietotnēm ignorēt režīmu “Netraucēt”"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Lietotnes, kas var pārtraukt"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Citu lietotņu atlase"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nav atlasīta neviena lietotne"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Nevienai lietotnei nav atļauts pārtraukt"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Pievienot lietotnes"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Visi paziņojumi"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Daži paziņojumi"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Atlasītie lietotāji joprojām var sazināties ar jums, pat ja neatļaujat lietotnēm traucēt jūs."</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Nevienai lietotnei nav atļauts pārtraukt}=1{Lietotnei {app_1} ir atļauts pārtraukt}=2{Lietotnei {app_1} un {app_2} ir atļauts pārtraukt}=3{Lietotnei {app_1}, {app_2} un {app_3} ir atļauts pārtraukt}zero{Lietotnei {app_1} un {app_2} un vēl # lietotnēm ir atļauts pārtraukt}one{Lietotnei {app_1} un {app_2} un vēl # lietotnei ir atļauts pārtraukt}other{Lietotnei {app_1} un {app_2} un vēl # lietotnēm ir atļauts pārtraukt}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Lietotnes"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Paziņojumi, kas var traucēt"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Atļaut visus paziņojumus"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nekam nav atļauts pārtraukt}=1{Šādiem signāliem ir atļauts pārtraukt: {sound_category_1}}=2{Šādiem signāliem ir atļauts pārtraukt: {sound_category_1} un {sound_category_2}}=3{Šādiem signāliem ir atļauts pārtraukt: {sound_category_1}, {sound_category_2} un {sound_category_3}}zero{Šādiem signāliem ir atļauts pārtraukt: {sound_category_1}, {sound_category_2} un vēl #}one{Šādiem signāliem ir atļauts pārtraukt: {sound_category_1}, {sound_category_2} un vēl #}other{Šādiem signāliem ir atļauts pārtraukt: {sound_category_1}, {sound_category_2} un vēl #}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nekam nav atļauts pārtraukt"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Nevienai personai nav atļauts pārtraukt"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Dažām personām ir atļauts pārtraukt"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Visām personām ir atļauts pārtraukt"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Atkārtoti zvani"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Atkārtotu zvanu atļaušana"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"ikviens"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontaktpersonas"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"ar zvaigznīti atzīmētas kontaktpersonas"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"atkārtotie zvanītāji"</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> un <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Ja tā pati persona <xliff:g id="MINUTES">%d</xliff:g> min laikā zvana vēlreiz"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Sākuma laiks"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Beigu laiks"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> nākamajā dienā"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Pāriet uz režīmu “Tikai signāli” uz nenoteiktu laiku"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Vienu minūti pāriet uz režīmu “Tikai signāli” (līdz: {time})}zero{# minūtes pāriet uz režīmu “Tikai signāli” (līdz: {time})}one{# minūti pāriet uz režīmu “Tikai signāli” (līdz: {time})}other{# minūtes pāriet uz režīmu “Tikai signāli” (līdz: {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Vienu stundu pāriet uz režīmu “Tikai signāli” (līdz: {time})}zero{# stundas pāriet uz režīmu “Tikai signāli” (līdz: {time})}one{# stundu pāriet uz režīmu “Tikai signāli” (līdz: {time})}other{# stundas pāriet uz režīmu “Tikai signāli” (līdz: {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Pāriet uz režīmu “Tikai signāli” līdz plkst. <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Pāriet uz “Vienmēr pārtraukt”"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Brīdinājums"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Aizvērt"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Sūtīt atsauksmes par šo ierīci"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Ievadiet administratora PIN"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Ieslēgts"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Izslēgts"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Ieslēgti"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Izslēgti"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Ieslēgta"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Izslēgta"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Lietotņu piespraušana"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Izmantojot lietotņu piespraušanas funkciju, varat iestatīt, lai pašreizējā lietotne tiktu rādīta, līdz to atspraudīsiet. Šo funkciju var izmantot, piemēram, lai ļautu uzticamam draugam spēlēt noteiktu spēli."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Kamēr lietotne ir piesprausta, tā var atvērt citas lietotnes, turklāt var būt iespējams piekļūt personas datiem. \n\nLai izmantotu lietotņu piespraušanu, veiciet tālāk norādītās darbības. 	\n1. Ieslēdziet lietotņu piespraušanu. 	\n2. Atveriet sadaļu Pārskats. 	\n3. Ekrāna augšdaļā pieskarieties konkrētas lietotnes ikonai un pēc tam — vienumam Piespraust."</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Kamēr lietotne ir piesprausta, tā var atvērt citas lietotnes, turklāt var būt iespējams piekļūt personas datiem. \n\nJa vēlaties droši kopīgot savu ierīci ar citu personu, lietotņu piespraušanas vietā varat izmantot vieslietotāja profilu. \n\nLai izmantotu lietotņu piespraušanu, veiciet tālāk norādītās darbības. 	\n1. Ieslēdziet lietotņu piespraušanu. 	\n2. Atveriet sadaļu Pārskats. 	\n3. Ekrāna augšdaļā pieskarieties konkrētas lietotnes ikonai un pēc tam — vienumam Piespraust."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Kamēr lietotne ir piesprausta, pastāv šādi riski. \n\n•	 Var būt iespējams piekļūt personas datiem \n		(piemēram, kontaktpersonu sarakstam un e-pasta ziņojumu saturam). \n•	 Piespraustā lietotne var atvērt citas lietotnes. \n\nIzmantojiet lietotņu piespraušanu tikai kopā ar uzticamām personām."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Pirms atspraušanas pieprasīt atbloķēšanas kombināciju"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Prasīt PIN kodu pirms atspraušanas"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Pirms atspraušanas pieprasīt paroli"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Bloķēt ierīci, kad tiek veikta atspraušana"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"SIM kartes dzēšanas apstiprinājums"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Pirms eSIM kartes dzēšanas apstipriniet savu identitāti."</string>
    <string name="memtag_title" msgid="5096176296797727201">"Uzlab. atmiņas aizsardz. beta v."</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Uzlabotā atmiņas aizsardzība"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Šī beta funkcija palīdz aizsargāt jūsu ierīci no kļūdām, kas var apdraudēt drošību."</string>
    <string name="memtag_on" msgid="824938319141503923">"Ieslēgta"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Izslēgta"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Tiks ieslēgta pēc restartēšanas"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Tiks izslēgta pēc restartēšanas"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Pašlaik nav pieejama jūsu ierīcei"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Vienmēr ieslēgta jūsu ierīcei"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Lai ieslēgtu vai izslēgtu uzlaboto atmiņas aizsardzību, ir nepieciešams restartēt ierīci. Kad aizsardzība ir ieslēgta, ierīce var darboties lēnāk."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Vai restartēt ierīci?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Jums būs jārestartē ierīce, lai ieslēgtu uzlaboto atmiņas aizsardzību."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Jums būs jārestartē ierīce, lai izslēgtu uzlaboto atmiņas aizsardzību."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Restartēt"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Vēlāk"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Uzziniet vairāk par uzlaboto atmiņas aizsardzību."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Šis darba profils tiek pārvaldīts, izmantojot:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Pārvalda <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Atvērt pēc noklusējuma"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Atbalstīto saišu atvēršana"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Atļaut tīmekļa saišu atvēršanu šajā lietotnē"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Saites, ko atvērt šajā lietotnē"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Atbalstītās saites"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Citas noklusējuma preferences"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Pievienot saiti"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Lietotne var verificēt saites, ko drīkstēs automātiski atvērt attiecīgajā lietotnē."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# verificēta saite}zero{# verificētu saišu}one{# verificēta saite}other{# verificētas saites}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Šī saite ir verificēta un automātiski tiek atvērta šajā lietotnē.}zero{Šīs saites ir verificētas un automātiski tiek atvērtas šajā lietotnē.}one{Šīs saites ir verificētas un automātiski tiek atvērtas šajā lietotnē.}other{Šīs saites ir verificētas un automātiski tiek atvērtas šajā lietotnē.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"Labi"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Rādīt verificēto saišu sarakstu"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Tiek pārbaudīts, vai ir citas atbalstītas saites…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Atcelt"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# atbalstīta saite}zero{# atbalstītu saišu}one{# atbalstīta saite}other{# atbalstītas saites}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Pievienot"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Tiek atvērta lietotnē <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"Izmantots: <xliff:g id="SIZE">%1$s</xliff:g> no <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"iekšējā atmiņa"</string>
    <string name="storage_type_external" msgid="125078274000280821">"ārējā krātuve"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"Izmantoti <xliff:g id="SIZE">%1$s</xliff:g> kopš: <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Izmantotā krātuve"</string>
    <string name="change" msgid="273206077375322595">"Mainīt"</string>
    <string name="change_storage" msgid="8773820275624113401">"Krātuves mainīšana"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Paziņojumi"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Ieslēgti"</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">"Izslēgti"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategorija tika izslēgta}zero{# kategorijas tika izslēgtas}one{# kategorija tika izslēgta}other{# kategorijas tika izslēgtas}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# papildu atļauja}zero{# papildu atļauju}one{# papildu atļauja}other{# papildu atļaujas}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nav piešķirta neviena atļauja."</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nav pieprasīta neviena atļauja."</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Pārvaldiet lietotņu piekļuvi jūsu datiem"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Konfidencialitātes informācijas panelis"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Skatiet, kuras lietotnes nesen izmantoja atļaujas"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Neizmantotās lietotnes"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# neizmantota lietotne}zero{# neizmantotu lietotņu}one{# neizmantota lietotne}other{# neizmantotas lietotnes}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Neizmantotās lietotnes iestatījumi"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Apturēt lietotni, ja tā netiek izmantota"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Atsaukt atļaujas, dzēst pagaidu failus un izslēgt paziņojumus"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Visas lietotnes"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Instalētās lietotnes"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Tūlītējās lietotnes"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Izslēgti"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Papildu"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Atļauju pārvaldnieks"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Atjauninājumi atrašanās vietas datu kopīgošanā"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Pārskatiet lietotnes, kurās ir mainīti atrašanās vietas datu kopīgošanas veidi."</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Pieskarieties, lai aktivizētu"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Lai aktivizētu ierīci, veiciet dubultskārienu jebkurā ekrāna vietā."</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Palaišanas saites"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Neatvērt atbalstītās saites"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Atvērt: <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Atvērt <xliff:g id="DOMAIN">%s</xliff:g> un citus vietrāžus URL"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Atļaut lietotnei atvērt atbalstītas saites"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Vaicāt katru reizi"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Neatļaut lietotnei atvērt saites"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Izmantojot lietotni, var tikt atvērta # saite}zero{Izmantojot lietotni, var tikt atvērtas # saites}one{Izmantojot lietotni, var tikt atvērta # saite}other{Izmantojot lietotni, var tikt atvērtas # saites}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Izmantojot lietotni, var tikt atvērtas tālāk norādītās saites:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Palīgs un balss ievade"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digitālā asistenta lietotne"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Noklusēj. digitālais asistents"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Piekrītu"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Pārlūka lietotne"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Tālruņa lietotne"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistēma)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Lietotņu krātuve"</string>
    <string name="usage_access" msgid="5487993885373893282">"Piekļuve lietojuma datiem"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Atļaut piekļuvi lietojuma datiem"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Izmantošanas ilgums"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Piekļuve lietojuma datiem ļauj lietotnei izsekot, kādas lietotnes un cik bieži izmantojat, kā arī iegūt informāciju par jūsu mobilo sakaru operatoru, valodas iestatījumiem u.c."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Atmiņa"</string>
    <string name="always_running" msgid="9012705720688200252">"Darbojas pastāvīgi (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Darbojas dažreiz (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Reti darbojas (<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">"Akumulatora optimizācija"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Netiek optimizēts"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Netiek optimizēts"</string>
    <string name="high_power_off" msgid="317000444619279018">"Akumulatora darbība tiek optimizēta"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Akumulatora darbības optimizācija nav pieejama"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Vai atļaut lietotnei vienmēr darboties fonā?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Atļaujot lietotnei <xliff:g id="APP_NAME">%1$s</xliff:g> vienmēr darboties fonā, var tikt samazināts akumulatora darbības ilgums. \n\nVēlāk varat veikt izmaiņas sadaļā Iestatījumi &gt; Lietotnes."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> lietojums kopš pēdējās pilnās uzlādes"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> lietojums pēdējo 24 stundu laikā"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Kopš pēdējās pilnās uzlādes akumulatora jauda nav izmantota"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Vai kopīgot kļūdas pārskatu?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Jūsu IT administrators pieprasīja kļūdas pārskatu, lai palīdzētu novērst problēmu šajā ierīcē. Var tikt kopīgotas lietotnes un dati."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Jūsu IT administrators pieprasīja kļūdas pārskatu, lai palīdzētu novērst problēmu šajā ierīcē. Var tikt kopīgotas lietotnes un dati, un jūsu ierīces darbība var īslaicīgi palēnināties."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Šis kļūdas pārskats tiek kopīgots ar jūsu IT administratoru. Lai saņemtu plašāku informāciju, sazinieties ar savu IT administratoru."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Kopīgot"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Noraidīt"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Dati netiek pārsūtīti"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Pievienotās ierīces uzlāde"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Failu pārsūtīšana"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Tīmekļa kamera"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konvertēt videoklipus AVC formātā"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videoklipus varēs atskaņot daudzos citos multivides atskaņotājos, taču video kvalitāte var būt zemāka"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB piesaiste"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"USB savienojuma lietošana"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Noklusējuma USB konfigurācija"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Šie iestatījumi tiks piemēroti, kad būs pievienota cita ierīce un jūsu tālrunis būs atbloķēts. Izveidojiet savienojumu tikai ar uzticamām ierīcēm."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Barošanas iespējas"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Failu pārsūtīšanas opcijas"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB preferences"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB, ko pārvalda:"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Pievienotā ierīce"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Šī ierīce"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Notiek pārslēgšana…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Pārslēgšana neizdevās"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Šīs ierīces uzlāde"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Pievienotās ierīces uzlāde"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Failu pārsūtīšana"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB piesaiste"</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">"Tīmekļa kamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Failu pārsūtīšana un ierīces uzlāde"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB piesaiste un ierīces uzlāde"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP un ierīces uzlāde"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI režīms un ierīces uzlāde"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Tīmekļa kamera un ierīces uzlāde"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Fona pārbaude"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Izmantot ekrānā redzamo tekstu"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Atļaut palīga lietotnei piekļūt ekrānā redzamajam tekstam"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Izmantot ekrānuzņēmumu"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Atļaut palīga lietotnei piekļūt ekrānā redzamajam attēlam"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Ekrāna mirgošana"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Kad palīga lietotne piekļūst tekstam no ekrāna vai ekrānuzņēmuma, jāmirgo ekrāna malām"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Izmantojot palīga lietotnes, varat iegūt palīdzību, pamatojoties uz ekrānā redzamo informāciju. Dažās lietotnēs tiek atbalstītas gan palaišanas programmas, gan balss ievades pakalpojumi, lai nodrošinātu integrētu palīdzību."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Vidējs atmiņas lietojums"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimāls atmiņas lietojums"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Atmiņas lietojums"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Lietotņu izmantošana"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detalizēta informācija"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Vidējais atmiņas lietojums pēdējo 3 stundu laikā: <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Pēdējās 3 stundās netika lietota atmiņa"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Kārtot pēc vidējā lietojuma"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Kārtot pēc maksimālā lietojuma"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Veiktspēja"</string>
    <string name="total_memory" msgid="5244174393008910567">"Kopējā atmiņa"</string>
    <string name="average_used" msgid="690235917394070169">"Vidējais lietojums (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Brīvs"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Lietotņu izmantotais atmiņas apjoms"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 lietotne izmantoja atmiņu šādā laika periodā: pēdējā(-ais) {time}}zero{# lietotnes izmantoja atmiņu šādā laika periodā: pēdējā(-ais) {time}}one{# lietotne izmantoja atmiņu šādā laika periodā: pēdējā(-ais) {time}}other{# lietotnes izmantoja atmiņu šādā laika periodā: pēdējā(-ais) {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Biežums"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimālais lietojums"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Dati nav izmantoti"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Vai piešķirt lietotnei <xliff:g id="APP">%1$s</xliff:g> piekļuvi režīmam “Netraucēt”?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Lietotne varēs ieslēgt un izslēgt režīmu “Netraucēt” un mainīt ar to saistītos iestatījumus."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Jābūt ieslēgtam, jo ir ieslēgta piekļuve paziņojumiem"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Vai atsaukt piekļuvi kārtulām “Netraucēt” no lietotnes <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Visas šajā lietotnē izveidotās kārtulas “Netraucēt” tiks noņemtas."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Neoptimizēt"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizēt"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Iespējams, akumulators tiks ātrāk izlādēts. Turpmāk lietotne varēs patērēta akumulatora enerģiju fonā."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Ieteicams akumulatora darbības laika paildzināšanai"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Nav"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Izslēdzot piekļuvi šīs lietotnes lietojuma datiem, administratoram netiek liegta iespēja izsekot datu lietojumu lietotnēm jūsu darba profilā."</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Rādīt pāri citām lietotnēm"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Rādīt pāri citām lietotnēm"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Atļaut rādīt pāri citām lietotnēm"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Atļaut rādīt šo lietotni pāri citām jūsu izmantotajām lietotnēm. Šī lietotne varēs redzēt, kur pieskaraties, vai mainīt ekrānā redzamo saturu."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Piekļuve visiem failiem"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Atļaut piekļuvi visu failu pārvaldībai"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Atļaujiet šai lietotnei lasīt, pārveidot un dzēst visus failus šajā ierīcē vai pievienotajās atmiņas ierīcēs. Ja piešķirsiet atļauju, lietotne varēs piekļūt failiem, jums par to nezinot."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Var piekļūt visiem failiem"</string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Pilnekrāna paziņojumi"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Atļaut šīs lietotnes pilnekrāna paziņojumus"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Atļaujiet šai lietotnei rādīt paziņojumus pilnekrāna režīmā, kad ierīce ir bloķēta. Lietotnes var šādi izcelt signālus, ienākošos zvanus vai citus svarīgus paziņojumus."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Multivides satura pārvaldības lietotnes"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Atļaut lietotnei pārvaldīt multivides failus"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Ja piešķirsiet atļauju, šī lietotne varēs bez iepriekšēja brīdinājuma pārveidot vai dzēst multivides failus, kas izveidoti citās lietotnēs. Lietotnei ir nepieciešama atļauja piekļūt failiem un multivides saturam."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Multivide, fails, pārvaldība, pārvaldnieks, pārvaldīt, rediģēt, redaktors, lietotne, lietojumprogramma, programma"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtuālā realitāte klausītājs stereo palīgs pakalpojums"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Rādīt pāri citām lietotnēm"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Lietotnes ar atļauju"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Atļauts"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nav atļauts"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instalēt lietotnes nezināmi avoti"</string>
    <string name="write_settings" msgid="6864794401614425894">"Iestatījumu pārveidošana"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"rakstīt, pārveidot sistēmas iestatījumus"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Var instalēt citas lietotnes"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Var pārveidot sistēmas iestatījumus"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Var pārveidot sistēmas iestatījumus"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Iestatījumu pārveidošana"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Atļaut pārveidot sistēmas iestatījumus"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Ar šo atļauju lietotnes var pārveidot sistēmas iestatījumus."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Atļaut no šī avota"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Pagriešana divreiz kameras atvēršanai"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Atvērt kameras lietotni, divreiz pagriežot plaukstas locītavu"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Attēlojuma lielums"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Palieliniet vai samaziniet saturu"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"attēlojums, blīvums, ekrāna tālummaiņa, mērogs, mērogošana"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Priekšskatījums"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Samazināt"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Palielināt"</string>
    <string name="disconnected" msgid="3469373726996129247">"Savienojums nav izveidots"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Savienojums nav izveidots"</string>
    <string name="apps_summary" msgid="4007416751775414252">"Instalētas <xliff:g id="COUNT">%1$d</xliff:g> lietotnes"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Izmantotā vieta: <xliff:g id="PERCENTAGE">%1$s</xliff:g>, pieejamā vieta: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tumšais motīvs, fonta lielums, spilgtums"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Izmantotais atmiņas apjoms: vidēji <xliff:g id="USED_MEMORY">%1$s</xliff:g> no <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Pierakstījies kā: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Atjaunināta uz Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Ir pieejams atjauninājums"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Bloķēts saskaņā ar darbavietas politiku"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Nevar mainīt skaļumu"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Nevar veikt zvanus"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Nevar nosūtīt īsziņas"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Nevar izmantot kameru"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Nevar izveidot ekrānuzņēmumus"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Nevar atvērt šo lietotni"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Bloķējis jūsu kredīta nodrošinātājs"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Nepieciešama vecāku palīdzība"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Iedodiet tālruni vienam no vecākiem, lai sāktu iestatīšanu."</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Iedodiet tālruni kādam no vecākiem, kas var apstiprināt šī iestatījuma mainīšanu."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Lai iegūtu plašāku informāciju, sazinieties ar savu IT administratoru."</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Plašāka informācija"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Administrators var pārraudzīt un pārvaldīt ar jūsu darba profilu saistītās lietotnes un datus, tostarp iestatījumus, atļaujas, korporatīvo piekļuvi, darbības tīklā un informāciju par ierīces atrašanās vietu."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Administrators var pārraudzīt un pārvaldīt ar šo lietotāju saistītās lietotnes un datus, tostarp iestatījumus, atļaujas, korporatīvo piekļuvi, darbības tīklā un informāciju par ierīces atrašanās vietu."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Jūsu administrators var uzraudzīt un pārvaldīt ar šo ierīci saistītās lietotnes un datus, tostarp iestatījumus, atļaujas, korporatīvo piekļuvi, darbības tīklā un informāciju par ierīces atrašanās vietu."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Iespējams, jūsu ierīces administrators var piekļūt ar šo ierīci saistītajiem datiem, pārvaldīt lietotnes un mainīt šīs ierīces iestatījumus."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Izslēgt"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Ieslēgt"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Rādīt"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Paslēpt"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Tīklājs ir aktīvs"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Lidojuma režīms ir ieslēgts."</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Tīkli nav pieejami"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Režīms “Netraucēt” ir ieslēgts"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Tālruņa skaņa izslēgta"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Ar izņēmumiem"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Akumulatora enerģijas taupīšana"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funkcijas ir ierobežotas"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobilie dati ir izslēgti"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internets ir pieejams, izmantojot tikai Wi-Fi savienojumu"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Datu lietojuma samazinātājs"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funkcijas ir ierobežotas"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Darba profils ir izslēgts"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Lietotnēm un paziņojumiem"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Ieslēgt skaņu"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Zvanītāja skaņa izslēgta"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Zvaniem un paziņojumiem"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Tikai vibrācija"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Zvaniem un paziņojumiem"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Nakts režīma iestatīšana"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Automātiski tonēt ekrānu katru vakaru"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Nakts režīms ir ieslēgts"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Ekrāns iekrāsojas dzintara krāsā"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Pelēktoņu iestatījums"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Attēlot tikai pelēkā krāsā"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Sakļaut"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Vēsu krāsu temperatūra"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Izmantot vēsākas krāsas"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Lai mainītu krāsas, izslēdziet ekrānu"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Kameras lāzera sensors"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automātiski sistēmas atjauninājumi"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Lietot atjauninājumus pēc ierīces restartēšanas"</string>
    <string name="usage" msgid="287782903846013936">"Lietojums"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Mobilo datu lietojums"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Lietotnes datu lietojums"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Wi-Fi datu lietojums"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Datu lietojums, ko nenodrošina mobilo sakaru operators"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Ethernet datu lietojums"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Tīkls Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"Mobilie dati: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> Wi-Fi datu"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> tīkla Ethernet datu"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Datu brīdinājums, ierobežojums"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Mobilo datu lietojuma cikls"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Datu brīdinājums: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Datu ierobežojums: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Datu brīdinājums: <xliff:g id="ID_1">^1</xliff:g>, datu ierobežojums: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="operator_warning" msgid="5672761970087591211">"Mobilo sakaru operatora datu uzskaite var atšķirties no datu uzskaites ierīcē"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Neietver datu lietojumu mobilo sakaru operatoru tīklos."</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> izmantoti"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Ieslēgt brīdinājumu par datiem"</string>
    <string name="data_warning" msgid="2925054658166062884">"Datu brīdinājums"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Datu brīdinājumu un datu ierobežojumu nosaka ierīce. Izmērītās vērtības var atšķirties no mobilo sakaru operatora datiem."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Iestatīt datu ierobežojumu"</string>
    <string name="data_limit" msgid="8731731657513652363">"Datu ierobežojums"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"Izmantotais datu apjoms: <xliff:g id="ID_1">%1$s</xliff:g> (šādā periodā: <xliff:g id="ID_2">%2$s</xliff:g>)"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigurēt"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Citas lietojuma datos iekļautās lietotnes"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 lietotnē ir atļauts izmantot datus bez ierobežojumiem, kamēr ir ieslēgts datu lietojuma samazinātājs}zero{# lietotnēs ir atļauts izmantot datus bez ierobežojumiem, kamēr ir ieslēgts datu lietojuma samazinātājs}one{# lietotnē ir atļauts izmantot datus bez ierobežojumiem, kamēr ir ieslēgts datu lietojuma samazinātājs}other{# lietotnēs ir atļauts izmantot datus bez ierobežojumiem, kamēr ir ieslēgts datu lietojuma samazinātājs}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Galvenie dati"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Wi‑Fi datu apjoms"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Patērētie dati: <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Pārsniegts par <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Atlikušais laiks: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Diagrammā ir redzams datu lietojums šādā periodā: <xliff:g id="START_DATE">%1$s</xliff:g>–<xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Šajā datumu diapazonā nav datu."</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Atlikusi vēl # diena}zero{Atlikušas vēl # dienas}one{Atlikusi vēl # diena}other{Atlikušas vēl # dienas}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Laiks beidzies"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Atlikusi mazāk nekā 1 diena"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Atjaunināja <xliff:g id="ID_1">^1</xliff:g> pirms <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Atjaunināts pirms <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Tikko atjaunināja <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Tikko atjaunināts"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Skatīt plānu"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Skatīt detalizētu informāciju"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Datu lietojuma samazinātājs"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Neierobežoti dati"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Fona dati ir izslēgti."</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Ieslēgts"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Izslēgts"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Izmantot datu lietojuma samazinātāju"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Neierobežots datu lietojums"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Neierobežoti dati, ja datu lietojuma samazinātājs ieslēgts"</string>
    <string name="home_app" msgid="6056850504746902747">"Sākuma lietotne"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Pievienot pirksta nospiedumu"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Atbloķēt ar citu pirkstu"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Ieslēgts"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Tiks ieslēgts, kad sasniegs <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Izslēgts"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Akumulatora lietojums lietotnēm"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Iestatiet akumulatora lietojumu lietotnēm."</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Neierobežots"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimizēts"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Ierobežots"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Nokl. pareizrakstības pārbaude"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Pareizrakst. pārb. atlasīšana"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Izmantot pareizrakstības pārbaudītāju"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nav atlasīta"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pakotne"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"atslēga"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupa"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(kopsavilkums)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publiskā versija"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"svarīgums"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"paskaidrojums"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"drīkst rādīt emblēmu"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"nolūks"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"dzēšanas nolūks"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"pilnekrāna režīma nolūks"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"darbības"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"nosaukums"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"attālā ievade"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"pielāgots skats"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"papildsaturs"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikona"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"pakotnes lielums"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"paziņojuma brīdinājuma signāls aktivizēts"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanāls"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Trūkst ranžēšanas objekta."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Ranžēšanas objektā nav ietverta šī atslēga."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Ekrāna izgriezums"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"ekrāna izgriezums"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Ierīces noklusējuma iestatījums"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Neizdevās lietot pārklājumu"</string>
    <string name="special_access" msgid="1767980727423395147">"Īpaša lietotņu piekļuve"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="zero"><xliff:g id="COUNT">%d</xliff:g> lietotnēs var izmantot neierobežotu datu apjomu</item>
      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> lietotnē var izmantot neierobežotu datu apjomu</item>
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> lietotnēs var izmantot neierobežotu datu apjomu</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Skatīt vairāk"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Ilgi uzdevumi fonā"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Atļaut ilgus uzdevumus fonā"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Ilgi uzdevumi fonā"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Atļauj šai lietotnei izpildīt ilgus uzdevumus fonā. Tādējādi lietotne var izpildīt uzdevumus, kuru pabeigšanai nepieciešams ilgāks laiks, piemēram, lejupielādes un augšupielādes. \n\nJa šī atļauja netiks piešķirta, sistēma ierobežos to, cik ilgi lietotne var veikt šādus uzdevumus fonā."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"ilgi uzdevumi, datu pārsūtīšana, uzdevumi fonā"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Vai atiestatīt ShortcutManager ātruma ierobežošanu?"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"ShortcutManager ātruma ierobežošana ir atiestatīta."</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontrolējiet informāciju bloķēšanas ekrānā"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Rādīt vai slēpt paziņojumu saturu"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Padomi un atbalsts"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Mazākais platums"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Nevienā instalētajā lietotnē nav pieprasīta piekļuve maksas īsziņām."</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Par maksas īsziņām no jums var tikt iekasēta samaksa, kas tiks pievienota jūsu mobilo sakaru operatora rēķinam. Ja kādai lietotnei iespējosiet piekļuves atļauju, varēsiet sūtīt maksas īsziņas, izmantojot šo lietotni."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Piekļuve maksas īsziņām"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Izslēgts"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Izveidots savienojums ar ierīci <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Izveidots savienojums ar vairākām ierīcēm"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Sistēmas lietotāja saskarnes demonstrācijas režīms"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tumšais motīvs"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Īslaicīgi atspējots akumulatora enerģijas taupīšanas dēļ"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Īslaicīgi atspējots akumulatora enerģijas taupīšanas dēļ."</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Izslēgt akumulatora enerģijas taupīšanas režīmu"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Īslaicīgi ieslēgts akumulatora enerģijas taupīšanas dēļ"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Izmēģiniet tumšo motīvu"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Palīdz paildzināt akumulatora darbības laiku"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Izstrādātāja ātro iestatījumu elementi"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Atspējot adb autorizāciju noildzi"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Atspējojiet adb autorizācijas automātisko atsaukšanu sistēmām, kas nav atkārtoti pievienotas noklusējuma laikā (7 dienas) vai lietotāja konfigurētā laikā (minimālais laiks: 1 diena)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Winscope izsekošana"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensori izslēgti"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Darba profila iestatījumi"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Personīgajās lietotnēs meklēt kontaktpersonas, kas saglabātas darba katalogā"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Jūsu IT administratoram var būt redzami jūsu meklēšanas vaicājumi un ienākošie zvani"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Vairāku profils kalendārs"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Rādīt darba pasākumus personīgajā kalendārā"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Kad darba lietotnes ir izslēgtas, to darbība ir apturēta un tām nevar piekļūt, kā arī tās nevar nosūtīt jums paziņojumus."</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Pārvaldīt krātuvi"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Lai atbrīvotu vietu krātuvē, krātuves pārvaldnieks noņem no jūsu ierīces dublētos fotoattēlus un videoklipus."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Fotoattēlu un videoklipu noņemšana"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Krātuves pārvaldnieks"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Izmantot krātuves pārvaldnieku"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Žesti"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Ātra kameras atvēršana"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Lai ātri atvērtu kameru, divreiz nospiediet barošanas pogu. Šī funkcija darbojas jebkurā ekrānā."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Kameras apvēršana pašbildes uzņemšanai"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Navigācijas režīms"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"2 pogu navigācija"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Lai pārslēgtu lietotnes, velciet augšup pogu Sākums. Lai skatītu visas lietotnes, vēlreiz velciet augšup. Lai pārietu atpakaļ, pieskarieties pogai Atpakaļ."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Drošība un ārkārtas situācijas"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Ārkārtas zvans, medicīniskā informācija, brīdinājumi"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Žestu navigācija"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Lai pārietu uz sākuma ekrānu, velciet augšup no ekrāna apakšdaļas. Lai pārslēgtu lietotnes, velciet augšup no ekrāna apakšdaļas, turiet un pēc tam atlaidiet. Lai pārietu atpakaļ, velciet no ekrāna kreisās vai labās malas."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"3 pogu navigācija"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Pārejiet atpakaļ, uz sākuma ekrānu un pārslēdziet lietotnes, izmantojot ekrāna apakšdaļā esošās pogas."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"sistēmas navigācija, 2 pogu navigācija, 3 pogu navigācija, žestu navigācija, vilkšana"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitālais asistents"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Vilkšana, lai izsauktu asistentu"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Lai izsauktu digitālā asistenta lietotni, velciet augšup no apakšējā stūra."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Lai izsauktu Asistentu, nospiediet un turiet pogu Sākums"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Nospiediet un turiet pogu Sākums, lai izsauktu digitālā asistenta lietotni."</string>
    <string name="low_label" msgid="6525629096999711220">"Zems"</string>
    <string name="high_label" msgid="357503396626018487">"Augsts"</string>
    <string name="left_edge" msgid="1513576842959071849">"Kreisā mala"</string>
    <string name="right_edge" msgid="1505309103265829121">"Labā mala"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Augstāks jutīguma līmenis var konfliktēt ar lietotņu žestiem gar ekrāna malām."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Malu jutīgums"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Žestu navigācijas jutīguma līmenis"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Pogu navigācija"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"žestu navigācija, malu jutīgums, žests Atpakaļ"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigācija, poga Sākums"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Vienas rokas režīms"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Izmantot vienas rokas režīmu"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Saīsne uz vienas rokas režīmu"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"sasniedzamība"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Velciet lejup:"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Saīsnei piešķiramā darbība:"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Velciet lejup ekrāna augšējo daļu, lai to varētu vieglāk sasniegt ar vienu roku."</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Kā izmantot vienas rokas režīmu"</b>\n" • Pārliecinieties, ka sistēmas navigācijas iestatījumos ir atlasīta žestu navigācija.\n • Velciet lejup ekrāna apakšmalas tuvumā."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Ekrāna vilkšana, lai tas būtu pieejams"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Ekrāna augšdaļa tiks pārvietota tā, lai to varētu sasniegt ar īkšķi."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Rādīt paziņojumus"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Tiks parādīti paziņojumi un iestatījumi."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Lai skatītu laiku, paziņojumus un citu informāciju, divreiz pieskarieties ekrānam."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Displeja aktivizēšana"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Lai skatītu laiku, paziņojumus un citu informāciju, pieskarieties ekrānam."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Ārkārtas zvans"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Izmantot ārkārtas zvanu"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Vismaz piecas reizes strauji nospiežot barošanas pogu, sākt tālāk norādītās darbības"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Laika atskaites signāla atskaņošana"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Sākot ārkārtas zvanu, atskaņot skaļu signālu"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Saziņa ar palīdzības dienestu"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Zvans palīdzības dienestam"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Numurs, uz kuru zvanīt, lai saņemtu palīdzību"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Pieskarieties, lai mainītu."</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Ja ievadīsiet numuru, kas nav ārkārtas numurs, ņemiet vērā:\n • lai izmantotu ārkārtas zvanu, būs jāatbloķē ierīce;\n • zvans var netikt atbildēts."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Ziņu skatīšana ar pirksta nospiedumu"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Nospiedumu skeneris"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Skatiet paziņojumus ātri"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Ieslēgti"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Izslēgti"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Palaišanas ielādētājs jau ir atbloķēts"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Izveidot savienojumu ar internetu/sazināties ar operatoru"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nav pieejams mobilo sakaru operatoru bloķētās ierīcēs"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Lūdzu, restartējiet ierīci, lai iespējotu ierīces aizsardzības funkciju."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Kopā pieejams: <xliff:g id="SIZE">%1$s</xliff:g>\n\nPēdējoreiz izmantots: <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Tūlītējās lietotnes"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Atveriet saites lietotnēs, pat ja tās nav instalētas."</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Tūlītējās lietotnes"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Tūlītējo lietotņu preferences"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Instalētās lietotnes"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Tagad jūsu krātuvi pārvalda krātuves pārvaldnieks"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Konti: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Automātiski sinhronizēt lietotnes datus"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Ļaut lietotnēm automātiski atsvaidzināt datus"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Konta sinhronizācija"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sinhronizācija ieslēgta <xliff:g id="ID_1">%1$d</xliff:g> no <xliff:g id="ID_2">%2$d</xliff:g> vienumiem"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sinhronizācija ieslēgta visiem vienumiem"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinhronizācija izslēgta visiem vienumiem"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informācija par pārvaldīto ierīci"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Izmaiņas un iestatījumus pārvalda jūsu organizācija"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Izmaiņas un iestatījumus pārvalda <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Lai nodrošinātu piekļuvi jūsu darba datiem, organizācija jūsu ierīcē var mainīt iestatījumus un instalēt programmatūru.\n\nLai iegūtu detalizētu informāciju, sazinieties ar savas organizācijas administratoru."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Jūsu organizācijai redzamās informācijas veidi"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Organizācijas administratora ieviestās izmaiņas"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Jūsu piekļuve šai ierīcei"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Ar jūsu darba kontu saistīti dati, piemēram, e-pasta un kalendāra dati"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Jūsu ierīces lietotņu saraksts"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Katrā lietotnē pavadītais laiks un patērēto datu apjoms"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Pēdējais tīkla datplūsmas žurnāls"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Pēdējais kļūdas pārskats"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Pēdējais drošības žurnāls"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Nav darbību"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Ir instalētas lietotnes."</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Lietotņu skaits ir aptuvens. Tajā var nebūt ietvertas lietotnes, kas instalētas ārpus Play veikala."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Vismaz # lietotne}zero{Vismaz # lietotņu}one{Vismaz # lietotne}other{Vismaz # lietotnes}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Atrašanās vietas atļaujas"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Mikrofona atļaujas"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Kameras atļaujas"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Noklusējuma lietotnes"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# lietotne}zero{# lietotņu}one{# lietotne}other{# lietotnes}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Noklusējuma tastatūra"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Iestatītā metode: <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Iestatījums “Vienmēr ieslēgts VPN” ir ieslēgts"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Iestatījums “Vienmēr ieslēgts VPN” ir ieslēgts jūsu personiskajā profilā"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Iestatījums “Vienmēr ieslēgts VPN” ir ieslēgts jūsu darba profilā"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Ir iestatīts globālais HTTP starpniekserveris"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Uzticami akreditācijas dati"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Jūsu personiskajā profilā instalēti uzticami akreditācijas dati"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Jūsu darba profilā instalēti uzticami akreditācijas dati"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Vismaz # CA sertifikāts}zero{Vismaz # CA sertifikātu}one{Vismaz # CA sertifikāts}other{Vismaz # CA sertifikāti}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administrators var bloķēt ierīci un atiestatīt paroli."</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administrators var dzēst visus ierīces datus"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Nesekmīgi paroles ievadīšanas mēģinājumi, pirms tiek dzēsti visi ierīces dati."</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Nesekmīgi paroles ievadīšanas mēģinājumi, pirms tiek dzēsti darba profila dati."</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# mēģinājums}zero{# mēģinājumu}one{# mēģinājums}other{# mēģinājumi}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Šo ierīci pārvalda jūsu organizācija."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Šo ierīci pārvalda <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">"Uzzināt vairāk"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Ierobežots iestatījums"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Ierobežotie iestatījumi ir atļauti lietotnei <xliff:g id="APP_NAME">%s</xliff:g>."</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Drošības apsvērumu dēļ šis iestatījums pašlaik nav pieejams."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Finansētās ierīces informācija"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Iestatīšanas laikā kredīta nodrošinātājs var mainīt iestatījumus un instalēt programmatūru šajā ierīcē.\n\nJa laicīgi neveiksiet maksājumu, kredīta nodrošinātājs var bloķēt ierīci un mainīt ierīces iestatījumus.\n\nLai uzzinātu vairāk, sazinieties ar kredīta nodrošinātāju."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Ja ierīce iegādāta uz nomaksu, nevarat:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Instalēt lietotnes no avotiem ārpus Play veikala"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Atkārtoti palaist ierīci drošajā režīmā"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Pievienot ierīcei vairākus lietotājus"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Piekļūt datumam, laikam un laika joslām"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Lietot izstrādātāju opcijas"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Jūsu kredīta nodrošinātājs var:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Piekļūt jūsu IMEI numuram"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Ja rodas problēma, atiestatiet ierīces rūpnīcas datus"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Ja ierīce ir bloķēta, varat to izmantot tikai šādu darbību veikšanai:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Veikt ārkārtas zvanus"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Skatīt sistēmas informāciju, piemēram, datumu, laiku, tīkla statusu un akumulatora informāciju"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Ieslēgt vai izslēgt ierīci"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Skatīt paziņojumus un īsziņas"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Piekļūt kredīta nodrošinātāja atļautajām lietotnēm"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Pēc pilnas summas samaksāšanas:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"No ierīces ir noņemti visi ierobežojumi"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Varat atinstalēt kreditora lietotni"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Finansētās ierīces informācija"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Kameras lietotne}zero{Kameras lietotnes}one{Kameras lietotnes}other{Kameras lietotnes}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalendāra lietotne"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Kontaktpersonu lietotne"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{E-pasta klienta lietotne}zero{E-pasta klientu lietotnes}one{E-pasta klientu lietotnes}other{E-pasta klientu lietotnes}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Karšu lietotne"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Tālruņa lietotne}zero{Tālruņa lietotnes}one{Tālruņa lietotnes}other{Tālruņa lietotnes}}"</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">"Šī ierīce"</string>
    <string name="storage_games" msgid="1176568610086802469">"Spēles"</string>
    <string name="storage_files" msgid="7968460921272772299">"Faili"</string>
    <string name="storage_images" msgid="2055893015567979387">"Attēli"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videoklipi"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Lietotnes"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumenti un cits saturs"</string>
    <string name="storage_system" msgid="8472410119822911844">"Sistēma"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Atkritne"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Vai iztukšot atkritni?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Atkritnē ir <xliff:g id="TOTAL">%1$s</xliff:g> failu. Visi vienumi tiks neatgriezeniski dzēsti, un jūs nevarēsiet tos atjaunot."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Atkritne ir tukša"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Iztukšot atkritni"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Izmantotais apjoms: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Kopējais apjoms: <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">"Notīrīt lietotni"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Vai vēlaties noņemt šo tūlītējo lietotni?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Atvērt"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Spēles"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Izmantotā vieta krātuvē"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(atinstalēts lietotājam <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(atspējots lietotājam <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Automātiskā aizpilde"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Noklusējuma automātiskās aizpildes pakalpojums"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Paroles"</string>
    <string name="credman_chosen_app_title" msgid="4547405511458518096">"Paroles, piekļuves atslēgas un datu pakalpojumi"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Papildu pakalpojumu sniedzēji"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# parole}zero{# paroļu}one{# parole}other{# paroles}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automātiskā aizpilde, automātiski aizpildīt, parole"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"dati, piekļuves atslēga, parole"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automātiskā aizpilde, automātiski aizpildīt, dati, piekļuves atslēga, parole"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Pārliecinieties, ka šī lietotne ir uzticama&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google automātiskā aizpilde&gt;%1$s&lt;/xliff:g&gt; izmanto ekrānā redzamo, lai noteiktu, kādu informāciju aizpildīt automātiski."</string>
    <string name="credman_autofill_confirmation_message" msgid="4951846866327737417">"&lt;b&gt;Izmantojiet lietotni &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Lietotne &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; izmanto ekrānā redzamo saturu, lai noteiktu, kādu informāciju var aizpildīt automātiski. Turpmāk jaunās paroles, piekļuves atslēgas un cita informācija tiks saglabāta šeit."</string>
    <string name="credman_picker_title" msgid="2642776965060619988">"Paroles, piekļuves atslēgas un datu pakalpojumi"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Vai izslēgt pakalpojumu %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Vai izslēgt šo pakalpojumu?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Pierakstoties netiks aizpildīta saglabātā informācija, piemēram, paroles, piekļuves atslēgas, maksājumu veidi un cita informācija. Lai izmantotu saglabāto informāciju, izvēlieties paroli, piekļuves atslēgu vai datu pakalpojumu."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Vai izmantot %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s izmanto ekrānā pieejamos datus, lai noteiktu, kādu informāciju var aizpildīt automātiski."</string>
    <string name="credman_error_message_title" msgid="4741457523969373713">"Paroļu, piekļuves atslēgu un datu pakalpojumu ierobežojums"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Vienlaikus jums var būt aktīvas ne vairāk kā 5 paroles, piekļuves atslēgas un datu pakalpojumi. Lai pievienotu vēl kādu pakalpojumu, izslēdziet kādu no pašreizējiem."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Izslēgt"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Automātiskā aizpilde"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Pieteikšanās līmenis"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maksimālais pieprasījumu skaits katrā sesijā"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maksimālais redzamo datu kopu skaits"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Atiestatīt uz noklusējuma vērtībām"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Izstrādātāju opciju automātiskā aizpilde ir atiestatīta."</string>
    <string name="location_category" msgid="3496759112306219062">"Atrašanās vieta"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Atrašanās vietas indikators statusa joslā"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Rādīt vienmēr, kad tiek noteikta atrašanās vieta, tostarp tad, ja tā var tikt atklāta, izmantojot tīklu vai savienojamību"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Veikt pilnus GNSS mērījumus"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Izsekot visas GNSS konstelācijas un frekvences bez darba cikliem"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Ievades metode"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Ievade ar skārienekr. pildsp."</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Ja opcija ir iespējota un ir fokusēts redaktors, pašreizējā ievades metode saņem skārienekrāna pildspalvas objektu MotionEvent."</string>
    <string name="device_theme" msgid="5027604586494772471">"Ierīces motīvs"</string>
    <string name="default_theme" msgid="4815428567082263639">"Noklusējums"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Tīkla nosaukums"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Statusa joslā rādīt tīkla nosaukumu"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Tūlītējā lietotne"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Vai izslēgt krātuves pārvaldnieku?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Atjaunināt iestatījumu “Netraucēt”"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pārtraukt paziņojumus, lai ilglaicīgi koncentrētos"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funkcija nav pieejama"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Šī funkcija ir izslēgta, jo tā palēnina jūsu tālruņa darbību."</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Vienmēr rādīt avārijas dialoglodziņu"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Rādīt dialoglodziņu katru reizi, kad lietotne avarē"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Atlasiet lietotni, kam ANGLE ir iespējots"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nav iestatīta neviena lietojumprogramma, kam ANGLE ir iespējots"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Lietojumprogramma, kam ANGLE ir iespējots: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Grafikas draivera preferences"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Grafikas draivera iestatījumu mainīšana"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Ja ir vairāki grafikas draiveri, varat izvēlēties izmantot atjaunināto grafikas draiveri, kas paredzēts ierīcēs instalētajām lietotnēm."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Iespējot visām lietotnēm"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Grafikas draivera atlase"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Noklusējums"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Spēles draiveris"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Grafikas draiveris izstrādātājiem"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Sistēmas grafikas draiveris"</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="enable_angle_as_system_driver" msgid="3985105681812713612">"Iespējot ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="4173041926052925436">"Iespējot ANGLE kā sistēmas OpenGL ES draiveri"</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Lai mainītu sistēmas OpenGL ES draiveri, nepieciešama atkārtota palaišana."</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Lietotņu saderības iestatījumu izmaiņas"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Pārslēdziet lietotņu saderības iestatījumu izmaiņas"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Pēc noklusējuma iespējotās izmaiņas"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Pēc noklusējuma atspējotās izmaiņas"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Nav lietotņu"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Lietotņu saderības izmaiņas var pārveidot tikai atkļūdojamām lietotnēm. Instalējiet atkļūdojamu lietotni un mēģiniet vēlreiz."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Atkarīgs no cita iestatījuma"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Konts"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Ierīces nosaukums"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Pamatinformācija"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Juridiskā un regulējošā informācija"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Informācija par ierīci"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Ierīces identifikatori"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Wi-Fi pārvaldība"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Atļaut lietotnei pārvaldīt savienojumu ar Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Atļaut šai lietotnei ieslēgt vai izslēgt savienojumu ar Wi-Fi, meklēt un izveidot savienojumu ar Wi-Fi tīkliem, pievienot vai noņemt tīklus vai izveidot vietējo tīklāju."</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Palaist, izmantojot NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Atļaut palaišanu pēc NFC atzīmes skenēšanas"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Atļaujiet palaist šo lietotni ikreiz, kad tiek skenēta NFC atzīme.\nJa piešķirsiet šo atļauju, lietotne būs pieejama kā iespēja katru reizi, kad tiks noteikta atzīme."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Atskaņot multivides saturu šeit:"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Atskaņot <xliff:g id="LABEL">%s</xliff:g> šeit:"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Šī ierīce"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Ierīce nav pieejama zvanu laikā"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Atbildēt uz zvanu, izmantojot:"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"APN nevar mainīt."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Zvana signāla novēršana"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Vienlaikus nospiediet barošanas un skaļuma palielināšanas pogu"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Īsinājumtaustiņš zvana signāla novēršanai"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrēt"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Izslēgt skaņu"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrēt"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Izslēgt skaņu"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Lai iespējotu, vispirms nomainiet iestatījumu “Nospiest un turēt barošanas pogu” uz barošanas izvēlni."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Dati par tīklu"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Jūsu ierīces nosaukums ir redzams tālrunī instalētajām lietotnēm. Tas var būt redzams arī citām personām, ja izveidosiet savienojumu ar Bluetooth ierīcēm, Wi-Fi tīklu vai iestatīsiet Wi-Fi tīklāju."</string>
    <string name="devices_title" msgid="649715719278562515">"Ierīces"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Izvēlēties tīklu"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Nav savienojuma"</string>
    <string name="network_connected" msgid="7637745547242487795">"Izveidots savienojums"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Notiek savienojuma izveide…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Nevarēja izveidot savienojumu"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Netika atrasts neviens tīkls."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Neizdevās atrast tīklus. Mēģiniet vēlreiz."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(aizliegts)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM karte"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Nav SIM kartes"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Nav"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Lai izveidotu savienojumu, nepieciešama SIM karte"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Lai izveidotu savienojumu, nepieciešama <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> SIM karte"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Ieteicamais tīkla režīms: WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Ieteicamais tīkla režīms: tikai GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Ieteicamais tīkla režīms: tikai WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Ieteicamais tīkla režīms: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Ieteicamais tīkla režīms: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Ieteicamais tīkla režīms: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Ieteicamais tīkla režīms: tikai CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Ieteicamais tīkla režīms: tikai EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Ieteicamais tīkla režīms: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Ieteicamais tīkla režīms: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Ieteicamais tīkla režīms: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Ieteicamais tīkla režīms: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Ieteicamais tīkla režīms: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Ieteicamais tīkla režīms: vispārējs"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Ieteicamais tīkla režīms: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Ieteicamais tīkla režīms: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Ieteicamais tīkla režīms: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Ieteicamais tīkla režīms: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Ieteicamais tīkla režīms: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Ieteicamais tīkla režīms: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Ieteicamais tīkla režīms: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Ieteicamais tīkla režīms: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Ieteicamais tīkla režīms: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Ieteicamais tīkla režīms: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Ieteicamais tīkla režīms: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Ieteicamais tīkla režīms: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Ieteicamais tīkla režīms: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Ieteicamais tīkla režīms: tikai NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Ieteicamais tīkla režīms: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Ieteicamais tīkla režīms: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Ieteicamais tīkla režīms: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Ieteicamais tīkla režīms: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Ieteicamais tīkla režīms: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Ieteicamais tīkla režīms: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Ieteicamais tīkla režīms: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Ieteicamais tīkla režīms: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Ieteicamais tīkla režīms: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Ieteicamais tīkla režīms: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (ieteicams)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (ieteicams)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (ieteicams)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Automātiski atlasīt tīklu"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Mobilo sakaru operatora iestatījumi"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Datu pakalpojuma iestatīšana"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobilie dati"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Piekļuve datiem, izmantojot mobilo tīklu"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Tālrunis tiks automātiski pārslēgts uz šo mobilo sakaru operatoru, ja būs sasniedzamības zonā"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Neviena SIM karte nav pieejama"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Vēlamais abonements zvaniem"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Vēlamais tīkls īsziņām"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Vaicāt katru reizi"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Pievienot tīklu"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Noklusējums zvaniem"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Noklusējums īsziņām"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Noklusējums zvaniem un īsziņām"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Noklusējums mobilajiem datiem"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Aktīvs mobilo datu savienojums"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobilie dati izslēgti"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Pieejama"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Pievienot SIM karti"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktīvs, SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Neaktīvs, SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktīva/eSIM karte"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Neaktīva/eSIM karte"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"SIM kartes nosaukums un krāsa"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Vārds"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Krāsa (izmanto saderīgas lietotnes)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Saglabāt"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Izmantot SIM karti"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Izslēgta"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Lai atspējotu šo SIM, izņemiet SIM karti."</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Pieskarieties, lai aktivizētu <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Dzēst SIM karti"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Ieteicamais tīkla veids"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Mainiet tīkla darbības režīmu"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Ieteicamais tīkla veids"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Mobilo sakaru operatora iestatījumu versija"</string>
    <string name="call_category" msgid="641461844504128789">"Zvanīšana"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Mobilo sakaru operatora videozvani"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Sistēmas atlasīšana"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Mainīt CDMA viesabonēšanas režīmu"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Sistēmas atlasīšana"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Tīkls"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA abonements"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Mainīt uz RUIM/SIM vai NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"abonēšana"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automātiska reģistrācija..."</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Vai atļaut datu viesabonēšanu?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Sazinieties ar savu tīkla pakalpojumu sniedzēju, lai uzzinātu par tarifiem."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Lietotnes datu lietojums"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Nederīgs tīkla režīms: <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorēt."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Piekļuves punktu nosaukumi"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"APN"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Nav pieejams, ja izveidots savienojums ar operatoru <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Skatīt vairāk"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Vai ieslēgt operatoru <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Vai ieslēgt SIM karti?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Vai pārslēgt uz operatoru <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Vai pārslēgties uz SIM kartes izmantošanu?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Vai lietot operatoru <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Vienlaikus aktīva var būt tikai viena SIM karte.\n\nPārslēdzoties uz operatoru <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, netiks atcelti <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> pakalpojumi."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Vienlaikus var būt aktīva tikai viena eSIM karte.\n\nPārejot pie mobilo sakaru operatora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, netiks atcelti <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> pakalpojumi."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Vienlaikus var būt aktīva tikai viena SIM karte.\n\nPārslēdzoties netiks atcelti <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> pakalpojumi."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Jūs nevarat lietot divas SIM kartes vienlaikus. Lai lietotu operatoru <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, izslēdziet otru SIM karti."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Pārslēgties uz operatoru <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">"Izslēgt operatoru <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Izslēdzot kāda operatora SIM karti, netiks atcelts jūsu izmantotais plāns."</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Notiek savienojuma izveide ar tīklu…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Notiek pārslēgšanās uz <xliff:g id="CARRIER_NAME">%1$s</xliff:g> savienojumu zvaniem un ziņojumu sūtīšanai…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Nevar pārslēgties uz cita mobilo sakaru operatora tīklu"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Nevar pārslēgties uz cita mobilo sakaru operatora tīklu, jo radās kļūda."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Vai izslēgt pakalpojumu <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Vai izslēgt SIM karti?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Notiek SIM kartes izslēgšana<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Nevar atspējot mobilo sakaru operatoru"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Radās kļūda, un mobilo sakaru operatoru nevarēja atspējot."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Vai izmantot divas SIM kartes?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Šajā ierīcē vienlaikus var būt aktīvas divas SIM kartes. Lai turpinātu vienlaikus lietot vienu SIM karti, pieskarieties vienumam “Nē, paldies”."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Vai restartēt ierīci?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Jā"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Restartēt"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nē, paldies"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Atcelt"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Pārslēgt"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Nevar aktivizēt SIM karti"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Mēģiniet atkal ieslēgt SIM karti. Ja problēma nav novērsta, restartējiet savu ierīci."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Tīkla aktivizācija"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Mobilo sakaru operatora pārslēgšana"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> ir aktīvs"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Pieskarieties, lai atjauninātu SIM kartes iestatījumus."</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Pārslēgts uz: <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Pārslēgts uz citu operatoru"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Jūsu mobilais tīkls tika mainīts."</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Otras SIM kartes iestatīšana"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Izvēlieties savu aktīvo SIM karti vai izmantojiet vienlaikus divas SIM kartes."</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Izmantojamā numura izvēle"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Šajā ierīcē ir pieejams 1 numurs, un vienlaikus var lietot tikai vienu numuru.}=2{Šajā ierīcē ir pieejami 2 numuri, taču vienlaikus var lietot tikai vienu numuru.}zero{Šajā ierīcē ir pieejami # numuri, taču vienlaikus var lietot tikai vienu numuru.}one{Šajā ierīcē ir pieejams # numurs, taču vienlaikus var lietot tikai vienu numuru.}other{Šajā ierīcē ir pieejami # numuri, taču vienlaikus var lietot tikai vienu numuru.}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Notiek aktivizēšana<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Pašlaik nevar aktivizēt"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Vai izmantot <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> tiks izmantots mobilo datu, zvanu un īsziņu pakalpojumu nodrošināšanai."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nav pieejama neviena aktīva SIM karte"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Lai vēlāk izmantotu mobilos datus, zvanīšanas funkcijas un īsziņas, pārejiet uz tīkla iestatījumiem."</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM karte"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Vai dzēst šo eSIM karti?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Izdzēšot šo SIM karti, operatora “<xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>” pakalpojumi tiek noņemti no šīs ierīces.\n\nOperatora “<xliff:g id="CARRIER_NAME_B">%1$s</xliff:g>” pakalpojumi netiks atcelti."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Dzēst"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Notiek SIM kartes dzēšana…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Nevar izdzēst SIM karti"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Šo SIM karti nevar izdzēst, jo radās kļūda.\n\nRestartējiet ierīci un mēģiniet vēlreiz."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Savienojuma izveide ar ierīci"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Lietotne <xliff:g id="APPNAME">%1$s</xliff:g> vēlas izmantot pagaidu Wi‑Fi tīklu, lai izveidotu savienojumu ar jūsu ierīci."</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nav atrasta neviena ierīce. Ierīcēm ir jābūt ieslēgtām un pieejamām savienojuma izveidei."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Mēģināt vēlreiz"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Radās kļūda. Lietojumprogramma atsauca ierīces atlases pieprasījumu."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Savienojums izveidots"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Savienojuma kļūme"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Rādīt visu"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Notiek ierīces meklēšana…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Notiek savienojuma izveide ar ierīci…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Pa kreisi"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Pa labi"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Futrālis"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Iestatījumu panelis"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Veikt piespiedu darbvirsmas režīma atvēršanu"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Veikt piespiedu eksperimentālā darbvirsmas režīma atvēršanu sekundārajos displejos"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Vairāku logu režīmā iespējot nemainīga lieluma lietotnes"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Šis iestatījums ļauj vairāku logu režīmā rādīt lietotnes, kuru lielums nav maināms"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Tumšā režīma piespiedu ieslēgšanas ignorēšana"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Ignorē tumšā režīma iestatījumu Vienmēr ieslēgts"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Konfidencialitāte"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Atļaujas, konta aktivitāte, personas dati"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Vadīklas"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Noņemt"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Saglabāt"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Vai noņemt šo ieteikumu?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Krātuvē ir maz vietas: <xliff:g id="PERCENTAGE">%1$s</xliff:g> izmantota, <xliff:g id="FREE_SPACE">%2$s</xliff:g> brīva"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Sūtīt atsauksmes"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Vai vēlaties sniegt atsauksmes par šo ieteikumu?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> — kopēts starpliktuvē."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Pieejamības lietojums"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{Vienai lietotnei ir pilna piekļuve jūsu ierīcei}zero{# lietotnēm ir pilna piekļuve jūsu ierīcei}one{# lietotnei ir pilna piekļuve jūsu ierīcei}other{# lietotnēm ir pilna piekļuve jūsu ierīcei}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Svarīga informācija"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"TURPINĀT"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NĒ, PALDIES"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Atrašanās vieta"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Ja izmantosiet šo pakalpojumu ārkārtas izsaukumiem, mobilo sakaru operators var ievākt jūsu atrašanās vietas informāciju.\n\nLai uzzinātu vairāk, skatiet mobilo sakaru operatora konfidencialitātes politiku."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Iespējams, zaudēsiet piekļuvi atlikušajam laikam vai datiem. Pirms noņemšanas sazinieties ar pakalpojuma sniedzēju."</string>
    <string name="content_capture" msgid="868372905432812238">"Lietotnes saturs"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Atļaut lietotnēm nosūtīt saturu Android sistēmai"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Tvert sistēmas kaudzes izrakstu"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Paplašinājums Memory Tagging Extension (MTE) palīdz meklēt atmiņas drošības problēmas lietotnē un uzlabot iebūvētā koda drošību."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Ieslēdzot paplašinājumu MTE, ierīces darbība var palēnināties."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Uzzināt vairāk par MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Iespējot MTE, līdz to izslēgsiet"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Jums būs jārestartē ierīce, lai ieslēgtu MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Jums būs jārestartē ierīce, lai izslēgtu MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Iespējot MTE uz vienu sesiju"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Sistēma tiks restartēta, un varēsiet eksperimentēt ar paplašinājumu Memory Tagging Extension (MTE). MTE var negatīvi ietekmēt sistēmas veiktspēju un stabilitāti. Nākamajā atkārtotas palaišanas reizē šis iestatījums tiks atiestatīts."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Restartēt uz vienu sesiju ar iespējotu MTE"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"Paplašinājums MTE jau ir iespējots"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Notiek sistēmas kaudzes izraksta tveršana"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Neizdevās tvert sistēmas kaudzes izrakstu"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Automātiski tvert sistēmas kaudzes izrakstus"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Automātiski tvert Android sistēmas kaudzes izrakstu, ja sistēma patērē pārāk daudz atmiņas"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Atvienot"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Ārkārtas zvani"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Jūsu mobilo sakaru operators neatbalsta ārkārtas zvanus kā Wi‑Fi zvanus.\nIerīcē tiek automātiski pārslēgts mobilais tīkls, lai veiktu ārkārtas zvanu.\nĀrkārtas zvanus iespējams veikt tikai apgabalos ar mobilā tīkla pārklājumu."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Zvaniem izmantot Wi‑Fi, lai uzlabotu kvalitāti"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Zvanu rezerves iespēja"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Ja <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> nav pieejams vai ir ieslēgta viesabonēšana, izmantojiet SIM kartes mobilos datus <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g> zvaniem."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"zvanu rezerves iespēja"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Ienākoša multiziņa"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Nevar nosūtīt multiziņu"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Pieskarieties, lai atļautu multiziņu sūtīšanu, izmantojot operatoru <xliff:g id="OPERATOR_NAME">%1$s</xliff:g>, kad mobilie dati ir izslēgti."</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Multiziņa"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problēma ar SIM kombināciju"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Izmantojot operatorus <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g>, funkcijas var būt ierobežotas. Pieskarieties, lai uzzinātu vairāk."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM kombinācija"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Jūsu darba politikas informācija"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Iestatījumus pārvalda jūsu IT administrators"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"Grafiskais procesors"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Kļūdu pārskatu apstrādātājs"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Šeit varat noteikt, kurai lietotnei jūsu ierīcē jāapstrādā kļūdu pārskatu saīsne."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personiskais profils"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Darba profils"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Sistēmas noklusējums"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Nav"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Šī atlase vairs nav derīga. Mēģiniet vēlreiz."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Barošanas pogas nospiešana un turēšana"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Kad tiek nospiesta un turēta barošanas poga, ir jāatver"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Barošanas izvēlne"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitālais asistents"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Piekļūt digitālajam asistentam"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Piekļūt barošanas izvēlnei"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Lai to izmantotu, vispirms ir jāiestata ekrāna bloķēšana."</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Barošanas izvēlne:\nvienlaikus nospiediet barošanas pogu un skaļuma palielināšanas pogu"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Zvana signāla novēršana:\nlai izmantotu īsinājumtaustiņu, nospiediet skaļuma pogu"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Nospiešanas un turēšanas ilgums"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Pielāgojiet jutīgumu, izvēloties, cik ilgi barošanas poga ir jātur."</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Īsi"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Ilgi"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Rādīt maku"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Atļaut piekļūt makam no bloķēšanas ekrāna"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Rādīt kvadrātkoda skeneri"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Atļaut piekļuvi kvadrātkoda skenerim no bloķēšanas ekrāna"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Rādīt ierīču vadīklas"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Bloķēšanas ekrānā"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Izmantot ierīču vadīklas"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Lai izmantotu vadīklas, vispirms ieslēdziet iestatījumu “Rādīt ierīču vadīklas”."</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Rādīt pulksteni divās rindās, ja tas ir pieejams"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Pulkstenis divās rindās"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Saīsnes"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="zero">Nav</item>
      <item quantity="one"><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">"Vai izslēgt VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Tādējādi tiek arī izslēgts jūsu 5G savienojums.\nBalss zvana laikā jūs nevarat izmantot internetu un dažas lietojumprogrammas, iespējams, nedarbosies."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Kešatmiņā saglabāto lietotņu izpildes apturēšana"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Neierobežots termiņš."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Neierobežots nomas termiņš."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Atļaut ekrānu pārklāšanu iestatījumos"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Atļaut lietotnēm, ko var rādīt pāri citām lietotnēm, pārklāt iestatījumu ekrānus"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Atļaut modema imitāciju"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Atļaut šajā ierīcē izpildīt modema imitācijas pakalpojumu, lai veiktu instrumentācijas testu. Neiespējojiet šo atļauju parastas tālruņa lietošanas laikā."</string>
    <string name="media_controls_title" msgid="403271085636252597">"Multivide"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Piespraust multivides atskaņotāju"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Multivides atskaņotājs paliek atvērts sadaļā Ātrie iestatījumi, lai varētu ātri atsākt atskaņošanu"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Rādīt multividi bloķēšanas ekrānā"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Multivides atskaņotājs paliek atvērts bloķēšanas ekrānā, lai varētu ātri atsākt atskaņošanu"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Rādīt multivides satura ieteikumus"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Ieteikumu pamatā ir jūsu darbības"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Paslēpt atskaņotāju"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Rādīt atskaņotāju"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"multivide"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Tiks ieslēgts Bluetooth savienojums."</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internets"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM kartes"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Zvani un īsziņas"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Wi-Fi zvani"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Zvanu veikšana un saņemšana Wi-Fi tīklā"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Zvani"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"Īsziņas"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"vēlamie"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"ieteicams zvaniem"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"ieteicams īsziņām"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nav pieejami"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Īslaicīgi nav pieejams"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Nav SIM kartes"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Tīkla preferences"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"tīkla savienojums, internets, bezvadu, dati, Wi-Fi, mobilais tīkls, mobilie sakari, mobilo sakaru operators, 4G, 3G, 2G, LTE"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Vai atiestatīt internetu?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Notiek interneta atiestatīšana…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Novērst problēmu ar savienojamību"</string>
    <string name="networks_available" msgid="3299512933684383474">"Pieejamie tīkli"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Lai pārslēgtu tīklus, atvienojiet tīkla Ethernet vadu."</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+ savienojumi"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Atļaut Google Fi izmantot W+ tīklus, lai uzlabotu ātrumu un pārklājumu"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+ tīkls"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM karte"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM karte"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIM kartes"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Aktīva"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Neaktīva"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Noklusējuma iestatījums kategorijai “<xliff:g id="ID_1">%1$s</xliff:g>”"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"zvani"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"īsziņas"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobilie dati"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Lai uzlabotu ierīces lietošanas iespējas, lietotnes un pakalpojumi joprojām varēs meklēt Wi-Fi tīklus jebkurā laikā, pat ja Wi-Fi būs izslēgts. Šo iestatījumu var izmantot, piemēram, lai uzlabotu ar atrašanās vietu saistītas funkcijas un pakalpojumus. Varat to mainīt Wi-Fi meklēšanas iestatījumos."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Mainīt"</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">"Ir izveidots savienojums"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Īslaicīgi izveidots savienojums"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Īslaicīgi tiek izmantots pakalpojums <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Nav savienojuma"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobilo datu savienojums netiks veidots automātiski"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Vai izslēgt mobilos datus?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Izmantojot mobilo sakaru operatora <xliff:g id="CARRIER">%s</xliff:g> pakalpojumus, nevarēsiet piekļūt datiem vai internetam. Internetam varēsiet piekļūt, tikai izmantojot Wi-Fi savienojumu."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"jūsu mobilo sakaru operators"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Jūsu organizācija to neatļauj."</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Šī preference nav pieejama, jo ir ieslēgts naktsmiera režīms."</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Paziņojumu svarīguma līmeņa atiestatīšana ir pabeigta."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Lietotnes"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Kāda ierīce pieprasa atļauju piekļūt jūsu ziņojumiem. Pieskarieties, lai skatītu detalizētu informāciju."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Vai atļaujat piekļūt ziņojumiem?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Bluetooth ierīce “<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>” pieprasa atļauju piekļūt jūsu ziņojumiem.\n\nJūs iepriekš neesat izveidojis savienojumu ar ierīci “<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>”."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Kāda ierīce pieprasa atļauju piekļūt jūsu kontaktpersonu datiem un zvanu žurnālam. Pieskarieties, lai skatītu detalizētu informāciju."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Vai atļaujat piekļūt kontaktpersonu datiem un zvanu žurnālam?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Bluetooth ierīce “<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>” pieprasa atļauju piekļūt jūsu kontaktpersonu datiem un zvanu žurnālam. Tas attiecas arī uz datiem par ienākošajiem un izejošajiem zvaniem.\n\nJūs iepriekš neesat izveidojis savienojumu ar ierīci “<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>”."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Spilgtums"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Displeja bloķēšana"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Izskats"</string>
    <string name="category_name_color" msgid="937514550918977151">"Krāsa"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Citas displeja vadīklas"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Vispārīgi"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Tumšā motīva izmantošana"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Bluetooth izmantošana"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Izmantot zvana signāla novēršanu"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Izmantot Wi-Fi tīklāju"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Izmantot lietotņu piespraušanu"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Izmantot izstrādātāju opcijas"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Izmantot drukāšanas pakalpojumu"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Atļaut vairākus lietotājus"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"ļaut, vairāki, lietotājs, atļaut, daudz"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Izmantot bezvadu atkļūdošanu"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Izmantot grafikas draivera preferences"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Izmantot funkciju Nakts režīms"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Izmantot tehnoloģiju NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Izmantot adaptīvu spilgtumu"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Izmantot Wi-Fi zvanus"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Skatīt visas lietotnes"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Viedā pāradresācija"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Viedā pāradresācija ir iespējota"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Viedā pāradresācija ir atspējota"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Zvanu iestatījumi"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Notiek iestatījumu atjaunināšana…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Zvanu iestatījumu kļūda"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Tīkla vai SIM kartes kļūda."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM karte nav aktivizēta."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Ievadiet tālruņa numurus"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Ievadiet tālruņa numuru"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Nav norādīts tālruņa numurs."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"Labi"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Atļaut 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G drošības līmenis ir zemāks, taču dažās atrašanās vietās šis savienojums var būt stabilāks. Ārkārtas izsaukumiem 2G lietošana vienmēr ir atļauta."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> pieprasa 2G tīkla pieejamību"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Vai pieprasīt šifrēšanu?"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Šifrēšana uzlabo drošību, taču, to izmantojot, dažās atrašanās vietās var neizdoties izveidot savienojumu. Veicot ārkārtas zvanus, nekad netiek pieprasīta šifrēšana."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Visi pakalpojumi"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Rādīt paziņojumus par piekļuvi starpliktuvei"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Rādīt ziņojumu, kad lietotnes piekļūst jūsu nokopētajam tekstam, attēliem vai citam saturam"</string>
    <string name="all_apps" msgid="3054120149509114789">"Visas lietotnes"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Neatļaut"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra platjosla (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Palīdz noteikt tuvumā esošo ierīču relatīvo pozīciju, ja šīs ierīces izmanto UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Izslēdziet lidojuma režīmu, lai izmantotu UWB."</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB nav pieejama pašreizējā atrašanās vietā."</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Piekļuve kamerai"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Piekļuve mikrofonam"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Lietotnēm un pakalpojumiem"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Lietotnēm un pakalpojumiem. Ja šis iestatījums ir izslēgts, mikrofona dati joprojām var tikt kopīgoti, kad zvanīsiet uz ārkārtas numuru."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Iepriekšējā"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Nākamā"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Krāsas priekšskatījums"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Pieprasījums piekļūt SIM kartei"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Kāda ierīce pieprasa piekļuvi jūsu SIM kartei. Pieskarieties, lai skatītu detalizētu informāciju."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Vai piešķirt piekļuvi SIM kartei?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Bluetooth ierīce “<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>” pieprasa atļauju piekļūt jūsu SIM kartē saglabātājiem datiem, tostarp kontaktpersonām.\n\nKamēr savienojums būs aktīvs, visi zvani uz numuru <xliff:g id="PHONE_NUMBER">%3$s</xliff:g> tiks saņemti ierīcē “<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>”."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Ir pieejama Bluetooth ierīce"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Ierīce pieprasa atļauju izveidot savienojumu. Pieskarieties, lai skatītu detalizētu informāciju."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Vai izveidot savienojumu ar Bluetooth ierīci?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"Ierīce “<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>” pieprasa atļauju izveidot savienojumu ar šo tālruni.\n\nIepriekš neesat veidojis savienojumu ar ierīci <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Neizveidot savienojumu"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Izveidot savienojumu"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE iestatījumi"</string>
    <string name="tare_on" msgid="2386073225978684535">"Ieslēgta"</string>
    <string name="tare_off" msgid="6305694402929756726">"Izslēgta"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Atjaunot noklusējuma iestatījumus"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Atjaunoti noklusējuma iestatījumi."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maksimālais atlikums ar uzlādētu ierīci"</string>
    <string name="tare_balances" msgid="731881382594747961">"Atlikumi"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Patēriņa ierobežojumi"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Sākotnējais patēriņa ierobežojums"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimālais patēriņa ierobežojums"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maksimālais patēriņa ierobežojums"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Pārveidotāji"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Darbības (izveides cena)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Darbības (pamatcena)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Atlīdzības par vienu notikumu"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Atlīdzības par vienu notikuma sekundi"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maksimālais atlīdzību skaits dienā"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Lietotnes instalēšana"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Biežākā darbība"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Paziņojums redzēts"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Paziņojums redzēts 15 minūšu laikā"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Mijiedarbība ar paziņojumu"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Mijiedarbība ar logrīku"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Cita lietotāja mijiedarbība"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Uzdevums sākts (maksimālā prioritāte)"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Uzdevums aktīvs (maksimālā prioritāte)"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Uzdevums sākts (augsta prioritāte)"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Uzdevums aktīvs (augsta prioritāte)"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Uzdevums sākts (noklusējuma prioritāte)"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Uzdevums aktīvs (noklusējuma prioritāte)"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Uzdevums sākts (zema prioritāte)"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Uzdevums aktīvs (zema prioritāte)"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Uzdevums sākts (minimālā prioritāte)"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Uzdevums aktīvs (minimālā prioritāte)"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Sods par uzdevuma noildzi"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimālais atlikums ar uzlādētu ierīci (izslēgtas lietotnes)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimālais atlikums ar uzlādētu ierīci (bezgalvas sistēmas lietotne)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimālais atlikums ar uzlādētu ierīci (atlikušās lietotnes)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Minimālā atlikuma ar uzlādētu ierīci papildināšana (lietotņu atjauninātāji)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Uzlāde"</item>
    <item msgid="658627268149681677">"Snauda"</item>
    <item msgid="1599558140284643834">"Enerģijas taupīšanas režīms"</item>
    <item msgid="588427840913221601">"Apstrādes statuss"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Apstiprināt"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Priekšskatīt"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Izvēlieties ekrānsaudzētāju"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Rādīt papildu informāciju"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Ekrānsaudzētājā tiek rādīts pulksteņa laiks, laikapstākļu prognoze vai cita informācija."</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Rādīt mājas viedierīču pārvaldības pogas"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Ekrānsaudzētājā rādīt mājas viedierīču pārvaldības pogas"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Citi iestatījumi"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Ekrānsaudzētāja izvēle"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Izvēlieties, kas būs redzams ekrānā, kad planšetdators būs dokots. Ja izmantosiet ekrānsaudzētāju, ierīce var patērēt vairāk enerģijas."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Pielāgot"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Pielāgot ekrānsaudzētāju “<xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>”"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Lai iespējotu brīvās formas atbalstu, nepieciešama atkārtota palaišana."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Lai piespiedu kārtā aktivizētu darbvirsmas režīmu sekundārajos displejos, nepieciešama atkārtota palaišana."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Atkārtoti palaist tūlīt"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Atkārtoti palaist vēlāk"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Telpiskais audio"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Audio no saderīga multivides satura kļūst iekļaujošāks"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Galvas izsekošana"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Kustinot galvu, audio mainīsies, lai izklausītos dabiskāk"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Tīkla lejupielādes ātruma ierobežojums"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Varat konfigurēt tīkla joslas platuma ātruma ierobežojumu ienākošajiem datiem. Tas tiks piemērots visiem tīkliem, kas nodrošina interneta savienojumu."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Tīkla lejupielādes ātruma ierobežojuma konfigurēšana"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Nav ierobežojuma"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Atspējot pakārtoto procesu ierobežojumus"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Atspējot ierobežojumus, kas attiecas uz sistēmas resursu izmantošanu lietotņu pakārtotajiem procesiem"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Iespējot piezīmju funkcionalitāti piespiedu kārtā"</string>
    <string name="enable_notes_role_summary" msgid="136916915155048249">"Iespējot piezīmju veikšanas sistēmas integrāciju, izmantojot piezīmju funkcionalitāti. Ja piezīmju funkcionalitāte jau ir iespējota, netiek veiktas nekādas darbības."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Apraide"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Lietotnes <xliff:g id="CURRENTAPP">%1$s</xliff:g> apraide"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Klausieties tuvumā atskaņotas apraides."</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Apraidiet multividi uz tuvumā esošām ierīcēm vai klausieties citu atpraides."</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Apraides"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Klausīšanās"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Meklēt apraides"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Pamest apraidi"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Skenēt QR kodu"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Ievadiet paroli"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Nevar izveidot savienojumu. Mēģiniet vēlreiz."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Nepareiza parole"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Nevar pievienoties apraidei."</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Lai sāktu klausīties, centrējiet tālāk norādīto kvadrātkodu."</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Kvadrātkoda formāts nav derīgs."</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Pārveidot par eSIM karti"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Pārsūtīt eSIM karti uz citu ierīci"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# lietotne}zero{# lietotņu}one{# lietotne}other{# lietotnes}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Fonā instalētās lietotnes"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Ierīces ražotājs var fonā instalēt ierīcē lietotnes vai atļaut to darīt mobilo sakaru operatoram un citiem partneriem.\n\nŠeit norādītās lietotnes nav nepieciešamas normālai ierīces darbībai. Varat atinstalēt lietotnes, ko nevēlaties paturēt."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Fonā nav instalēta neviena lietotne"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Atinstalēt lietotni"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Pēdējā # mēneša laikā instalētās lietotnes}zero{Pēdējo # mēnešu laikā instalētās lietotnes}one{Pēdējā # mēneša laikā instalētās lietotnes}other{Pēdējo # mēnešu laikā instalētās lietotnes}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Pirms vairāk nekā # mēneša instalētās lietotnes}zero{Pirms vairāk nekā # mēnešiem instalētās lietotnes}one{Pirms vairāk nekā # mēneša instalētās lietotnes}other{Pirms vairāk nekā # mēnešiem instalētās lietotnes}}"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Pirksta nospieduma sensors"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Zibpaziņojumi"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Par zibpaziņojumiem"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Izslēgt"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Ieslēgta/kameras zibspuldze"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Ieslēgta/ekrāna mirgošana"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Ieslēgta/kameras zibspuldze un ekrāna mirgošana"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Kad saņemsiet paziņojumus vai tiks atskaņoti signāli, kameras zibspuldze vai ekrāns mirgos."</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Kad saņemsiet paziņojumus vai tiks atskaņoti signāli, ekrāns mirgos."</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Apdomīgi izmantojiet zibpaziņojumus, ja esat jutīgs pret gaismu."</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"mirgošana, indikators, vājdzirdība, nedzirdība"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Priekšskatīt"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Kameras zibspuldze"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Ekrāna mirgošana"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Ekrāna mirgošanas krāsa"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Zila"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Gaiši debesszila"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Ciānzila"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Pavasara zaļa"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Zaļa"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Dzeltenzaļa"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Dzeltena"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranža"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Sarkana"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Sārta"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Fuksīnsarkana"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violeta"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Gatavs"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Atcelt"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrasts"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standarta"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Vidējs"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Augsts"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Šo lietotni var atvērt tikai vienā logā"</string>
</resources>
