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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Da"</string>
    <string name="no" msgid="5541738710521607130">"Nu"</string>
    <string name="create" msgid="986997212165228751">"Creează"</string>
    <string name="allow" msgid="3763244945363657722">"Permite"</string>
    <string name="deny" msgid="7326117222944479942">"Refuză"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Activează"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Necunoscut"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Atinge pentru a afișa informații"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Mai ai de parcurs # pas pentru a deveni dezvoltator.}few{Mai ai de parcurs # pași pentru a deveni dezvoltator.}other{Mai ai de parcurs # de pași pentru a deveni dezvoltator.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Ai devenit dezvoltator!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Nu mai este nevoie, ești deja dezvoltator."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Mai întâi activează opțiunile pentru dezvoltatori."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistem"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"În aria de acoperire"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"În afara ariei de acoperire"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio oprit"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Nu se utilizează roamingul"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Deconectată"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Se conectează"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Conectat"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Suspendat"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Necunoscut"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Previzualizare"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Micșorează"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Mărește"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Întotdeauna"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Ecranul frontal se activează când pliezi dispozitivul"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Numai jocuri, videoclipuri și altele"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Ecranul frontal se activează pentru aplicațiile care împiedică intrarea ecranului în modul inactiv"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Niciodată"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Ecranul frontal se blochează când pliezi dispozitivul"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Folosește rotirea automată"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Detectarea facială folosește camera foto frontală pentru a îmbunătăți precizia rotirii automate. Imaginile nu sunt niciodată stocate sau trimise la Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Vizibil pt. toate dispoz. Bluetooth din apropiere (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Vizibil pt. toate dispoz. Bluetooth din apropiere"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nu este vizibil pentru alte dispozitive Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Vizibil numai pe dispozitivele asociate"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Dispozitive Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Numele dispozitivului"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Redenumește acest dispozitiv"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Redenumește"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Deconectezi dispozitivul?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Asociază un nou dispozitiv"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Urechea dreaptă"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Urechea stângă"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Asociază cealaltă ureche"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Aparatul auditiv stâng este conectat.\n\nCa să-l asociezi pe cel drept, verifică dacă este pornit și gata de asociat."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Aparatul auditiv drept este conectat.\n\nCa să-l asociezi pe cel stâng, verifică dacă este pornit și gata de asociat."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Asociază urechea dreaptă"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Asociază urechea stângă"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Pentru toate aparatele auditive disponibile"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Setări pentru aparate auditive"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Comandă rapidă, compatibilitate cu aparatele auditive"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Pentru acest dispozitiv"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Ieșire audio"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Despre ieșirea audio"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Transmite sunetele spre dispozitivul auditiv sau spre difuzorul telefonului"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Similare"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Tonul de sonerie și alarmele"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Sonorul în timpul apelurilor"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Media"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Notificări și sunete de sistem"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"În mod prestabilit, ieșirea audio este stabilită de fiecare aplicație"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Dispozitiv Bluetooth nedenumit"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Se caută dispozitive"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Niciun dispozitiv Bluetooth în apropiere."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Solicitare de conectare prin Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Solicitare de asociere"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Atinge pentru a asocia cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth este dezactivat"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Atinge pentru a-l activa"</string>
    <string name="device_picker" msgid="2427027896389445414">"Alege dispozitivul Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> încearcă să activeze Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> încearcă să dezactiveze Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"O aplicație încearcă să activeze Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"O aplicație încearcă să dezactiveze Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Se activează Bluetooth…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Se dezactivează Bluetooth..."</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Solicitare de conectare Bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Solicitarea accesului la agendă"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Solicitarea accesului la mesaje"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Vizibil ca „<xliff:g id="DEVICE_NAME">^1</xliff:g>” pentru alte dispozitive"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Activează Bluetooth ca să te conectezi la alte dispozitive."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Dispozitivele tale"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Asociază un nou dispozitiv"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Dezactivează descărcarea prin hardware cu Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Dezactivează descărcarea prin hardware cu Bluetooth LE audio"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Repornești dispozitivul?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Trebuie să repornești dispozitivul pentru a modifica setarea."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Repornește"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Anulează"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Dezactivează Bluetooth LE Audio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Dezactivează funcția Bluetooth LE Audio dacă dispozitivul acceptă capacitățile de hardware LE Audio."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Comutator LE Audio în Detalii dispozitiv"</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Activează Lista cu acces permis pentru Bluetooth LE Audio"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Activează funcția Listă cu acces permis pentru Bluetooth LE Audio."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Dispozitive media"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Dispozitive de apel"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Alte dispozitive"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Dispozitive salvate"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth se va activa pentru asociere"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Preferințe pentru conexiune"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Conectat anterior"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Funcția Bluetooth activată"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Afișează-le pe toate"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Creion"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Apăsarea butonului creionului"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (profil de serviciu)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Scrie în câmpurile text"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignoră toate apăsările de butoane ale creionului"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Creion"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Data și ora"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Șterge"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Port proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Evită utilizarea unui proxy pentru"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Restabilește valorile prestabilite"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Terminat"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Nume de gazdă proxy"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Atenție"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Numele de gazdă introdus nu este valid."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Lista de excludere introdusă nu este formatată corect. Introdu o listă cu valori separate prin virgulă pentru domeniile excluse."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Trebuie să completezi câmpul pentru port."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Câmpul pentru port trebuie să fie necompletat în situația în care câmpul pentru gazdă este necompletat."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Portul introdus nu este valid."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Proxy-ul HTTP este utilizat de browser, dar nu poate fi utilizat de alte aplicații."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"Adresă URL fișier PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Dă ping adresei IPv4 a numelui de gazdă (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Test client HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Fă testul de ping"</string>
    <string name="skip_label" msgid="6380034601349015895">"Omite"</string>
    <string name="next_label" msgid="1248293387735652187">"Înainte"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Limbi"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Ordinea preferată a limbilor"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Limba sistemului"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Elimină"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Adaugă o limbă"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Limbă"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Limba preferată"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Limbile aplicațiilor"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Setează limba pentru fiecare aplicație"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Limba aplicației"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Limbi sugerate"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Toate limbile"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Limba sistemului"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Prestabilit de sistem"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Selectarea limbii pentru această aplicație din Setări nu este disponibilă."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Limba poate fi alta decât limbile disponibile în aplicație. Este posibil ca unele aplicații să nu accepte această setare."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Setează limba pentru fiecare aplicație."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Sistemul, aplicațiile și site-urile folosesc prima limbă acceptată dintre limbile preferate."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Ca să selectezi o limbă pentru fiecare aplicație, accesează setările de limbă ale aplicației"</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Află mai multe despre limbile aplicațiilor"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Schimbi limba sistemului la %s?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Setările dispozitivului și preferințele regionale se vor modifica."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Schimbă"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s nu este disponibilă"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Limba nu poate fi folosită ca limbă a sistemului, dar ai indicat aplicațiilor și site-urilor că preferi această limbă."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Preferințe regionale"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Setează preferințele pentru unități și cifre"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Setează preferințele regionale pentru ca aplicațiile să-ți poată personaliza experiența."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Aplicațiile vor folosi preferințele tale regionale, dacă este posibil."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatură"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Prima zi a săptămânii"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Preferințe numerice"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Folosește setarea prestabilită"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Duminică"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Luni"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Marți"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Miercuri"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Joi"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Vineri"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Sâmbătă"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Dacă o aplicație nu acceptă preferințele regionale, aceasta va folosi setările prestabilite pentru codul local."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Află mai multe despre preferințele de limbă"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Elimini limba selectată?}few{Elimini limbile selectate?}other{Elimini limbile selectate?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Textul va fi afișat în altă limbă."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Nu pot fi eliminate toate limbile"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Păstrează cel puțin o limbă preferată"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Nedisponibilă ca limbă de sistem"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Mută în sus"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Mută în jos"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Mută sus"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Mută jos"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Elimină limba"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Alegeți activitatea"</string>
    <string name="cancel" msgid="5780102414089664898">"Anulează"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Șterge"</string>
    <string name="save" msgid="3125033126936493822">"Salvează"</string>
    <string name="done" msgid="7497982645646431310">"Terminat"</string>
    <string name="apply" msgid="7834684883190163536">"Aplică"</string>
    <string name="share" msgid="8502235338607613795">"Distribuie"</string>
    <string name="add" msgid="8335206931421683426">"Adaugă"</string>
    <string name="remove" msgid="1028414219245072102">"Elimină"</string>
    <string name="settings_label" msgid="943294133671632976">"Setări"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Setări"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Comandă rapidă pentru setări"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Mod Avion"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Wireless și rețele"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Conectează-te la servicii de date în roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Conectează-te la serviciile de date în roaming"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Se pot aplica tarife de roaming."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Setează ora automat"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Setează automat"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Locația va fi folosită pentru setarea fusului orar când acest comutator este activat"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Folosește codul local prestabilit"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Folosește formatul de 24 de ore"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Oră"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Formatul orei"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Fus orar"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Selectează un fus orar"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Dată"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Caută o regiune"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Regiune"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Selectează decalajul față de UTC"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Folosește <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> începe pe <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Folosește <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Fără oră de vară."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Ora de vară"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Ora standard"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Selectează după regiune"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Select. după decalaj de la UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Blochează după dezactivarea ecranului"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> după dezactivarea ecranului"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Imediat după dezactivarea ecranului, dacă dispozitivul nu este menținut în activitate de <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"La <xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> după dezactivarea ecranului, dacă dispozitivul nu este menținut în activitate de <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Adaugă text pe ecranul de blocare"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Niciunul"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"De ex., dispozitivul Android al lui Andrei."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Locație"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Folosește locația"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Dezactivat"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{Activată – # aplicație are acces la locație}few{Activată – # aplicații au acces la locație}other{Activată – # de aplicații au acces la locație}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Se încarcă…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Aplicațiile cu permisiunea pentru Dispozitive din apropiere pot stabili poziția relativă a dispozitivelor conectate."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Accesul la locație este dezactivat pentru aplicații și servicii. Locația dispozitivului poate fi trimisă serviciilor de urgență atunci când suni sau trimiți un mesaj la un număr de urgență."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Află mai multe despre Setările privind locația."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Conturi"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Securitate"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Criptare și date de conectare"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Ecran de blocare"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Ce se afișează"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Indisponibil"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Starea de securitate"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Blocarea ecranului, Găsește-mi dispozitivul, securitatea aplicațiilor"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Securitate și confidențialitate"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Securitatea aplicației, blocarea dispozitivului, permisiuni"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Chip adăugat"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Este necesară configurarea"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Deblocare facială"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Deblocare facială pentru serviciu"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Configurarea Deblocării faciale"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Configurează Deblocarea facială"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Folosește-ți chipul pentru autentificare"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Începe"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Dacă Deblocarea facială pentru accesibilitate este dezactivată, este posibil ca unii pași de configurare să nu funcționeze corect cu TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Înapoi"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Continuă configurarea"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Folosește configurarea accesibilității"</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">"Anulează"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nu, mulțumesc"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Accept"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Mai multe"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Deblochează folosindu-ți chipul"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Permite deblocarea facială"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Folosește-ți chipul pentru autentificare"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Folosește-ți chipul ca să deblochezi telefonul sau să aprobi achiziții.\n\nNotă: nu îți poți folosi chipul ca să deblochezi acest dispozitiv. Pentru informații suplimentare, contactează administratorul organizației."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Folosește-ți chipul ca să deblochezi telefonul, să autorizezi achiziții sau să te conectezi la aplicații"</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">"Centrează-ți fața în cerc"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Omite"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Ai adăugat numărul maxim de chipuri"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Nu se pot adăuga mai multe chipuri"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Înregistrarea nu a fost finalizată"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"OK"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Timpul limită pentru înregistrarea feței a expirat. Încearcă din nou."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Înregistrarea feței nu a funcționat."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Gata. Arată bine."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Terminat"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Îmbunătățește performanța Deblocării faciale"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Reconfigurează Deblocarea facială"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Reconfigurează Deblocarea facială"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Îmbunătățește securitatea și performanța"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Configurezi Deblocarea facială"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Șterge modelul facial actual pentru a reconfigura Deblocarea facială.\n\nModelul facial se va șterge definitiv și în siguranță.\n\nDupă ștergere, vei avea nevoie de codul PIN, de model sau de parolă să îți deblochezi telefonul sau să te autentifici în aplicații."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Șterge modelul facial actual pentru a reconfigura Deblocarea facială.\n\nModelul facial se va șterge definitiv și în siguranță.\n\nDupă ștergere, vei avea nevoie de amprentă, de codul PIN, de model sau de parolă să-ți deblochezi telefonul sau să te autentifici în aplicații."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Folosește Deblocarea facială pentru"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Când folosești Deblocarea facială"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Ochii trebuie să fie deschiși"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Pentru a debloca telefonul, trebuie să ai ochii deschiși"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Se solicită întotdeauna confirmarea"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Când folosești Deblocarea facială în aplicații, solicită întotdeauna confirmarea"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Șterge modelul facial"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Configurează Deblocarea facială"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Ștergi modelul facial?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Modelul facial se va șterge definitiv și în siguranță.\n\nDupă ștergere, vei avea nevoie de codul PIN, de model sau de parolă ca să-ți deblochezi telefonul sau să te autentifici în aplicații."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Modelul facial se va șterge definitiv și în siguranță.\n\nDupă ștergere, vei avea nevoie de codul PIN, de model sau de parolă ca să îți deblochezi telefonul."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Modelul facial se va șterge definitiv și în siguranță.\n\nDupă ștergere, vei avea nevoie de amprentă, de codul PIN, de model sau de parolă să îți deblochezi telefonul sau să te autentifici în aplicații."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Modelul facial se va șterge definitiv și în siguranță.\n\nDupă ștergere, vei avea nevoie de amprentă, de codul PIN, de model sau de parolă ca să îți deblochezi telefonul."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Folosește Deblocarea facială ca să-ți deblochezi telefonul"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Amprentă"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Amprentă"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Când folosești Deblocarea cu amprenta"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Amprentă pentru lucru"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Adaugă o amprentă"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Amprentă adăugată}few{# amprente adăugate}other{# de amprente adăugate}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Este necesară configurarea"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Configurează amprenta"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Permite deblocarea cu amprenta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Folosește amprenta"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Află mai multe despre Deblocarea cu amprenta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Tu deții controlul"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Tu și copilul tău dețineți controlul"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Reține"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Folosește amprenta ca să deblochezi telefonul sau să aprobi achizițiile.\n\nNotă: nu îți poți folosi amprenta ca să deblochezi acest dispozitiv. Pentru informații suplimentare, contactează administratorul organizației."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Anulează"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nu, mulțumesc"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Accept"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Omiți amprenta?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Setarea amprentei durează doar un minut sau două. Dacă ignori acest pas acum, poți adăuga amprenta mai târziu din setări."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Când vezi pictograma, folosește amprenta pentru autentificare, de exemplu, când te conectezi la aplicații sau aprobi o achiziție"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Reține"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Cum funcționează"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Deblocarea cu amprenta creează un model unic al amprentei tale pentru a-ți confirma identitatea. Pentru a crea acest model de amprentă, în timpul configurării vei captura imagini ale amprentei tale din diferite poziții."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Deblocarea cu amprenta creează un model unic al amprentei copilului tău pentru a-i confirma identitatea. Pentru a crea acest model de amprentă în timpul configurării, va captura imagini ale amprentei sale din diferite poziții."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Pentru rezultate optime, folosește o protecție pentru ecran care este certificată Made for Google. Este posibil ca amprenta să nu funcționeze cu alte protecții pentru ecran."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Pentru rezultate optime, folosește o protecție pentru ecran care este certificată Made for Google. Este posibil ca amprenta copilului să nu funcționeze cu alte protecții pentru ecran."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Deblocare cu ceasul"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Când configurezi Deblocarea facială și Deblocarea cu amprenta, telefonul îți va solicita amprenta atunci când porți mască sau te afli într-o zonă întunecoasă.\n\nPoți folosi ceasul pentru deblocare când nu ți se recunoaște fața sau amprenta."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Poți folosi ceasul pentru deblocare când nu ți se recunoaște amprenta."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Poți folosi ceasul pentru deblocare când nu ți se recunoaște fața."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Folosește amprenta sau ceasul pentru a"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Folosește fața sau ceasul pentru a"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Folosește fața, amprenta sau ceasul pentru a"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Folosește ceasul pentru a"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Folosește fața sau ceasul"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Folosește amprenta sau ceasul"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Folosește fața, amprenta sau ceasul"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Folosește ceasul"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Configurează Deblocarea facială sau Deblocarea cu amprenta"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Poți folosi deblocarea cu ceasul când nu ți se recunoaște fața sau amprenta"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Mai întâi, configurează Deblocarea cu amprenta"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Poți folosi ceasul pentru deblocare când nu ți se recunoaște amprenta"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Mai întâi, configurează Deblocarea facială"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Poți folosi ceasul pentru deblocare când nu ți se recunoaște fața"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Configurează"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Au fost adăugate amprenta și <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Au fost adăugate amprentele și <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Au fost adăugate fața și <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Au fost adăugate fața, amprenta și <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Au fost adăugate fața, amprentele și <xliff:g id="WATCH">%s</xliff:g>"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Deblocare cu amprenta și Deblocare facială"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Deblocarea facială și cu amprenta pentru serviciu"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Este necesară configurarea"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Fața și amprentele au fost adăugate"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Fața și amprenta au fost adăugate"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Când configurezi Deblocarea facială și Deblocarea cu amprenta, telefonul îți va solicita amprenta atunci când porți mască sau te afli într-o zonă întunecoasă"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Moduri de a debloca"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Folosește chipul sau amprenta pentru următoarele"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Deblochează telefonul"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Confirmă-ți identitatea în aplicații"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Folosește chipul"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Folosește amprenta"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Folosește chipul sau amprenta"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Nu poți configura Deblocarea facială"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Ieși din ecranul împărțit pentru a configura Deblocarea facială"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Nu se poate configura amprenta"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Ieși din ecranul împărțit pentru a configura Deblocarea cu amprenta"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Omiți blocarea ecranului?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Omite oricum"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Înapoi"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Omite"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Anulează"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Atinge senzorul"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Atinge butonul de pornire fără a-l apăsa"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Cum să-ți configurezi amprenta"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Se află pe partea din spate a telefonului. Folosește degetul arătător."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Senzorul de amprentă este integrat în ecran. Îți vei înregistra amprenta pe ecranul următor."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Începe"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Mișcă degetul pe ecran pentru a-l găsi. Atinge lung senzorul de amprentă."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Imagine cu dispozitivul și poziția senzorului de amprentă"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nume"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Încearcă din nou"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Șterge"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Atinge senzorul"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Pune degetul pe senzor și ridică-l după ce simți o vibrație"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Ține amprenta pe senzor până când simți o vibrație"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Fără să apeși butonul, ține amprenta pe senzor până când simți o vibrație.\n\nMișcă puțin degetul de fiecare dată când simți vibrația. Astfel vei putea captura o parte mai mare din amprentă."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Atinge lung senzorul de amprentă"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Ridică, apoi atinge din nou"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Încă o dată"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Atinge repetat pictograma amprentă"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Ridică degetul și atinge din nou pentru a adăuga toate părțile amprentei"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Atinge lung de fiecare dată când se mișcă pictograma amprentei. Astfel vei putea captura o parte mai mare din amprentă."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Așează vârful degetului pe senzor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Așază marginea din stânga a degetului"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Plasează marginea din dreapta a degetului"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Așază centrul vârfului degetului pe senzor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Așază vârful degetului pe senzor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Așază marginea din stânga a degetului pe senzor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Așază partea dreaptă a vârfului degetului pe senzor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Așează partea laterală a degetului pe senzor și menține, apoi procedează la fel cu cealaltă parte"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Astfel vei putea captura o parte mai mare din amprentă"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Înregistrarea amprentei: <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Înregistrare: <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Înregistrare amprentă: <xliff:g id="PERCENTAGE">%d</xliff:g> %%"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Amprentă adăugată"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Atinge pentru a debloca oricând"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Atinge senzorul pentru deblocare, chiar și când ecranul este oprit. Astfel, crește riscul de deblocare accidentală."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Ecran, Deblocare"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Mai târziu"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Ridică, apoi atinge din nou"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Așează partea laterală a degetului pe senzor și menține, apoi procedează la fel cu cealaltă parte"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Omiți configurarea amprentei?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Ai ales ca amprenta să fie una dintre modalitățile de deblocare a telefonului. Dacă omiți acum această etapă, va trebui să o configurezi mai târziu. Configurarea durează în jur de un minut."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Omiți configurarea pentru <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Omiți configurarea PIN-ului?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Omiți configurarea PIN-ului și a chipului?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Omiți configurarea PIN-ului și a amprentei?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Omiteți configurarea PIN-ului, a chipului și a amprentei?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Omiți configurarea parolei?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Omiți configurarea parolei și a chipului?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Omiți configurarea parolei și a amprentei?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Omiți configurarea parolei, a chipului și a amprentei?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Omiți configurarea modelului?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Omiți configurarea modelului și a chipului?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Omiți configurarea modelului și a amprentei?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Omiți configurarea modelului, a chipului și a amprentei?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Configurează blocarea ecranului"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Gata"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Hopa, acela nu este senzorul"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Atinge senzorul de pe spatele telefonului. Folosește degetul arătător."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Nu se poate finaliza configurarea amprentei"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Poți să încerci din nou acum sau să configurezi amprenta mai târziu în Setări."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Poți să încerci din nou acum sau să configurezi amprenta mai târziu."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Configurarea amprentei a expirat"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Poți configura amprenta mai târziu în Setări."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"A apărut o eroare. Poți configura amprenta mai târziu din Setări."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Poți configura amprenta mai târziu."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"A apărut o eroare. Poți configura amprenta mai târziu."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Adaugă altă amprentă"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Înainte"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Opțiunea pentru blocarea ecranului este dezactivată. Ca să afli mai multe, contactează administratorul organizației."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Poți folosi în continuare amprenta ca să autorizați achizițiile și accesul la aplicații."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Ridică degetul, apoi atinge senzorul din nou"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Nu se poate folosi senzorul de amprentă"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Vizitează un furnizor de servicii de reparații."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Mai multe setări de securitate"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Blocarea profilului de serviciu, criptarea și altele"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Criptarea, datele de conectare și altele"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"securitate, mai multe setări de securitate, mai multe setări, setări de securitate avansate"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Mai multe setări de confidențialitate"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Mai multe setări pentru securitate și confidențialitate"</string>
    <string name="security_header" msgid="961514795852103424">"Securitate"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Confidențialitate"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Profil de serviciu"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Poți să adaugi până la <xliff:g id="COUNT">%d</xliff:g> amprente"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Ai adăugat numărul maxim de amprente digitale"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Nu se mai pot adăuga amprente digitale"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Șterge <xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Nu vei putea să folosești amprenta ca să deblochezi profilul de serviciu, să autorizezi achiziții sau să te conectezi la aplicațiile pentru lucru."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Criptare"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Criptat"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Setează o blocare a ecranului"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Pentru securitate sporită, setează un PIN, un model sau o parolă pentru acest dispozitiv."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Setează blocarea ecranului"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Setează o blocare a ecranului"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Pentru securitate sporită, setează un PIN, un model sau o parolă pentru acest dispozitiv."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Securizează telefonul"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Adaugă amprenta pentru deblocare"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Opțiuni blocare ecran"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Alege blocarea ecranului"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Alege o nouă blocare a ecranului"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Alege o blocare pentru aplicațiile de lucru"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Alege o nouă blocare pentru serviciu"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Pentru mai multă siguranță, configurează o blocare a ecranului de backup"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Alege metoda de blocare a ecranului de backup"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Dacă uitați parola blocării ecranului, administratorul IT nu o poate reseta."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Setează o blocare separată pentru serviciu"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Dacă uiți blocarea, solicită-i administratorului IT să o reseteze"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opțiuni de blocare a ecranului"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opțiuni de blocare a ecranului"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Deblocare prin confirmare automată"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Deblochează automat la introducerea codului PIN corect de minimum șase cifre. Această opțiune este mai puțin sigură decât dacă atingi Enter pentru a confirma."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Confirmă automat codul PIN corect"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Confirmarea codului PIN prin atingerea tastei Enter este mai sigură decât folosirea confirmării automate"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Introdu codul PIN al dispozitivului pentru a activa confirmarea automată"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Introdu codul PIN al dispozitivului pentru a dezactiva confirmarea automată"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Blocarea ecranului"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Blocarea profilului de serviciu"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Fără"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Glisare"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Model"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Parolă"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Nu acum"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Blocarea actuală a ecranului"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Modelul • Amprenta"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"Codul PIN • Amprenta"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Parola • Amprenta"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Continuă fără amprentă"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Modelul • Fața"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"Codul PIN • Fața"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Parola • Fața"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Continuă fără Deblocarea facială"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Continuă fără amprentă sau chip"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Fără"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Glisare"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Model"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Parolă"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Ștergi blocarea ecranului?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Elimini protecția profilului?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Un model îți protejează telefonul dacă este pierdut sau furat"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Un model îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>În plus, această funcție șterge modelul cu amprentă stocat pe dispozitiv. Nu vei putea să îți folosești amprenta pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Un model îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>În plus, modelul facial va fi șters definitiv și în siguranță. Nu vei putea să-ți folosești fața pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Un model îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>Această funcție șterge modelul cu amprentă stocat pe dispozitiv. În plus, modelul facial va fi șters definitiv și în siguranță. Nu vei putea să folosești fața sau amprenta pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"Un PIN îți protejează telefonul dacă este pierdut sau furat"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"Un PIN îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>În plus, această funcție șterge modelul cu amprentă stocat pe dispozitiv. Nu vei putea să-ți folosești amprenta pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"Un PIN îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>În plus, modelul facial va fi șters definitiv și în siguranță. Nu vei putea să-ți folosești fața pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"Un PIN îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>Această funcție șterge modelul cu amprentă stocat pe dispozitiv. În plus, modelul facial va fi șters definitiv și în siguranță. Nu vei putea să folosești fața sau amprenta pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"O parolă îți protejează telefonul dacă este pierdut sau furat"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"O parolă îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>În plus, această funcție șterge modelul cu amprentă stocat pe dispozitiv. Nu vei putea să-ți folosești amprenta pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"O parolă îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>În plus, modelul facial va fi șters definitiv și în siguranță. Nu vei putea să îți folosești fața pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"O parolă îți protejează telefonul dacă este pierdut sau furat.<xliff:g id="EMPTY_LINE">

</xliff:g>Această funcție șterge modelul cu amprentă stocat pe dispozitiv. În plus, modelul facial va fi șters definitiv și în siguranță. Nu vei putea să folosești fața sau amprenta pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Funcțiile de protecție a dispozitivului nu vor funcționa fără blocarea ecranului."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Funcțiile de protecție a dispozitivului nu vor funcționa fără blocarea ecranului.<xliff:g id="EMPTY_LINE">

</xliff:g>În plus, această funcție șterge modelul cu amprentă stocat pe dispozitiv. Nu vei putea să-ți folosești amprenta pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Funcțiile de protecție a dispozitivului nu vor funcționa fără blocarea ecranului.<xliff:g id="EMPTY_LINE">

</xliff:g>În plus, modelul facial va fi șters definitiv și în siguranță. Nu vei putea să îți folosești fața pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Funcțiile de protecție a dispozitivului nu vor funcționa fără blocarea ecranului.<xliff:g id="EMPTY_LINE">

</xliff:g>Această funcție șterge modelul cu amprentă stocat pe dispozitiv. În plus, modelul facial va fi șters definitiv și în siguranță. Nu vei putea să folosești fața sau amprenta pentru autentificare în aplicații."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Șterge"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomandă un cod PIN sau o parolă puternică și este posibil să nu funcționeze corect fără una dintre acestea"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomandă un cod PIN sau o parolă nouă și este posibil să nu funcționeze corect fără una dintre acestea"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomandă un model, un cod PIN sau o parolă nouă și este posibil să nu funcționeze corect fără una dintre acestea"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomandă o nouă blocare a ecranului"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Încearcă din nou. Încercarea <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> din <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Datele tale vor fi șterse"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Dacă la următoarea încercare introduceți un model incorect, datele de pe acest dispozitiv vor fi șterse"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Dacă la următoarea încercare introduceți un cod PIN incorect, datele de pe acest dispozitiv vor fi șterse"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Dacă la următoarea încercare introduceți o parolă incorectă, datele de pe acest dispozitiv vor fi șterse"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Dacă la următoarea încercare introdu un model incorect, acest utilizator va fi șters"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Dacă la următoarea încercare introduci un cod PIN incorect, acest utilizator va fi șters"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Dacă la următoarea încercare introduceți o parolă incorectă, acest utilizator va fi șters"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Dacă la următoarea încercare introdu un model incorect, profilul de serviciu și datele tale vor fi șterse"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Dacă la următoarea încercare introduci un cod PIN incorect, profilul de serviciu și datele tale vor fi șterse"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Dacă la următoarea încercare introduceți o parolă incorectă, profilul de serviciu și datele tale vor fi șterse"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Trebuie să conțină cel puțin # caracter}few{Trebuie să conțină cel puțin # caractere}other{Trebuie să conțină cel puțin # de caractere}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Dacă folosești doar numere, parola trebuie să conțină cel puțin o cifră}few{Dacă folosești doar numere, parola trebuie să conțină cel puțin # cifre}other{Dacă folosești doar numere, parola trebuie să conțină cel puțin # de cifre}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{Codul PIN trebuie să aibă cel puțin # cifră}few{Codul PIN trebuie să aibă cel puțin # cifre}other{Codul PIN trebuie să aibă cel puțin # de cifre}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{Codul PIN trebuie să aibă cel puțin # cifră, dar pentru mai multă securitate, recomandăm un PIN de {minAutoConfirmLen} cifre}few{Codul PIN trebuie să aibă cel puțin # cifre, dar pentru mai multă securitate, recomandăm un PIN de {minAutoConfirmLen} cifre}other{Codul PIN trebuie să aibă cel puțin # cifre, dar pentru mai multă securitate, recomandăm un PIN de {minAutoConfirmLen} de cifre}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Trebuie să conțină mai puțin de # caracter}few{Trebuie să conțină mai puțin de # caractere}other{Trebuie să conțină mai puțin de # de caractere}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Trebuie să conțină mai puțin de # cifră}few{Trebuie să conțină mai puțin de # cifre}other{Trebuie să conțină mai puțin de # de cifre}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Administratorul dispozitivului nu permite utilizarea unui PIN recent"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Aceasta nu poate include un caracter nevalid"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Trebuie să conțină cel puțin o literă}few{Trebuie să conțină cel puțin # litere}other{Trebuie să conțină cel puțin # de litere}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Trebuie să conțină cel puțin o minusculă}few{Trebuie să conțină cel puțin # minuscule}other{Trebuie să conțină cel puțin # de minuscule}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Trebuie să conțină cel puțin o majusculă}few{Trebuie să conțină cel puțin # majuscule}other{Trebuie să conțină cel puțin # de majuscule}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Trebuie să conțină cel puțin o cifră}few{Trebuie să conțină cel puțin # cifre}other{Trebuie să conțină cel puțin # de cifre}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Trebuie să conțină cel puțin un simbol special}few{Trebuie să conțină cel puțin # simboluri speciale}other{Trebuie să conțină cel puțin # de simboluri speciale}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Trebuie să conțină cel puțin un caracter care să nu fie literă}few{Trebuie să conțină cel puțin # caractere care să nu fie litere}other{Trebuie să conțină cel puțin # de caractere care să nu fie litere}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Trebuie să conțină cel puțin un caracter care să nu fie cifră}few{Trebuie să conțină cel puțin # caractere care să nu fie cifre}other{Trebuie să conțină cel puțin # de caractere care să nu fie cifre}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Administratorul dispozitivului nu permite utilizarea unei parole recente"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Șirurile de cifre ascendente, descendente sau repetate nu sunt permise"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Confirmă"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Șterge"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Blocarea ecranului a fost schimbată deja. Încearcă din nou cu blocarea ecranului nouă."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Anulează"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Înainte"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Aplicații pentru administratorul dispozitivului"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Nicio aplicație activă"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aplicație activă}few{# aplicații active}other{# de aplicații active}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agenți de încredere"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Pentru utilizare, setează mai întâi un ecran de blocare"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Niciuna"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{Un agent de încredere activ}few{# agenți de încredere activi}other{# de agenți de încredere activi}}"</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">"Asociezi cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Adaugă un membru nou la setul coordonat existent"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Cod de asociere prin Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Introdu codul de conectare, apoi apasă pe Revino sau pe Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Codul PIN conține litere sau simboluri"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"De obicei, 0000 sau 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Trebuie să aibă 16 cifre"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Ar putea fi necesar, de asemenea, să introduci acest cod PIN pe celălalt dispozitiv."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Ar putea fi necesar, de asemenea, să introduci această parolă pe celălalt dispozitiv."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Confirmă pentru a asocia cu setul coordonat"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Permite accesul la agendă și la istoricul apelurilor"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Nu s-a putut conecta la <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dispozitive disponibile"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Conectează-te"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Deconectează"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Asociază și conectează"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Activarea Bluetooth facilitează comunicarea cu alte dispozitive Bluetooth din apropiere."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Când Bluetooth este activat, dispozitivul poate să comunice cu alte dispozitive Bluetooth din apropiere.\n\nPentru a îmbunătăți experiența dispozitivului, aplicațiile și serviciile pot să caute în continuare dispozitive din apropiere chiar și atunci când Bluetooth este dezactivat. Această opțiune poate fi folosită, de exemplu, pentru a îmbunătăți funcțiile și serviciile bazate pe locație. Poți să-ți schimbi preferințele în setările pentru căutarea prin Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Modifică"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detalii despre dispozitiv"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Setări tastatură"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Adresa Bluetooth a dispozitivului: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Adresa Bluetooth a dispozitivului: \n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Elimini dispozitivul?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Elimină asocierea"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Deconectezi aplicația?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Aplicația <xliff:g id="APP_NAME">%1$s</xliff:g> nu se va mai conecta la <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Experimental. Ameliorează calitatea audio."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Elimină dispozitivul"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Deconectează aplicația"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Numărul maxim de dispozitive audio Bluetooth conectate"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Selectează numărul maxim de dispozitive audio Bluetooth conectate"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Jurnalul de remediere a erorilor pentru stiva NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Mărește nivelul de înregistrare pentru stiva NFC"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Jurnal de remediere erori pentru furnizorii detaliați NFC"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Include alte jurnale ale furnizorilor de dispozitive în rapoartele de eroare, care pot conține informații private."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Jurnal nefiltrat NCI NFC"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Capturează pachetele NFC cu detalii, care pot conține informații private."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Repornești dispozitivul?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Înregistrarea NFC detaliată este menită exclusiv pentru dezvoltare Datele NFC suplimentare sunt incluse în rapoartele de eroare, care pot conține informații private. Repornește dispozitivul ca să schimbi setarea."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Repornește"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Proiectare"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"oglindă"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Activează ecranul wireless"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Nu s-au găsit dispozitive în apropiere."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Se conectează"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Conectat"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"Se utilizează"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Indisponibil"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opțiuni pentru ecrane wireless"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Elimină"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Gata"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nume"</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">"Conectează-te"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Accesează site-ul"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Timp rămas: <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Expiră pe <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> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> încearcă să activeze Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> încearcă să dezactiveze Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verifică bytecode-ul aplicațiilor care pot fi depanate"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Permite ART să verifice bytecode-ul pentru aplicațiile care pot fi depanate"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Rata de actualizare"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Afișează rata de actualizare a ecranului"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Solicită deblocarea dispozitivului pentru NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Pregătit să transmită conținut din aplicații prin NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Dezactivată"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Indisponibilă, deoarece NFC este oprit"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"După activarea acestei funcții, poți transmite conținutul aplicațiilor către un alt dispozitiv compatibil NFC, ținând cele două dispozitive apropiate unul de celălalt. De exemplu, poți să transmiți pagini web, videoclipuri YouTube, date de contact și multe altele.\n\nNu trebuie decât să apropii cele două dispozitive (de obicei, așezându-le spate în spate) și să atingi ecranul. Aplicația determină apoi ce poate fi transmis."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Folosiți Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Setări Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Selectează o rețea Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Se activează Wi-Fi…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Se dezactivează Wi-Fi…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Eroare"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Banda de 5 GHz nu este disponibilă în această țară"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"În modul Avion"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Notificare pentru rețelele publice"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Notifică-mă atunci când este disponibilă o rețea publică de înaltă calitate"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Activează automat Wi-Fi"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi-Fi se va reactiva automat lângă rețelele de înaltă calitate salvate, cum ar fi rețeaua ta de domiciliu"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Indisponibil pentru că este dezactivată locația. Activează "<annotation id="link">"Locația"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instalează certificate"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Pentru a îmbunătăți precizia localizării, aplicațiile și serviciile pot continua să caute rețele Wi‑Fi chiar și atunci când conexiunea Wi-Fi este dezactivată. Această permisiune poate fi folosită, de exemplu, pentru a îmbunătăți funcțiile și serviciile bazate pe locație. Poți să schimbi acest aspect din <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>setările pentru căutarea de rețele Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Pentru a îmbunătăți precizia localizării, activează căutarea de rețele Wi-Fi în <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>pentru căutarea de rețele Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Comută automat la date mobile"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Folosește datele mobile când rețeaua Wi-Fi nu are acces la internet. Este posibil să se aplice taxe pentru utilizarea datelor."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Adaugă o rețea"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Preferințe Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi se reactivează automat"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi nu se reactivează automat"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Vezi rețelele disponibile activând Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Se caută rețele…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Nu ai permisiunea să modifici rețeaua Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Activezi căutarea de rețele Wi-Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Pentru a se activa automat conexiunea Wi-Fi, trebuie mai întâi să activezi căutarea de rețele Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Căutarea de rețele Wi-Fi permite aplicațiilor și serviciilor să caute oricând rețele Wi-Fi, chiar și atunci când conexiunea Wi-Fi este dezactivată. Această opțiune poate fi folosită, de exemplu, pentru a îmbunătăți funcțiile și serviciile bazate pe locație."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Activează"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Căutare de rețele Wi-Fi activată"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Opțiuni avansate"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista drop-down Opțiuni avansate"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"extindeți"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Numele rețelei"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Introdu identificatorul SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Securitate"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Rețea ascunsă"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Dacă routerul nu transmite un ID de rețea, dar vrei să te conectezi la rețea în viitor, o poți seta ca ascunsă.\n\nAceasta ar putea crea un risc de securitate deoarece telefonul va transmite regulat semnal ca să găsească rețeaua.\n\nDacă setezi rețeaua ca ascunsă, setările pentru router nu se modifică."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Puterea semnalului"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Stare"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Viteza conexiunii la trimitere"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Viteza conexiunii la primire"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Viteză"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frecvență"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Adresă IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Salvată prin"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Date de conectare la <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Metodă EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Autentificare faza 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certificat CA"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Versiunea TLS minimă"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Starea certificatelor online"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domeniu"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certificat de utilizator"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identitate"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Identitate anonimă"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Parolă"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Afișează parola"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Banda de 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Se preferă banda de 5,0 GHz"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Setări IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Confidențialitate"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Abonament"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Vezi sau modifică abonamentul"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Adresă MAC aleatorie"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Adaugă un dispozitiv"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centrează codul QR de mai jos pentru a adăuga dispozitivul la „<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Scanează codul QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centrează codul QR de mai jos pentru a te conecta la „<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Conectează-te la Wi‑Fi scanând un cod QR"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Distribuie Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Scanează acest cod QR cu alt dispozitiv pentru a te conecta la „<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Scanează acest cod QR pentru a te conecta la „<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Încearcă din nou. Dacă problema persistă, contactează producătorul dispozitivului"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"A apărut o eroare"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Asigură-te că dispozitivul este conectat la priză, încărcat și pornit"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Asigură-te că dispozitivul este conectat la priză, încărcat și pornit. Dacă problema persistă, contactează producătorul dispozitivului"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Adăugarea „<xliff:g id="SSID">%1$s</xliff:g>” nu este acceptată de acest dispozitiv"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Încearcă să muți dispozitivul mai aproape de router/punctul de acces Wi‑Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Verifică parola și încearcă din nou"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Contactează producătorul dispozitivului"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Verifică conexiunea și încearcă din nou"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Alege rețeaua"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Pentru a vă conecta dispozitivul, alegeți o rețea"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Adaugi acest dispozitiv la „<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Dispozitivul a primit acces la rețeaua Wi‑Fi"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Adaugă alt dispozitiv"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Alege o altă rețea"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Nu s-a putut adăuga dispozitivul"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"S-a găsit un dispozitiv"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Se permite accesul la Wi-Fi pentru acest dispozitiv…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Se conectează…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Permite accesul la hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Confirmă că ești tu."</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Parola rețelei Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Parolă hotspot: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Conectare automată"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Permite conectarea la această rețea când se află în aria de acoperire"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Adaugă un dispozitiv"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Folosește un cod QR pentru a adăuga un dispozitiv la această rețea"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"Codul QR nu are un format valid"</string>
    <string name="retry" msgid="7542103800274026915">"Încearcă din nou"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Permite accesul și altor utilizatori ai dispozitivului"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nu s-a schimbat)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Selectează"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Au fost adăugate mai multe certificate)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Folosește certificate de sistem"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Nu se furnizează"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Trust on First Use"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Numele rețelei este prea lung."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Trebuie să specifici un domeniu."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Este obligatoriu un certificat."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Pentru a îmbunătăți precizia locației, precum și pentru alte scopuri, <xliff:g id="APP_NAME">%1$s</xliff:g> solicită permisiunea să activeze scanarea rețelelor, chiar și atunci când rețeaua Wi-Fi este dezactivată.\n\nPermiți acest lucru pentru toate aplicațiile care solicită scanarea?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Pentru a îmbunătăți precizia locației, dar și în alte scopuri, o aplicație necunoscută solicită activarea scanării rețelei, chiar și când rețeaua Wi-Fi este dezactivată.\n\nAcorzi permisiune pentru toate aplicațiile care solicită scanarea?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Permite"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Respinge"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Această rețea nu are acces la internet. Menții conexiunea?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Unele aplicații și servicii pot să nu funcționeze din cauza conectivității limitate. Folosești oricum?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Nu mai întreba pentru această rețea"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Rețeaua Wi-Fi nu este conectată la internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Poți comuta la rețeaua mobilă ori de câte ori conexiunea Wi-Fi este slabă. Este posibil să se aplice taxe pentru utilizarea datelor."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Comută la rețeaua mobilă"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Rămâi pe Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Nu afișa din nou"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Conectează-te"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Conexiunea prin Wi-Fi este activată"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Te-ai conectat la <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Se conectează la <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Se conectează…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Nu s-a putut stabili conexiunea la rețea"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Rețeaua este în afara ariei de acoperire"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Elimină"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Modifică"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Nu s-a putut elimina rețeaua"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Salvează"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Nu s-a putut salva rețeaua"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Anulează"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Elimini rețeaua?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{O rețea}few{# rețele}other{# de rețele}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{Un abonament}few{# abonamente}other{# de abonamente}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{O rețea și un abonament}few{# rețele și abonamente}other{# de rețele și abonamente}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Adresa MAC a dispozitivului"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Adresă MAC aleatorie"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Adresă MAC randomizată (ultima folosită)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detaliile rețelei"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Mască de subrețea"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Tip"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Adrese IPv6"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Detaliile dispozitivului hotspot"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Sursa de internet"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi-Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Date mobile"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%s</xliff:g> – Se încarcă"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Conexiune hotspot"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Puterea conexiunii"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Rețele salvate"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Abonamente"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Alte rețele"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Introdu o adresă IP validă."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Introdu o adresă gateway validă."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Introdu o adresă DNS validă."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Introdu prefix rețea din 0 – 32 caractere."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (dacă nu este înlocuit de un DNS privat)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (dacă nu este înlocuit de un DNS privat)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Lungime prefix rețea"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Caută dispozitive"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Se caută…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Redenumește dispozitivul"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Dispozitive asociate"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Grupuri reținute"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Conectarea nu s-a putut realiza."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Dispozitivul nu a fost redenumit."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Deconectezi?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Dacă te deconectezi, conexiunea cu <xliff:g id="PEER_NAME">%1$s</xliff:g> se va încheia."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Dacă te deconectezi, conexiunea cu <xliff:g id="PEER_NAME">%1$s</xliff:g> și cu alte <xliff:g id="PEER_COUNT">%2$s</xliff:g> dispozitive se va încheia."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Anulezi invitația?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Vrei să anulezi invitația de conectare cu <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Elimini acest grup?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Hotspot Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Nu se permite altor dispozitive accesul la conexiunea de internet sau la conținut"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Nu s-a setat nicio parolă"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Nume hotspot"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Parolă hotspot"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Banda AP"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Dezactivează automat hotspotul"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Când nu este conectat niciun dispozitiv"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Extinde compatibilitatea"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Ajută alte dispozitive să găsească acest hotspot. Reduce viteza conexiunii hotspotului."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Ajută alte dispozitive să găsească acest hotspot. Mărește utilizarea bateriei."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Viteză și compatibilitate"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz / compatibil cu majoritatea dispozitivelor"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / Compatibil cu multe dispozitive"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / Compatibil cu câteva dispozitive"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 și 5 GHz / Compatibil cu majoritatea dispozitivelor"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Alege o frecvență pentru hotspot. Frecvența influențează viteza conexiunii și tipurile de dispozitive care pot detecta hotspotul."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Frecvența preferată"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Viteze mai mici. Compatibil cu majoritatea dispozitivelor"</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Viteze mari. Compatibil cu multe dispozitive."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 și 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Viteze mari. Acest hotspot dual-band este compatibil cu majoritatea dispozitivelor."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Cele mai mari viteze. Compatibil cu câteva dispozitive."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Nu este disponibilă în țara sau regiunea ta"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Dacă frecvența preferată nu este disponibilă, hotspotul poate folosi alta. Setările de securitate ale hotspotului se pot modifica dacă schimbi frecvența."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Nu este disponibilă cu 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Setările de securitate se pot schimba dacă schimbi frecvența hotspotului"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Hotspot instant"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Activat"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Dezactivat"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Se activează hotspotul..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Se dezactivează hotspotul..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Tetheringul nu este disponibil"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Contactează operatorul pentru detalii"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> este activ"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Salvezi rețeaua?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Se salvează…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Salvată"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Nu se poate salva. Încearcă din nou."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Salvezi rețelele?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Se salvează <xliff:g id="NUMBER">%d</xliff:g> rețele…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Rețelele s-au salvat"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Apelare prin Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Activează apelarea prin Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Activează apelarea prin Wi-Fi pentru acoperire mai mare"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Preferință pentru apelare"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Preferință pentru apelare"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Preferințe privind roamingul"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Preferințe privind roamingul"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Date mobile"</item>
    <item msgid="3027927219952052398">"Numai 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">"Date mobile"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Dacă rețeaua Wi‑Fi nu este disponibilă, folosește rețeaua mobilă"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Dacă rețeaua mobilă nu este disponibilă, folosește Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Apelează prin Wi‑Fi. Dacă pierzi conexiunea Wi-Fi, apelul se încheie."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Când este activată Apelarea prin Wi-Fi, telefonul poate să redirecționeze apelurile prin rețelele Wi-Fi sau prin rețeaua operatorului, în funcție de preferință și de semnalul cu cea mai mare intensitate. Înainte să activezi această funcție, consultă-ți operatorul în privința taxelor și a altor detalii.<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">"Adresă de urgență"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Folosită ca locație când efectuați un apel de urgență prin Wi-Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Află mai multe"</annotation>" despre funcțiile DNS-ului privat"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Activat"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Activează Apelarea prin Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Activează Apelarea prin Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Deconectat de la <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Sunete și vibrații"</string>
    <string name="account_settings" msgid="255404935489127404">"Conturi"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Conturi cu profil de serviciu – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Conturi cu profil personal"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Clonează conturile de profil"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Cont de serviciu – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Cont personal – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Caută"</string>
    <string name="display_settings" msgid="7197750639709493852">"Afișaj"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Rotire automată a ecranului"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Dezactivată"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Activată"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Activată – În funcție de chip"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Detectare facială"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Află mai multe despre rotirea automată"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Rezoluția ecranului"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Rezoluție înaltă"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Rezoluție maximă"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Rezoluția maximă consumă mai multă baterie. Dacă schimbi rezoluția, unele aplicații pot reporni."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Selectată"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Culori"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Naturale"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Intensificate"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Saturat"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptive"</string>
    <string name="brightness" msgid="6216871641021779698">"Nivel de luminozitate"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Luminozitate adaptivă"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Luminozitatea ecranului se va adapta automat la mediul și activitățile tale. Poți să muți manual glisorul pentru a ajuta luminozitatea adaptivă să îți învețe preferințele."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Activată"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Dezactivat"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Balansul de alb al ecranului"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Continuă să folosești aplicațiile după pliere"</string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Ridică automat rata de actualizare de la 60 la <xliff:g id="ID_1">%1$s</xliff:g> Hz pentru unele tipuri de conținut. Mărește utilizarea bateriei."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Forțează rata maximă de actualizare"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Cea mai ridicată rată de actualizare, pentru receptivitate la atingere îmbunătățită și animații de calitate. Mărește utilizarea bateriei."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Atenție la ecran"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Este necesar accesul la camera foto"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Pentru funcția Atenție la ecran este necesar accesul la cameră. Atinge pentru a gestiona permisiunile pentru Serviciile de personalizare a dispozitivului"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Gestionează permisiunile"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Nu lasă ecranul să se închidă dacă te uiți la el"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Funcția Atenție la ecran folosește camera frontală pentru a detecta dacă se uită cineva la ecran. Funcționează pe dispozitiv, iar imaginile nu sunt niciodată stocate sau trimise la Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Activați „Atenție la ecran”"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Menține activat ecranul când îl privești"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Camera foto este blocată"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Camera foto trebuie deblocată pentru detectarea facială"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Camera trebuie să fie deblocată pentru funcția Atenție la ecran"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Pentru detectarea facială este necesar accesul la camera foto. Atinge pentru a gestiona permisiunile pentru Serviciile de personalizare a dispozitivului"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Gestionează permisiunile"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Lumină de noapte"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Lumina de noapte dă o nuanță de chihlimbar ecranului. Astfel, este mai ușor să privești ecranul sau să citești într-o lumină slabă și te poate ajuta să adormi mai rapid."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Program"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Niciodată"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Se activează la o anumită oră"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Se activează de la apus la răsărit"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Ora începerii"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Ora încheierii"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensitate"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nu se va activa niciodată automat"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Se va activa automat la <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Se va activa automat la apus"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nu se va dezactiva niciodată automat"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Se va dezactiva automat la <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Se va dezactiva automat la răsărit"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Lumina de noapte nu este activată"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Este necesară locația dispozitivului pentru a stabili orele de răsărit și de apus."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Setări privind locația"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Activezi acum"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Dezactivează acum"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Activează până la răsărit"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Dezactivează până la apus"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Modul întunecat"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Program"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Niciodată"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Se activează de la apus la răsărit"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Se activează la o anumită oră"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Se activează la ora de culcare"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Stare"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nu se va activa niciodată automat"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Se va activa automat la apus"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Se va activa automat la <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Se va activa automat la ora de culcare"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nu se va dezactiva niciodată automat"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Se va dezactiva automat la răsărit"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Se va dezactiva automat la <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Se va dezactiva automat după ora de trezire"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Tema întunecată folosește un fundal negru pentru a conserva autonomia bateriei pentru unele ecrane. Programele cu Tema întunecată se activează când se dezactivează ecranul."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Tema întunecată urmează momentan programul modului Ora de culcare"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Setările modului Ora de culcare"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Durată până la dezactivarea ecranului"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"După <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> de inactivitate"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nesetate"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Imagine de fundal"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Imagine de fundal și stil"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Ecran de pornire, ecran de blocare"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Schimbă imaginea de fundal"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personalizează ecranul"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Alege imagine de fundal din"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Personalizează-ți telefonul"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Încearcă diverse stiluri, imagini de fundal și altele"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Screensaver"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"screensaver"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Indisponibil; modul ora de culcare este activat"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Folosește screensaverul"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"În timpul încărcării sau andocării"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Când este andocat și încarcă"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"În timpul încărcării"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Când dispozitivul este andocat"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Niciodată"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Activat/<xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Dezactivat"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Când pornește"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Ridică pentru a reactiva"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Afișaj ambiental"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Când se afișează"</string>
    <string name="doze_title" msgid="1523090408230862316">"Activează ecranul pentru notificări"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Când este întunecat, ecranul se activează pentru notificări noi"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Afișează mereu ora și informațiile"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Utilizare ridicată a bateriei"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Text aldin"</string>
    <string name="title_font_size" msgid="570613010306330622">"Dimensiunea fontului"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Mărește sau micșorează texul"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Setări de restricționare pentru SIM"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Restricționarea cartelei SIM"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Blochează cartela SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Schimbă codul PIN pentru SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN SIM"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Blochează cartela SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Deblochează cartela SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Vechiul cod PIN al cardului SIM"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nou cod PIN pentru SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Reintrodu noul PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN SIM"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Introdu un cod PIN de 4 – 8 cifre"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Codurile PIN nu corespund"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"Codul PIN pentru SIM a fost modificat"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Nu se poate dezactiva codul PIN."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Nu se poate activa codul PIN."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Anulează"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Folosești <xliff:g id="CARRIER">%1$s</xliff:g> pentru date mobile?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Folosești <xliff:g id="CARRIER2_0">%2$s</xliff:g> pentru datele mobile. Când comuți la <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> nu va mai fi folosit pentru date mobile."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Folosește <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Actualizezi SIM-ul preferat?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> este singurul card SIM de pe dispozitiv. Vrei să folosești acest card SIM pentru date mobile, apeluri și mesaje SMS?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Crești acoperirea datelor mobile?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Permite ca dispozitivul să comute automat la <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> pentru date mobile când are o disponibilitate mai mare."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Apelurile, mesajele și traficul de rețea pot fi vizibile pentru organizația ta."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Codul PIN pentru cardul SIM este incorect. Contactează operatorul pentru a-ți debloca dispozitivul."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Codul PIN pentru cardul SIM este incorect. Ți-a mai rămas # încercare, după care va trebui să contactezi operatorul pentru a debloca dispozitivul.}few{Codul PIN pentru cardul SIM este incorect. Ți-au mai rămas # încercări.}other{Codul PIN pentru cardul SIM este incorect. Ți-au mai rămas # de încercări.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Codul PIN pentru cardul SIM este incorect. Ți-a mai rămas o încercare, după care va trebui să contactezi operatorul pentru a-ți debloca dispozitivul."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Deblocarea cu ajutorul codului PIN pentru cardul SIM nu a reușit!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Actualizări de sistem"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Versiune Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Actualizare de securitate Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Versiune de hardware"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Anul fabricației"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID echipament"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Versiunea benzii de bază"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Versiune nucleu"</string>
    <string name="build_number" msgid="9009733242117579826">"Numărul versiunii"</string>
    <string name="module_version" msgid="1787518340082046658">"Actualizare de sistem Google Play"</string>
    <string name="battery_info" msgid="7873528123969546728">"Informații despre baterie"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Indisponibil"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Stocare"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Spațiul de stocare și memoria cache"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Setări de stocare"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (slot sim <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (slot pentru SIM <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (slot pentru SIM <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (principal)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Alege rețeaua salvată pentru afișare"</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">"Versiune PRL"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (slot pentru SIM <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (slot pentru SIM <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (principal)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Activată"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Dezactivată"</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">"Tipul rețelei de date mobile"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Tipul rețelei mobile de voce"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informații operator"</string>
    <string name="status_data_state" msgid="525196229491743487">"Starea rețelei mobile"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Starea acoperirii"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Puterea semnalului"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Rețea"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Adresă MAC Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Adresa MAC Wi-Fi a dispozitivului"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Adresă Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Număr de serie"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Durată de funcționare"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Data fabricării"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Data primei folosiri"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Numărul de cicluri"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Indisponibil"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Se calculează..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Redenumește"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Montează"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Scoate"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatează cardul SD pentru memorie portabilă"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatează cardul"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatează ca stocare portabilă"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatează"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Mută datele"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Șterge"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Configurează"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Eliberează spațiu"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Gestionează spațiul de stocare"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Eliberează spațiu"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Accesează aplicația Files pentru a gestiona și a elibera spațiu"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Alți utilizatori"</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> este montată"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"<xliff:g id="NAME">%1$s</xliff:g> nu a putut fi montată"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> este scoasă în siguranță"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"<xliff:g id="NAME">%1$s</xliff:g> nu a putut fi scoasă în siguranță"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Redenumește stocarea"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"<xliff:g id="NAME_0">^1</xliff:g> este deteriorat. \n\nPentru a folosi acest <xliff:g id="NAME_1">^1</xliff:g>, mai întâi trebuie să îl configurați."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Poți formata cardul SD ca să stochezi fotografii, videoclipuri, muzică și altele și să le accesezi de pe alte dispozitive. \n\n"<b>"Toate datele de pe acest card SD vor fi șterse."</b>" \n\n"<b>"Înaintea formatării"</b>" \n\n"<b>"Fă backup fotografiilor și altor fișiere media"</b>" \nMută fișierele media în altă stocare de pe acest dispozitiv sau transferă-le pe un computer folosind un cablu USB. \n\n"<b>"Fă backup aplicațiilor"</b>" \nToate aplicațiile stocate pe <xliff:g id="NAME">^1</xliff:g> vor fi dezinstalate, iar datele acestora vor fi șterse. Pentru a păstra aceste aplicații, mută-le în altă stocare de pe acest dispozitiv."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Când scoți <xliff:g id="NAME_0">^1</xliff:g>, aplicațiile stocate pe acesta nu vor mai funcționa, iar fișierele media stocate pe acesta nu vor mai fi disponibile până când nu este introdus din nou."</b>\n\n" Acest <xliff:g id="NAME_1">^1</xliff:g> este formatat pentru a funcționa numai pe acest dispozitiv. Nu va funcționa pe alte dispozitive."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Pentru a folosi aplicațiile, fotografiile și datele pe care le conține acest <xliff:g id="NAME">^1</xliff:g>, reintrodu-l. \n\nSau, poți alege să ștergi acest spațiu de stocare, dacă dispozitivul nu este disponibil. \n\nDacă alegi să îl ștergi, toate datele de pe dispozitiv vor fi pierdute definitiv. \n\nPoți reinstala aplicațiile mai târziu, dar datele acestora care au fost stocate pe dispozitiv vor fi pierdute."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Elimini <xliff:g id="NAME">^1</xliff:g> din listă?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Toate aplicațiile, fotografiile și datele stocate pe acest <xliff:g id="NAME">^1</xliff:g> se vor pierde definitiv."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Sistemul include fișiere folosite pentru a rula versiunea de Android <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Utilizatorii invitați nu pot formata carduri SD"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Se formatează <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Nu scoate <xliff:g id="NAME">^1</xliff:g> în timp ce se formatează."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"S-a formatat <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Mută <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Va dura doar câteva momente să muți <xliff:g id="APP">^1</xliff:g> și datele acesteia pe <xliff:g id="NAME_0">^2</xliff:g>. Nu vei putea folosi aplicația până când mutarea nu este finalizată. \n\nNu scoate <xliff:g id="NAME_1">^2</xliff:g> în timpul procesului de mutare."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Pentru a muta datele, trebuie să deblochezi utilizatorul <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Se mută <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Nu scoate <xliff:g id="NAME">^1</xliff:g> în timpul procesului de mutare. \n\nAplicația <xliff:g id="APP">^2</xliff:g> de pe acest dispozitiv nu va fi disponibilă până când mutarea nu este finalizată."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Cum vei folosi acest <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Sau"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formatează cardul SD pentru memorie portabilă"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Stochează fotografii, videoclipuri, muzică și altele și accesează-le de pe alte dispozitive. &lt;a href=https://support.google.com/android/answer/12153449&gt;Află mai multe despre configurarea unui card SD&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatează"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Configurează mai târziu"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formatezi <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"<xliff:g id="NAME_0">^1</xliff:g> trebuie formatat pentru a stoca aplicații, fișiere și conținut media. \n\nFormatarea va șterge conținutul existent de pe <xliff:g id="NAME_1">^2</xliff:g>. Pentru a evita să pierzi conținut, fă-i backup pe un alt <xliff:g id="NAME_2">^3</xliff:g> sau dispozitiv."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"<xliff:g id="NAME_0">^1</xliff:g> trebuie formatat pentru a stoca fotografii, videoclipuri, muzică și altele. \n\nFormatarea va șterge conținutul existent de pe <xliff:g id="NAME_1">^2</xliff:g>. Pentru a evita pierderea de conținut, fă-i backup pe un alt <xliff:g id="NAME_2">^3</xliff:g> sau dispozitiv."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatează <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Mutați conținutul pe <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"În timpul mutării:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Nu scoate <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Unele aplicații nu vor rula"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Mută conținutul"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Mută conținutul mai târziu"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Se mută conținut…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> lent"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Poți folosi în continuare <xliff:g id="NAME_0">^1</xliff:g>, dar este posibil să fie lent. \n\nEste posibil ca aplicațiile stocate pe <xliff:g id="NAME_1">^2</xliff:g> să nu ruleze corect și transferul conținutului să dureze mai mult. \n\nÎncearcă să folosești un <xliff:g id="NAME_2">^3</xliff:g> mai rapid sau poți să folosești <xliff:g id="NAME_3">^4</xliff:g> pentru stocare mobilă."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Începe din nou"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Continuă"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Poți începe să folosești <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Poți începe să folosești <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Poți începe să folosești <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Stare baterie"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Nivelul bateriei"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Comune"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Setări comune"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Nume APN"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Modifică punctul de acces"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nesetat(ă)"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Nesetată"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nume"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Nume de utilizator"</string>
    <string name="apn_password" msgid="7435086635953953029">"Parolă"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Port MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Tip de autentificare"</string>
    <string name="apn_type" msgid="1835573305077788773">"Tip APN"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protocol APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protocol de roaming APN"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Activează/dezactivează APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN activat"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN dezactivat"</string>
    <string name="bearer" msgid="3231443241639159358">"Purtător"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Tip MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Valoare MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Ștergeți APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"APN nou"</string>
    <string name="menu_save" msgid="6611465355127483100">"Salvează"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Anulează"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Câmpul Nume nu poate fi necompletat."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Numele APN nu poate fi necompletat."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Câmpul MCC trebuie să conțină 3 cifre."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Câmpul MNC trebuie să conțină 2 sau 3 cifre."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operatorul nu permite adăugarea numelor APN de tipul %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Se restabilesc setările APN prestabilite."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Resetează la valorile prestabilite"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Resetarea setărilor APN prestabilite a fost finalizată."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Opțiuni de resetare"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Restabilește setările pentru rețeaua mobilă"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Astfel vor fi restabilite toate setările pentru rețeaua mobilă"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Restabilești setările rețelei mobile?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Resetează Bluetooth și Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Astfel vor fi resetate toate setările pentru Wi‑Fi și Bluetooth. Nu poți anula această acțiune."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Resetează"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth și Wi‑Fi au fost resetate"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Șterge cartelele eSIM"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Acest lucru nu va anula niciun abonament de servicii mobile. Pentru a descărca SIM-uri de înlocuire, contactează operatorul."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Resetează opțiunile"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Restabilește toate setările pentru rețea? Nu poți anula această acțiune."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Resetezi toate setările de rețea și ștergi cartelele eSIM? Nu poți anula această acțiune."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Resetează setările"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Resetezi?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Resetarea rețelei nu este disponibilă pentru acest utilizator"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Setările pentru rețea au fost reinițializate"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Nu se pot șterge SIM-urile"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"Cartelele eSIM nu se pot șterge din cauza unei erori.\n\nRepornește dispozitivul și încearcă din nou."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Șterge datele (revino la setările din fabrică)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Șterge datele (revino la setările din fabrică)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"muzică;"</li>\n<li>"fotografii;"</li>\n<li>"alte date ale utilizatorului."</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"carduri eSIM,"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Planul tău de servicii mobile nu va fi anulat astfel."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Toate informațiile cu caracter personal și aplicațiile descărcate vor fi șterse. Nu puteți anula această acțiune."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Toate informațiile cu caracter personal, inclusiv aplicațiile și SIM-urile descărcate, vor fi șterse. Nu poți anula această acțiune."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Ștergi toate datele?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Revenirea la setările din fabrică nu este disponibilă pentru acest utilizator"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Se șterge"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Așteaptă…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Setări pentru apeluri"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Activează mesageria vocală, redirecționarea apelurilor, apelul în așteptare, ID apelant"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Tethering prin USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Hotspot portabil"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Tethering prin Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Tethering"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot și tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot activat, tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot activat"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Tethering"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Nu se poate face tethering și nu se pot folosi hotspoturile portabile în timp ce Economizorul de date este activat"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Numai hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Numai USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Numai Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Doar Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, 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">"Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, 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">"Hotspot, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Nu se permite altor dispozitive accesul la conexiunea de internet"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Dezactivat"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Tethering"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Nu se folosesc hotspoturi Wi-Fi"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Permite accesul la internet doar prin USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Permite accesul la internet doar prin Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Permiteți accesul la internet doar prin Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Permite accesul la internet prin USB și Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Permite accesul la internet doar prin USB și Ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Permite accesul la internet doar prin Bluetooth și Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Permite accesul la internet doar prin USB, Bluetooth și Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Tethering prin USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Tethering prin Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Tethering Ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Folosește hotspotul și tetheringul pentru a oferi o conexiune de internet altor dispozitive prin conexiunea ta de date mobile. Și aplicațiile pot crea un hotspot pentru a trimite conținut dispozitivelor din apropiere."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Folosește hotspotul și tetheringul pentru a oferi o conexiune de internet altor dispozitive prin conexiunea ta Wi-Fi sau de date mobile. Aplicațiile pot crea și un hotspot pentru a trimite conținut dispozitivelor din apropiere."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Ajutor"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Rețea mobilă"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Plan de date mobile"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Aplicația SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Schimbi aplicația SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Folosești <xliff:g id="NEW_APP">%1$s</xliff:g> în loc de <xliff:g id="CURRENT_APP">%2$s</xliff:g> ca aplicație SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Folosești <xliff:g id="NEW_APP">%s</xliff:g> ca aplicație SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Schimbi asistentul Wi-Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Folosești <xliff:g id="NEW_APP">%1$s</xliff:g> în loc de <xliff:g id="CURRENT_APP">%2$s</xliff:g> pentru a gestiona conexiunile la rețea?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Folosești <xliff:g id="NEW_APP">%s</xliff:g> pentru a gestiona conexiunile la rețea?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Operator SIM necunoscut"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> nu are niciun site de provizionare cunoscut"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Introdu cardul SIM și repornește"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Conectează-te la internet"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitări recente ale locației"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Locație pt. profil de serviciu"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Permisiuni pentru locație"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Locația este dezactivată"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# din {total} aplicații are acces la locație}few{# din {total} aplicații au acces la locație}other{# din {total} de aplicații au acces la locație}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Acces recent"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Afișează tot"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Vezi detaliile"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Nicio aplicație nu a solicitat locația recent"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Nicio aplicație nu a accesat recent locația"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Utilizare intensă a bateriei"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Utilizare redusă a bateriei"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Căutare de rețele Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Permite aplicațiilor și serviciilor să caute permanent rețele Wi-Fi, chiar și atunci când setarea Wi-Fi este dezactivată. Această permisiune poate fi folosită, de exemplu, pentru a îmbunătăți funcțiile și serviciile bazate pe locație."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Căutare Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Permite aplicațiilor și serviciilor să caute permanent dispozitive din apropiere, chiar și atunci când setarea Bluetooth este dezactivată. Această permisiune poate fi folosită, de exemplu, pentru a îmbunătăți funcțiile și serviciile bazate pe locație."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Servicii de localizare"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Servicii de localizare"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Folosește locația"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Fusul orar nu poate fi setat automat"</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">"Locația sau serviciile de localizare sunt dezactivate"</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">"Este necesară locația dispozitivului"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Pentru a seta fusul orar folosind locația, activeaz-o, apoi actualizează setările de fus orar"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Setări privind locația"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Remediază problema"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Anulează"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Fusul orar automat este dezactivat"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Detectarea fusului orar al locației este dezactivată"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Detectarea fusului orar al locației nu este acceptată"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Modificările detectării fusului orar al locației nu sunt permise"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Locația se poate folosi pentru a seta fusul orar"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Afișează informații legale, starea și versiunea programului software"</string>
    <string name="legal_information" msgid="7509900979811934843">"Informații de ordin juridic"</string>
    <string name="manual" msgid="3651593989906084868">"Manual"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Etichete de reglementări"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Manual despre siguranță și reglementări"</string>
    <string name="copyright_title" msgid="83245306827757857">"Drept de autor"</string>
    <string name="license_title" msgid="8745742085916617540">"Licență"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licențe de actualizare de sistem Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Termeni și condiții"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licență de sistem pentru WebView"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Contribuții cu imagini de fundal"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Furnizori de imagini din satelit:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Manual"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"A apărut o problemă la încărcarea manualului."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licențe terță parte"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"A apărut o problemă la încărcarea licențelor."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Se încarcă…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Se încarcă…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Setează o parolă"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Setează o parolă de serviciu"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Setează un cod PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Setează un cod PIN de serviciu"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Setează un model"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Pentru mai multă siguranță, setează un model pentru deblocarea dispozitivului"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Setează un model de serviciu"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Pentru a utiliza amprenta, setează parola"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Pentru a utiliza amprenta, setați modelul"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Din motive de securitate, setați un cod PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Pentru a utiliza amprenta, setează codul PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Reintrodu parola"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Reintrodu parola de serviciu"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Introdu parola de la serviciu"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Confirmă modelul"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Introdu modelul pentru serviciu"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Reintrodu codul PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Reintroduceți codul PIN de serviciu"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Introdu codul PIN pentru serviciu"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Parolele nu corespund"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Codurile PIN nu corespund"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Desenează modelul din nou"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Selectează metoda de deblocare"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Parola a fost setată"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Codul PIN a fost setat"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Modelul a fost setat"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Pentru Deblocare facială, setați parola"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Pentru Deblocare facială, setați modelul"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Pentru Deblocare facială, setează PIN-ul"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Setează o parolă pentru a folosi chipul sau amprenta"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Setează un model pentru a folosi fața sau amprenta"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Setează un PIN pentru a folosi fața sau amprenta"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Ai uitat parola?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Ai uitat modelul?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Ai uitat codul PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Desenează modelul pentru a continua"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Introdu codul PIN pentru a continua"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Introdu parola pentru a continua"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Desenează modelul de serviciu pentru a continua"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Pentru a continua, introdu codul PIN de serviciu"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Pentru a continua, introdu parola de serviciu"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Pentru mai multă siguranță, folosește modelul dispozitivului"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Pentru mai multă siguranță, introduceți codul PIN al dispozitivului"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Pentru mai multă siguranță, introdu parola dispozitivului"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Pentru mai multă siguranță, folosește modelul de serviciu"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Pentru mai multă siguranță, introdu codul PIN de serviciu"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Pentru mai multă siguranță, introdu parola de serviciu"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Confirmă modelul"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Confirmă codul PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Confirmă parola"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Confirmă-ți identitatea"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Ca să transferi Conturile Google, setările și altele, introdu modelul celuilalt dispozitiv. Modelul este criptat."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Ca să transferi Conturile Google, setările și altele, introdu codul PIN al celuilalt dispozitiv. PIN-ul este criptat."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Ca să transferi Conturile Google, setările și altele, introdu parola celuilalt dispozitiv. Parola este criptată."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Folosește și modelul pentru deblocare"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Folosește și PIN-ul pentru deblocare"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Folosește și parola pentru deblocare"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Confirmă modelul"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Confirmă codul PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Confirmă parola"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Pentru a continua, folosește modelul dispozitivului"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Pentru a continua, introdu codul PIN al dispozitivului"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Pentru a continua, introdu parola dispozitivului"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Cod PIN greșit"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Parolă greșită"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Model greșit"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Urgență"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Securitatea dispozitivului"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Schimbă modelul pentru deblocare"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Schimbă codul PIN de deblocare"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Desenează un model pentru deblocare"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Apasă pe Meniu pentru ajutor."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Ridică degetul când termini"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Conectează cel puțin <xliff:g id="NUMBER">%d</xliff:g> puncte. Încearcă din nou."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Model înregistrat"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Desenează din nou pentru a confirma"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Noul tău model pentru deblocare"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Confirmă"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Redesenare"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Șterge"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Continuă"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Model pentru deblocare"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Solicită un model"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Trebuie să desenezi modelul pentru a debloca ecranul"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Fă modelul vizibil"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Confidențialitate îmbunătățită pentru codul PIN"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Dezactivează animațiile când introduci codul PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Setează modelul profilului ca vizibil"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrare la atingere"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Blocare rapidă cu butonul de pornire"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Dacă dispozitivul nu este menținut în activitate de <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Setează modelul pentru deblocare"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Schimbă modelul pentru deblocare"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Modul de desenare a unui model de deblocare"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Prea multe încercări incorecte. Încearcă din nou peste <xliff:g id="NUMBER">%d</xliff:g> secunde."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Aplicația nu este instalată pe telefonul tău"</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Securitatea profilului de serviciu"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Blocarea ecranului în profilul de serviciu"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Folosește o singură blocare"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Folosește o singură blocare pentru profilul de serviciu și ecranul dispozitivului"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Folosești o singură blocare?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Dispozitivul tău va folosi blocarea ecranului în profilul de serviciu. Politicile pentru serviciu se vor aplica ambelor blocări."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Blocarea profilului de serviciu nu corespunde cerințelor de securitate ale organizației tale. Poți să folosești aceeași blocare pentru ecranul dispozitivului și pentru profilul de serviciu, însă se vor aplica toate politicile de blocare pentru serviciu."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Folosește o singură blocare"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Folosește o singură blocare"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Aceeași ca blocarea ecranului dispozitivului"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Gestionează aplicații"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informații despre aplicație"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Setări aplicații"</string>
    <string name="install_applications" msgid="3921609656584369901">"Surse necunoscute"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Permite aplic. din orice surse"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Aplicații deschise recent"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Afișează toate aplicațiile}few{Afișează toate cele # aplicații}other{Afișează toate cele # de aplicații}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Contactează administratorul IT"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Acesta vă poate ajuta să resetați codul PIN, modelul sau parola"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Setări avansate"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Activează mai multe opțiuni pentru setări"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Informații despre aplicație"</string>
    <string name="storage_label" msgid="2522307545547515733">"Stocare"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Deschide în mod prestabilit"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Prestabilite"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Compatibilitate ecran"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Permisiuni"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Memorie cache"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Golește memoria cache"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Memorie cache"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{Un articol}few{# articole}other{# de articole}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Anulează accesul"</string>
    <string name="controls_label" msgid="8671492254263626383">"Comenzi"</string>
    <string name="force_stop" msgid="2681771622136916280">"Oprește forțat"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Total"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Dimensiunea aplicației"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Stocare aplicație pe USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Datele utilizatorului"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Dezinstalează"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Dezinstalează pentru toți utilizatorii"</string>
    <string name="install_text" msgid="4558333621516996473">"Instalează"</string>
    <string name="disable_text" msgid="5146002260857428005">"Dezactivează"</string>
    <string name="enable_text" msgid="8570798764647110430">"Activează"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Șterge datele stocate"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Dezinstalați actualizările"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Permite setările restricționate"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Unele activități pe care le-ai selectat se deschid în această aplicație în mod prestabilit."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Ai ales să permiți acestei aplicații să creeze widgeturi și să acceseze datele acestora."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nu este setată nicio valoare standard."</string>
    <string name="clear_activities" msgid="488089228657585700">"Șterge preferințele prestabilite"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Este posibil ca această aplicație să nu fie proiectată pentru ecranul tău. Aici poți stabili modul în care aceasta se adaptează ecranului tău."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Se stabilește la lansare"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Scalează aplicația"</string>
    <string name="unknown" msgid="8192160131923461175">"Necunoscut"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Sortează după nume"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Sortează după dimensiune"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Cele mai recente"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Cele mai frecvente"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Serviciile care rulează"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Procese memorie cache"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplicația de urgență"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Resetează preferințele pentru aplicații"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Resetezi preferințele pentru aplicații?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Astfel vor fi resetate toate preferințele pentru:\n\n"<li>"aplicații dezactivate,"</li>\n<li>"notificări de aplicații dezactivate,"</li>\n<li>"aplicații prestabilite pentru acțiuni,"</li>\n<li>"restricții privind datele de fundal pentru aplicații,"</li>\n<li>"orice restricții de permisiuni,"</li>\n<li>"setări pentru folosirea bateriei."</li>\n\n"Nu veți pierde datele aplicațiilor."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Resetează aplicațiile"</string>
    <string name="filter" msgid="9039576690686251462">"Filtrează"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Alege opțiunile de filtrare"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Toate aplicațiile"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Aplicații dezactivate"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Descărcate"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Rulează"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nu este instal. pt. utilizator"</string>
    <string name="installed" msgid="2837449358488825884">"Instalată"</string>
    <string name="no_applications" msgid="985069304755391640">"Nu există aplicații."</string>
    <string name="internal_storage" msgid="999496851424448809">"Stocare internă"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Se recalculează dimensiunea..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Ștergi datele aplicației?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Datele acestei aplicații, între care fișiere și setări, vor fi șterse definitiv de pe dispozitiv"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Anulează"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Șterge"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Aplicația nu a fost găsită în lista de aplicații instalate."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Nu s-au putut șterge datele stocate pentru aplicație."</string>
    <string name="computing_size" msgid="4915310659841174866">"În curs de calculare..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Nu s-a putut calcula mărimea pachetului."</string>
    <string name="version_text" msgid="7628938665256107608">"versiunea <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Mută"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Altă migrare este deja în desfășurare."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nu există suficient spațiu de stocare."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Aplicația nu există."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Locația de instalare nu este validă."</string>
    <string name="system_package" msgid="7559476279008519360">"Actualizările de sistem nu pot fi instalate pe suportul extern."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Aplicația pentru administratorul dispozitivului nu poate fi instalată pe un mediu de stocare extern"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Oprești forțat?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Dacă forțezi oprirea unei aplicații, aceasta se poate comporta necorespunzător."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Dezactivează aplicația"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Dacă dezactivezi această aplicație, este posibil ca Android și alte aplicații să nu mai funcționeze corespunzător. Reține că nu poți șterge aplicația, deoarece a fost preinstalată pe dispozitiv. Dezactivând-o, oprești această aplicație și o ascunzi pe dispozitiv."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Magazin"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detalii despre aplicație"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Aplicație instalată din <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Mai multe informații în <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Rulează"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nu este utilizată niciodată)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Utilizare stocare"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Repornește"</string>
    <string name="cached" msgid="5379485147573438201">"Proces de fundal în memoria cache"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nu rulează niciun serv."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Inițiat de aplicație"</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> liberi"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> utilizați"</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">"Utilizator: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Utilizator eliminat"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces și <xliff:g id="NUMSERVICES">%2$d</xliff:g> serviciu"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces și <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicii"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g>   procese și <xliff:g id="NUMSERVICES">%2$d</xliff:g> serviciu"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procese și <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicii"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memoria dispozitivului"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Utilizarea memoriei RAM de către aplicații"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistem"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplicații"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Disponibilă"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Utilizată"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"În cache"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> de RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aplicația care rulează"</string>
    <string name="no_services" msgid="3898812785511572899">"Nu există servicii active"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Servicii"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procese"</string>
    <string name="service_stop" msgid="5712522600201308795">"Oprește"</string>
    <string name="service_manage" msgid="3896322986828332075">"Setări"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Acest serviciu a fost pornit de propria aplicație. Oprirea serviciului poate duce la eșuarea aplicației."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Această aplicație nu poate fi oprită în siguranță. Oprirea aplicației ar putea duce la pierderea datelor curente."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Acesta este un proces al unei aplicații mai vechi, care rulează în continuare, pentru cazul în care este necesar din nou. De obicei nu există niciun motiv să îl oprești."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: este folosit momentan. Atinge Setări pentru a-l controla."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Procesul principal în uz."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Serviciul <xliff:g id="COMP_NAME">%1$s</xliff:g> se află în utilizare."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Furnizorul <xliff:g id="COMP_NAME">%1$s</xliff:g> se află în utilizare."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Oprești serviciul de sistem?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Limbi, introducerea textului și gesturi"</string>
    <string name="language_settings" msgid="8700174277543875046">"Limbi și introducerea textului"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Limbi"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Tastatură"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Nu ai permisiunea de a schimba limba dispozitivului."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Limbi și introducerea textului"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Instrumente"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastatură și introducere de text"</string>
    <string name="system_language" msgid="1146762166579643257">"Limbile sistemului"</string>
    <string name="phone_language" msgid="5986939176239963826">"Limbi"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Înlocuire automată"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Corectezi cuvintele scrise greșit"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Scriere automată cu majuscule"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Scrie cu literă mare prima literă din propoziții"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Se introduce automat punctuația"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Setări pentru tastatura fizică"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Apasă de două ori pe tasta de spațiu pentru a insera „.”"</string>
    <string name="show_password" msgid="7101900779571040117">"Afișează parolele"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Caracterele se afișează pentru scurt timp, pe măsură ce tastezi"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Acest instrument de verificare a ortografiei poate, de asemenea, să culeagă în întregime textul pe care îl introduci, inclusiv datele personale, cum ar fi parolele și numerele cardurilor de credit. Instrumentul provine de la aplicația <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Folosești acest instrument de verificare ortografică?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Setări"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Limbă"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastaturi"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Tastatură pe ecran"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Tastatura pe ecran disponibilă"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Gestionează tastaturile pe ecran"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opțiuni"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Tastatură fizică"</string>
    <string name="show_ime" msgid="4334255501724746849">"Folosește tastatura pe ecran"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Se păstrează pe ecran cât timp este activată tastatura fizică"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Comenzi rapide de la tastatură"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Afișează lista de comenzi rapide"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastaturi și instrumente pt. profilul de serviciu"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Tastatura pe ecran pentru serviciu"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Prestabilit"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchpad"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchpad și mouse"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Viteza indicatorului, gesturi"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Atinge pentru clic"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Gesturi pentru touchpad"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Personalizează gesturi individuale de navigare cu touchpadul"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Derulare inversă"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Conținutul se deplasează în sus când derulezi în jos"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Atingere în dreapta jos"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Atinge colțul din dreapta jos al touchpadului pentru alte opțiuni"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Viteza indicatorului"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Învață gesturi pentru touchpad"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Înapoi la ecranul de pornire"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Glisează în sus cu trei degete oriunde pe touchpad"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Înapoi"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Glisează dinspre stânga sau dreapta cu trei degete"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Vezi aplicațiile recente"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Glisează în sus cu trei degete, ține apăsat, apoi eliberează"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Vezi notificările și Setările rapide"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Glisează în jos cu trei degete pe ecranul de pornire"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Schimbă între aplicații"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Glisează la stânga sau la dreapta cu patru degete"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Omite"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Înainte"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Repornește"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Gata"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Înapoi"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Glisează la stânga sau la dreapta cu trei degete"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Înapoi la pagina de pornire"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Glisează în sus cu trei degete"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Aplicații recente"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Glisează în sus cu trei degete, apoi ține apăsat"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Notificări"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Glisează în jos cu trei degete"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Schimbă între aplicații"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Glisează la stânga sau la dreapta cu patru degete"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Taste de modificare"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Schimbă comportamentul tastelor"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Resetează tot"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Prestabilite"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Sigur resetezi toate tastele de modificare la valorile prestabilite?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Gata"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Anulează"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Resetează"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Alege tasta de modificare"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Alege o nouă tastă pentru <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Prestabilit"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Voce"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Viteza indicatorului"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Controler de joc"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Redirecționează vibrațiile"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Trimite vibrații la controlerul de joc când este conectat"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Alege aspectul tastaturii"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Configurează aspectele tastaturii"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Pentru comutare, apasă pe Control-Space"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Prestabilit"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Aspecte tastatură"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Aspecte de tastaturi fizice"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Dicționar personal"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Dicționar personal pentru serviciu"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Adaugă cuvinte de folosit în aplicații cum ar fi Verificatorul ortografic"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Adaugă"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Adaugă în dicționar"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Expresie"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Mai multe opț."</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Mai puține opț."</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Cuvânt:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Comandă rapidă:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Limbă:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Introdu un cuvânt"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Comandă rapidă opțională"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Modifică cuvântul"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Modifică"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Șterge"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Nu ai niciun cuvânt în dicționarul utilizatorului. Pentru a adăuga un cuvânt, atinge butonul Adaugă (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Pentru toate limbile"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Mai multe limbi..."</string>
    <string name="testing" msgid="6294172343766732037">"Testare"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Tastatură pe ecran, instrumente"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Tastatură pe ecran, tastatură fizică, instrumente"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Tastatură fizică"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Aspect"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Alege obiectul gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Alege obiectul widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Creezi widgetul și permiți accesul?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"După ce creezi widgetul, aplicația poate accesa toate datele afișate.\n\nAplicația: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidgetul: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Permite întotdeauna ca <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> să creeze widgeturi și să acceseze datele acestora"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Statistici de utilizare"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Sortează după durata folosirii"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Sortează după data ultimei folosiri"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Sortează după numele aplicației"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Ultima utilizare"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Durată de utilizare"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Accesibilitate"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Setări de accesibilitate"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Afișaj, interacțiune, audio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Setări pentru vedere"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Poți personaliza acest dispozitiv conform nevoilor tale. Aceste funcții de accesibilitate pot fi modificate ulterior în setări."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Modifică dimensiunea fontului"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Cititor de ecran"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Subtitrări"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"General"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Afișaj"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Culoare și mișcare"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Redu luminozitatea ecranului"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Comenzi pentru interacțiune"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Comenzi de sincronizare"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Comenzile sistemului"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Aplicații descărcate"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimentale"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Semnalări ale funcției"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtrarea jurnalului de examinare Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Setează filtrele"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Dezactivează și activează Bluetooth ca să se aplice modificările"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP de filtrare a jurnalului de examinare Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"MAP de filtrare a jurnalului de examinare Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Setează modul de filtrare. (Dezactivează și activează Bluetooth ca să se aplice modificările)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Setează modul jurnalului de examinare Bluetooth HCI la Filtrare activată ca să schimbi opțiunea"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Cititor de ecran destinat în principal utilizatorilor nevăzători și cu deficiențe de vedere"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Atinge elementele de pe ecran pentru a le auzi citite cu voce tare"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Preferințe pentru subtitrări"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Despre preferințele legate de subtitrări"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Află mai multe despre preferințele legate de subtitrări"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Mărire"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Comandă rapidă pentru mărire"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Mărește textul scris"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Lupa urmărește textul pe măsură ce-l introduci"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Menține-o activată când schimbi între aplicații"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Lupa rămâne activată și micșorează când treci de la o aplicație la alta"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Activează și deplasează lupa cu un joystick pe ecran. Atinge lung, apoi trage pe joystick ca să controlezi lupa. Atinge și trage ca să deplasezi chiar joystickul."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Despre mărire"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Află mai multe despre mărire"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Tip de mărire"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Mărește tot ecranul sau o anumită zonă ori comută între cele două opțiuni"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Ecran complet"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Ecran parțial"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Comută între ecranul complet și cel parțial"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Alege tipul de mărire"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Mărește la ecran complet"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Mărește o parte a ecranului"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Comută între ecranul complet și cel parțial"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Atinge butonul de comutare pentru a alege între cele două opțiuni"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Comutați la butonul de accesibilitate?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Dacă folosești tripla atingere pentru a mări o parte a ecranului, vei întârzia tastarea și alte acțiuni.\n\nButonul de accesibilitate apare pe ecran peste alte aplicații. Atinge-l pentru a mări."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Comută la butonul de accesibilitate"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Folosește tripla atingere"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Poate încetini funcționarea tastaturii"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Când folosești trei atingeri pentru a mări o parte a ecranului, este posibil să observi probleme cu tastatura.\n\nPentru a le evita, înlocuiește comanda rapidă de mărire cu trei atingeri cu o altă opțiune.\n"<annotation id="link">"Modifică setarea"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuă oricum"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Anulează"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Setări pentru mărire"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Mărește atingând de trei ori"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Mărește folosind scurtătura"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Mărește folosind scurtătura și atingând de trei ori"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Despre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Dimensiunea afișării și textul"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Modifică modul de afișare a textului"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Subiect: Designuri pentru baloanele cu aer cald"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"De la: Bogdan"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Bună dimineața!\n\nVoiam să văd cum merg designurile. Vor fi gata până să începem să lucrăm la noile baloane?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Restabilește setările"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Dimensiunea afișării și textul au fost resetate"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Resetezi dimensiunea afișării și textul?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Resetează"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Ai planuri de weekend?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Mă duc la plajă. Vrei să vii?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opțiuni"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Mărește pe ecran"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Atinge de 3 ori pentru zoom"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Atinge un buton pentru a micșora/mări"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Mărește rapid conținutul de pe ecran"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Pentru a mări:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. folosește comanda rapidă ca să începi mărirea;&lt;br/&gt; {1,number,integer}. atinge ecranul;&lt;br/&gt; {2,number,integer}. glisează cu două degete ca să te deplasezi pe ecran;&lt;br/&gt; {3,number,integer}. ciupește cu două degete ca să ajustezi nivelul de zoom;&lt;br/&gt; {4,number,integer}. folosește comanda rapidă ca să oprești mărirea.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Pentru a mări temporar:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. asigură-te că tipul de mărire este setat la ecran complet;&lt;br/&gt; {1,number,integer}. folosește comanda rapidă ca să începi mărirea;&lt;br/&gt; {2,number,integer}. atinge lung oriunde pe ecran;&lt;br/&gt; {3,number,integer}. glisează cu degetul ca să te deplasezi pe ecran;&lt;br/&gt; {4,number,integer}. ridică degetul ca să oprești mărirea."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Când mărirea este activată, poți mări ecranul curent.\n\n"<b>"Pentru a mări"</b>", începe mărirea, apoi atinge oriunde pe ecran.\n"<ul><li>"Trage cu două sau mai multe degete pentru a derula"</li>\n<li>"Ciupește cu două sau mai multe degete pentru a regla nivelul de zoom"</li></ul>\n\n<b>"Pentru a mări temporar"</b>", începe mărirea, apoi atinge lung oriunde pe ecran.\n"<ul><li>"Trage pentru a te mișca pe ecran"</li>\n<li>"Ridică degetul pentru a micșora"</li></ul>\n\n"Nu poți mări pe tastatură și pe bara de navigare."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Pagina <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> din <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Folosește butonul de accesibilitate pentru a deschide"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Apasă lung butoanele de volum pentru a deschide"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Atinge ecranul de trei ori ca să deschizi"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Folosește un gest pentru a deschide"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Folosește gestul de accesibilitate"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Ca să folosești această funcție, atinge butonul de accesibilitate <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> din partea de jos a ecranului.\n\nCa să comuți între funcții, atinge lung butonul de accesibilitate."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Ca să folosești această funcție, atinge butonul de accesibilitate de pe ecran."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Ca să folosești această funcție, apasă lung ambele butoane de volum."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Pentru a porni și a opri mărirea, atinge de trei ori oriunde pe ecran."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Ca să folosești această funcție, glisează în sus cu două degete din partea de jos a ecranului.\n\nCa să comuți între funcții, glisează în sus cu două degete și ține apăsat."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Ca să folosești această funcție, glisează în sus cu trei degete din partea de jos a ecranului.\n\nCa să comuți între funcții, glisează în sus cu trei degete și ține apăsat."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Ca să folosești o funcție de accesibilitate, glisează în sus cu două degete din partea de jos a ecranului.\n\nCa să comuți între funcții, glisează în sus cu două degete și ține apăsat."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Ca să folosești o funcție de accesibilitate, glisează în sus cu trei degete din partea de jos a ecranului.\n\nCa să comuți între funcții, glisează în sus cu trei degete și menține apăsat."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"OK"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Setările butonului de accesibilitate"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Comanda rapidă pentru <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Buton de accesibilitate"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Gest de accesibilitate"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Glisează în sus cu două degete"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Glisează în sus cu trei degete"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Atinge butonul de accesibilitate"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Folosește gestul de accesibilitate"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Atinge butonul de accesibilitate <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> din partea de jos a ecranului.\n\nPentru a comuta între funcții, atinge lung butonul de accesibilitate."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Glisează în sus cu două degete din partea de jos a ecranului.\n\nPentru a comuta între funcții, glisează în sus cu două degete și ține apăsat."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Glisează în sus cu trei degete din partea de jos a ecranului.\n\nPentru a comuta între funcții, glisează în sus cu trei degete și ține apăsat."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Mai multe opțiuni"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Află mai multe despre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Apasă lung butoanele de volum"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"apasă lung butoanele de volum"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Apasă lung ambele butoane de volum"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Atinge ecranul de trei ori"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"atinge ecranul de trei ori"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Atinge rapid ecranul de {0,number,integer} ori. Această comandă rapidă poate încetini funcționarea dispozitivului"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Avansate"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Butonul Accesibilitate este setat pe <xliff:g id="SERVICE">%1$s</xliff:g>. Pentru a folosi mărirea, atinge lung butonul Accesibilitate și apoi selectează mărirea."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Gestul de accesibilitate este setat la <xliff:g id="SERVICE">%1$s</xliff:g>. Pentru a folosi mărirea, glisează în sus cu două degete din partea de jos a ecranului și ține apăsat. Apoi selectează mărirea."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Comandă rapidă pentru butoane volum"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Setări pentru comenzi rapide"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Comandă rapidă din ecranul de blocare"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Permite activarea comenzii rapide pentru funcție din ecranul de blocare. Apasă ambele taste pentru volum timp de câteva secunde."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Buton de accesibilitate"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Buton și gest de accesibilitate"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Accesează rapid funcțiile de accesibilitate de pe orice ecran"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Despre butonul de accesibilitate"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Despre butonul de accesibilitate și gest"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Află mai multe despre butonul de accesibilitate și gest"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Folosirea butonului de accesibilitate. Gestul nu este disponibil în cazul navigării cu 3 butoane."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Accesează rapid funcțiile de accesibilitate"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Pentru a începe"</b>\n"1. Accesează setările de accesibilitate\n2. Selectează o funcție și atinge comanda rapidă\n3. Alege dacă vrei să folosești un buton sau un gest pentru a accesa funcția"</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Pentru a începe"</b>\n"1. Accesează setările de accesibilitate\n2. Selectează o funcție și atinge comanda rapidă\n3. Alege butonul pentru a accesa funcția"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Folosește butonul sau gestul"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Locație"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Dimensiune"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Dispare atunci când nu este folosit"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Dispare în câteva secunde ca să vedeți mai bine ecranul"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparența atunci când nu este folosit"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparent"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Netransparent"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text cu contrast ridicat"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Schimbă culoarea textului în negru sau alb. Astfel, se maximizează contrastul cu fundalul."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Actualiz. automat mărirea ecranului"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Actualiz. mărirea ecran. la tranziția între aplic."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Butonul de pornire închide"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Cursor mare pentru mouse"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Fă cursorul mouse-ului mai ușor de observat"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Elimină animațiile"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Redu mișcarea de pe ecran"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Audio mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Combină canalele când redai conținutul audio"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Balans audio"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Stânga"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Dreapta"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Prestabilit"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 secunde"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 de secunde"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"Un minut"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minute"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Timp de reacție (timp limită de accesibilitate)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Despre timpul de reacție (timp limită de accesibilitate)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Află mai multe despre timpul de reacție (timp limită de accesibilitate)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Timp pentru a acționa"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Această preferință pentru durată nu este acceptată de toate aplicațiile"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Alege durata de afișare a mesajelor temporare care îți cer să acționezi"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Întârziere la atingere lungă"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inversarea culorilor"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Folosește inversarea culorilor"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Comandă rapidă pentru inversarea culorilor"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Inversarea culorilor întunecă ecranele luminoase. În plus, deschide ecranele întunecate."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Reține&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; culorile conținutului media și ale imaginilor se schimbă;&lt;/li&gt; &lt;li&gt; inversarea culorilor funcționează în toate aplicațiile;&lt;/li&gt; &lt;li&gt; poți folosi Tema întunecată pentru a afișa un fundal întunecat.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"pentru a accesa setările"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Clic automat (durată de staționare)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Despre clicul automat (durată de staționare)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Află mai multe despre clicul automat (durată de staționare)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Poți seta un mouse conectat să dea clic automat când cursorul nu se mai mișcă pentru un anumit interval de timp"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Clicul automat poate fi util dacă este dificil să dai clic pe mouse"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Clic automat dezactivat"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Scurt"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 secunde"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Mediu"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 secunde"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Lung"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"O secundă"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Personalizat"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Mai scurtă"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Mai lungă"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Durata clicului automat"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibrații și feedback tactil"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Controlează intensitatea vibrației pentru diferite moduri de folosire"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Activate"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Dezactivate"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Setare dezactivată, deoarece dispozitivul este setat la modul silențios"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Apeluri"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Notificări și alarme"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Feedback haptic interactiv"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Folosește vibrațiile și feedbackul tactil"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibrație pentru alarmă"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibrație pentru conținut media"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibrațiile soneriei"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibrații la notificare"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Feedback la atingere"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Folosește <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Deschide <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> s-a adăugat în Setări rapide. Glisează în jos oricând pentru a activa sau a dezactiva."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"În plus, poți adăuga <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> în Setările rapide din partea de sus a ecranului"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Corecția culorii s-a adăugat în Setări rapide. Glisează în jos oricând pentru a activa sau a dezactiva."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"În plus, poți adăuga corecția culorii în Setările rapide din partea de sus a ecranului"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Inversarea culorilor s-a adăugat în Setări rapide. Glisează în jos oricând pentru a activa sau a dezactiva."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"În plus, poți adăuga inversarea culorilor în Setările rapide din partea de sus a ecranului"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Luminozitatea redusă suplimentar s-a adăugat în Setări rapide. Glisează în jos oricând pentru a activa sau a dezactiva."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"În plus, poți adăuga luminozitatea redusă suplimentar în Setările rapide din partea de sus a ecranului"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Modul cu o mână s-a adăugat în Setări rapide. Glisează în jos oricând pentru a activa sau a dezactiva."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"În plus, poți adăuga modul cu o mână în Setările rapide din partea de sus a ecranului"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Dimensiunea fontului a fost adăugată în Setări rapide. Glisează oricând în jos pentru a schimba dimensiunea fontului."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Respinge"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Folosește corecția culorii"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Comandă rapidă pentru corecția culorii"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Despre corecția culorii"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Află mai multe despre corecția culorii"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Despre inversarea culorilor"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Află mai multe despre inversarea culorilor"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Afișează subtitrările"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Numai pentru aplicațiile compatibile"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Dimensiunea și stilul subtitrărilor"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Dimensiunea textului: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Mai multe opțiuni"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Personalizează dimensiunea și stilul subtitrărilor pentru a fi mai ușor de citit"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Aceste preferințe pentru subtitrări nu sunt acceptate de toate aplicațiile media"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Buton de accesibilitate"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Glisează cu două degete în sus din partea de jos"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Apasă lung butoanele de volum"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Atinge ecranul de trei ori"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuă"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Aparate auditive"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Poți folosi aparate auditive, implanturi cohleare și alte dispozitive de amplificare cu telefonul"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Niciun aparat auditiv conectat"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Adaugă aparate auditive"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Asociază aparatele auditive"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Pe ecranul următor, atinge aparatele auditive. Poate fi nevoie să asociezi separat urechea stângă și pe cea dreaptă.\n\nVerifică dacă aparatele auditive sunt activate și gata de asociat."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> este activ"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, numai stânga"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, numai dreapta"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, stânga și dreapta"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> + încă 1"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Asociază alt dispozitiv"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Despre asocierea unui dispozitiv nou"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Aparate auditive"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Dispozitive salvate"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Comenzi pentru aparatul auditiv"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Comandă rapidă pentru aparatul auditiv"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilitate cu aparatele auditive"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Îmbunătățește compatibilitatea cu bobinele cu inducție și reduce zgomotul nedorit"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Despre dispozitivele auditive"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Verifică dacă aparatul auditiv este pornit și gata de asociat"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Asociază aparatul auditiv"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Aparate auditive disponibile"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Nu vezi aparatul tău auditiv?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Vezi mai multe dispozitive"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Ajustarea setărilor audio"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Descriere audio"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Ascultă o descriere a conținutului de pe ecran în filmele și serialele acceptate"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"descriere audio, audio, descriere, vedere slabă"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Comanda rapidă este activată"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Dezactivată"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Activat"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Dezactivat"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Nu funcționeaza. Atinge pentru informații."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Acest serviciu nu funcționează corect."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Comenzi rapide pentru accesibilitate"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Afișează în Setări rapide"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Roșu-verde"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Roșu-verde"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Albastru-galben"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Tonuri de gri"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Percepție slabă a culorii verde, deuteranomalie"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Percepție slabă a culorii roșu, protanomalie"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalie"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Luminozitate redusă suplimentar"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Redu suplimentar luminozitatea"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Comandă rapidă pentru luminozitate redusă suplimentar"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Despre luminozitatea redusă suplimentar"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Întunecă ecranul pentru a citi mai confortabil"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensitate"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Mai întunecat"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Mai luminos"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Menține setarea după repornirea dispozitivului"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Scurt ({time} secundă)}few{Scurt ({time} secunde)}other{Scurt ({time} de secunde)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Mediu ({time} secundă)}few{Mediu ({time} secunde)}other{Mediu ({time} de secunde)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Lung ({time} secundă)}few{Lung ({time} secunde)}other{Lung ({time} de secunde)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} secundă}few{{time} secunde}other{{time} de secunde}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Setări"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Activată"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Dezactivată"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Previzualizare"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Opțiuni standard"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Limbă"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Dimensiunea textului"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Stilul subtitrării"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Opțiuni personalizate"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Culoare de fundal"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Opacitatea fundalului"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Culoarea ferestrei cu legenda"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Opacitatea ferestrei cu legenda"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Culoarea textului"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Opacitatea textului"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Culoarea marginii"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Tipul marginii"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Familie de fonturi"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Subtitrările vor arăta așa"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Prestabilită"</string>
    <string name="color_title" msgid="2511586788643787427">"Culoare"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Prestabilită"</string>
    <string name="color_none" msgid="3703632796520710651">"Niciuna"</string>
    <string name="color_white" msgid="1896703263492828323">"Alb"</string>
    <string name="color_gray" msgid="8554077329905747877">"Gri"</string>
    <string name="color_black" msgid="9006830401670410387">"Negru"</string>
    <string name="color_red" msgid="5210756997426500693">"Roșu"</string>
    <string name="color_green" msgid="4400462091250882271">"Verde"</string>
    <string name="color_blue" msgid="4997784644979140261">"Albastru"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cyan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Galben"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Permiți serviciului <xliff:g id="SERVICE">%1$s</xliff:g> să aibă control total asupra dispozitivului tău?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> are funcțiile:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Deoarece o aplicație acoperă o solicitare de permisiune, Setările nu îți pot verifica răspunsul."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> solicită control total asupra acestui dispozitiv. Serviciul poate citi ecranul și poate acționa în numele utilizatorilor cu nevoi de accesibilitate. Acest nivel de control nu este adecvat pentru majoritatea aplicațiilor."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Controlul total este adecvat pentru aplicații care te ajută cu accesibilitatea, însă nu pentru majoritatea aplicaților."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Te vede și-ți controlează ecranul"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Poate citi tot conținutul de pe ecran și poate afișa conținut peste alte aplicații."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Îți vede interacțiunile și le realizează"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Poate urmări interacțiunile tale cu o aplicație sau cu un senzor hardware și poate interacționa cu aplicații în numele tău."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Permite"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Refuză"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Oprește"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Anulează"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Oprești <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Dacă atingi <xliff:g id="STOP">%1$s</xliff:g> vei opri <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nu există servicii instalate"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Niciun serviciu selectat"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Nu a fost furnizată o descriere."</string>
    <string name="settings_button" msgid="2195468788019730377">"Setări"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"sensibilitate la lumină, fotofobie, tema întunecată, migrenă, durere de cap, mod de citire, modul noapte, reduceți luminozitatea, punct alb"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"ușurință de utilizare, acces simplu, asistență, care asigură asistență"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"lupă fereastră, zoom, mărire, vedere slabă, mărește, mai mare"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"subtitrări, transcriere live, deficiențe de auz, pierderea auzului, CART, redare în scris a vorbirii, subtitrare"</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">"dimensiunea ecranului, ecran mare"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"contrast mare, vedere slabă, font aldin, text aldin"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"ajustează culoarea"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"închide culorile ecranului, deschide culorile ecranului"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"contrastul culorilor"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"abilități motorii, mouse"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"aparate auditive, persoane cu deficiențe de auz, pierderea auzului, implanturi cohleare, dispozitive de amplificare, procesoare de sunet"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"deficiențe de auz, pierderea auzului, subtitrări, TeleTypewriter, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Printare"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Dezactivat"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{Un serviciu de printare activat}few{# servicii de printare activate}other{# de servicii de printare activate}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{O sarcină de printare}few{# sarcini de printare}other{# de sarcini de printare}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Servicii de printare"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nu există servicii instalate"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nu au fost găsite imprimante"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Setări"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Adaugă imprimante"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Activat"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Dezactiv."</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Adaugă un serviciu"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Adaugă o imprimantă"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Caută"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Se caută imprimante"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Serviciu dezactivat"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Activități de printare"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Sarcină de printare"</string>
    <string name="print_restart" msgid="4424096106141083945">"Repornește"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Anulează"</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">"Se configurează <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Se printează <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Se anulează <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Eroare de printare: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printare blocată: <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Caseta de căutare este afișată"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Caseta de căutare este ascunsă"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Mai multe informații despre această imprimantă"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Baterie"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Ce funcții au utilizat bateria"</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">"Timp rămas: <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> până la finalizarea încărcării"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Nivel scăzut al bateriei"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Permite aplicației să ruleze în fundal"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Limitezi activitatea de fundal?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Dacă limitezi activitatea de fundal pentru o aplicație, aceasta se poate comporta necorespunzător"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Aplicația nu optimizează bateria, deci nu o poți restricționa.\n\nPentru a o restricționa, activează optimizarea bateriei."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Fără restricții"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimizată"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Limitată"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Permite utilizarea bateriei în fundal fără restricții. Poate consuma mai multă baterie."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimizează în funcție de modul de utilizare. Se recomandă pentru majoritatea aplicațiilor."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Limitează utilizarea bateriei în timpul funcționării în fundal. Este posibil ca aplicația să nu funcționeze conform așteptărilor. Este posibil ca notificările să fie amânate."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Dacă modifici modul în care o aplicație îți folosește bateria, îi poți afecta performanța."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Această aplicație necesită utilizare <xliff:g id="STATE">%1$s</xliff:g> a bateriei."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"Fără restricții"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"Optimizată"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Află mai multe despre opțiunile de utilizare a bateriei"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Utilizarea ecranului de la încărcare"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Utilizarea bateriei"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detalii istoric"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Utilizarea bateriei"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Vezi utilizarea din ultimele 24 de ore"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Vezi utilizarea de la ultima încărcare completă"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Utilizarea bateriei pentru aplicații"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Detalii despre utilizare"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Ajustează utilizarea de energie"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Pachete incluse"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Aplicațiile rulează normal"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Nivelul bateriei este scăzut"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Activează Economisirea bateriei pentru a mări autonomia bateriei"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Îmbunătățește autonomia bateriei"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Activează Battery Manager"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Activează economisirea bateriei"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Bateria se poate descărca mai repede decât de obicei"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Economisirea bateriei este activată"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Află mai multe despre Economisirea bateriei"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Unele funcții pot fi limitate"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Utilizare mai mare a bateriei"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Vezi aplicațiile cu cea mai mare utilizare"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Încărcarea este optimizată pentru a proteja bateria"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Pentru a mări autonomia bateriei, încărcarea este optimizată"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Încărcarea este optimizată pentru a proteja bateria"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Pentru a mări autonomia bateriei, încărcarea este optimizată cât timp dispozitivul este andocat"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Încărcarea este optimizată pentru a proteja bateria"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Pentru a mări durata de viață a bateriei, încărcarea este optimizată cât timp dispozitivul este andocat"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Se încarcă la capacitate maximă"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Pentru a proteja bateria, încărcarea va fi optimizată data viitoare când tableta va fi andocată"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Află mai multe despre întreruperea încărcării"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Reia încărcarea"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Include activitatea din fundal cu un consum ridicat de energie"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Restricționează # aplicație}few{Restricționează # aplicații}other{Restricționează # de aplicații}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} restricționată recent}few{# aplicații restricționate recent}other{# de aplicații restricționate recent}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} determină o utilizare intensă a bateriei în fundal}few{# aplicații determină o utilizare intensă a bateriei în fundal}other{# de aplicații determină o utilizare intensă a bateriei în fundal}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Această aplicație nu poate rula în fundal}few{Aceste aplicații nu pot rula în fundal}other{Aceste aplicații nu pot rula în fundal}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Restricționezi aplicația?}few{Restricționezi # aplicații?}other{Restricționezi # de aplicații?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Pentru a economisi baterie, opriți utilizarea bateriei în fundal de <xliff:g id="APP">%1$s</xliff:g>. Este posibil ca aplicația să nu funcționeze corespunzător și ca notificările să fie primite cu întârziere."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Pentru a economisi baterie, opriți utilizarea bateriei în fundal de aceste aplicații. Este posibil ca aplicațiile restricționate să nu funcționeze corespunzător și ca notificările să fie primite cu întârziere.\n\nAplicații:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Pentru a economisi baterie, oprește utilizarea bateriei în fundal de aceste aplicații. Este posibil ca aplicațiile restricționate să nu funcționeze corespunzător și ca notificările să fie primite cu întârziere.\n\nAplicații:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Restricționate"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Elimini restricția?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Această aplicație va putea utiliza bateria în fundal. Bateria se poate descărca mai repede decât vă așteptați."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Elimină"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Anulează"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Încarcă până la 100 %%"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problemă legată de accesoriul de încărcare"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Află mai multe despre încărcarea cu un adaptor incompatibil"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Battery Manager"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Gestionează automat aplicațiile"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Când Battery Manager detectează că aplicațiile consumă bateria, poți să restricționezi respectivele aplicații. Este posibil ca aplicațiile restricționate să nu funcționeze corespunzător și ca notificările să fie primite cu întârziere."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Aplicații restricționate"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Se limitează utilizarea bateriei pentru # aplicație}few{Se limitează utilizarea bateriei pentru # aplicații}other{Se limitează utilizarea bateriei pentru # de aplicații}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Limitat <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Aceste aplicații sunt restricționate pentru utilizarea bateriei din fundal. Este posibil ca acestea să nu funcționeze conform așteptărilor și ca notificările să fie primite cu întârziere."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Folosește Battery Manager"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Detectează când aplicațiile consumă bateria"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Detectează când aplicațiile consumă bateria"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Detectează când aplicațiile consumă bateria"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# aplicație restricționată}few{# aplicații restricționate}other{# de aplicații restricționate}}"</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">"Problemă la citirea măsurării bateriei."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Atinge ca să afli mai multe despre această eroare"</string>
    <string name="power_screen" msgid="4596900105850963806">"Ecran"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Lanternă"</string>
    <string name="power_camera" msgid="4778315081581293923">"Cameră foto"</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">"Rețea mobilă"</string>
    <string name="power_phone" msgid="2768396619208561670">"Apeluri vocale"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Utilizarea ecranului: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> folosită de <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> din bateria încărcată complet"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Detaliere de la ultima încărcare completă"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Ultima încărcare completă"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Încărcarea completă durează aproximativ"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Autonomia rămasă a bateriei este aproximativă și se poate modifica în funcție de utilizare"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Utilizarea bateriei"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Nu a fost folosită de la ultima încărcare completă"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Nu a fost folosită în ultimele 24 h"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"de la ultima încărcare completă"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Aplicații de sistem"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Altele"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Timp estimat rămas"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Până la încărcarea completă"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Estimarea se poate modifica în funcție de utilizare"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Server media"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimizarea aplicației"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Tethering"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Aplicații eliminate"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Economisirea bateriei"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Se activează automat"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Niciun program"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Pe baza rutinei tale"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Se va activa în funcție de rutina ta"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"În funcție de procentaj"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Economisirea bateriei se activează dacă este probabil ca bateria să se descarce înainte de următoarea încărcare"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Se va activa la <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Setează un program"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Prelungește autonomia bateriei"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Dezactivează când este încărcat complet"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Dezactivează la <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Economisirea bateriei se dezactivează când bateria ajunge la <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">"Activează"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Folosește Economisirea bateriei"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Se activează automat"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Niciodată"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"la baterie <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Procentajul bateriei"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Se afișează procentajul bateriei în bara de stare"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Nivelul bateriei de la ultima încărcare completă"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Nivelul bateriei în ultimele 24 h"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Utilizarea aplicațiilor de la ultima încărcare completă"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Utilizarea de către aplicații în ultimele 24 h"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Utilizarea sistemului de la ultima încărcare completă"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Utilizarea de către sistem în ultimele 24 h"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Utilizarea de către sistem pentru <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Utilizarea de către aplicații pentru <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Utilizarea sistemului de la ultima încărcare completă la <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Utilizarea aplicațiilor de la ultima încărcare completă la <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Total: mai puțin de un minut"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"În fundal: mai puțin de un minut"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Durata de folosire a dispozitivului: mai puțin de un minut"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Total: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"În fundal: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Durata de folosire a dispozitivului: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Datele despre utilizarea bateriei vor fi disponibile la câteva ore după încărcarea completă"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"acum"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> – <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g>, <xliff:g id="HOUR">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Graficul de utilizare a bateriei"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Grafic cu utilizarea zilnică a bateriei"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Grafic cu utilizarea bateriei în fiecare oră"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Utilizarea bateriei de la ultima încărcare completă"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Utilizarea bateriei pentru <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Durata de folosire a dispozitivului de la ultima încărcare completă"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Durata de folosire a dispozitivului pentru <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Vezi după aplicații"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Vezi după sisteme"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"Este posibil ca numărul de cicluri să nu fie zero la prima utilizare datorită inspecțiilor de calitate realizate înaintea expedierii"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Statistici de proces"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Statistici inteligente despre procesele care rulează"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Utilizarea memoriei"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> din <xliff:g id="TOTALRAM">%2$s</xliff:g> folosiți în <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> din RAM folosit în <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"În fundal"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"În prim-plan"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"În cache"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Sistem de operare Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Native"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Nucleu"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Procese din cache"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Utilizare RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Utilizare RAM (fundal)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Durată de rulare"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procese"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Servicii"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Durată"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detalii despre memorie"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 ore"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 ore"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 ore"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"O zi"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Afișează procesele de sistem"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Ascunde procesele de sistem"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Afișează procentajele"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Folosește Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Tipul de statistici"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"În fundal"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"În prim-plan"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"În cache"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Intrare și ieșire voce"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Setări de intrare și de ieșire a vocii"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Căutare vocală"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Tastatură Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Setări de intrare vocală"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Intrare vocală"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Servicii de intrare vocală"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Expresie de activare și interacțiune complete"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Transformare simplă a vorbirii în text"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Acest serviciu de introducere vocală va putea să asigure în permanență monitorizarea vocală și să controleze aplicațiile cu comenzi vocale în locul tău. Acesta provine din aplicația <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Activezi utilizarea acestui serviciu?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Setări de recunoaștere pe dispozitiv"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Recunoaștere pe dispozitiv"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Recunoaștere vocală pe dispozitiv"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Motor preferat"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Setările motorului"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Viteza și tonalitatea vorbirii"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Motor"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Voci"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Limba vorbită"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instalează voci"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Continuă pentru a utiliza aplicația <xliff:g id="TTS_APP_NAME">%s</xliff:g> și a instala voci"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Deschide aplicația"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Anulează"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Resetează"</string>
    <string name="tts_play" msgid="2945513377250757221">"Redă"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Nesecurizat"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> nesecurizată"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> nesecurizate"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Conectivitate adaptabilă"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Extinde autonomia bateriei și îmbunătățește performanța dispozitivului, gestionând automat conexiunile la rețea"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Activată"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Dezactivată"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Folosește conectivitatea adaptivă"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Stocarea datelor de conectare"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instalează un certificat"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Șterge datele de conectare"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Elimină toate certificatele"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Date de conectare de încredere"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Afișează certificatele CA de încredere"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Date de conectare utilizator"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Vezi și modifică datele de conectare stocate"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Avansate"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Datele de conectare nu sunt disponibile pentru acest utilizator"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Instalate pentru VPN și aplicații"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Instalate pentru Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Instalate pentru Wi-Fi (în uz)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Elimini întregul conținut?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Acreditările stocate sunt șterse."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Nu s-au șters acredit. stocate"</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Aplicații cu acces de utilizare"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certificat CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Certificatul de utilizator de aplicații și VPN"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certificat pentru Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Datele tale nu vor fi private"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Certificatele CA sunt folosite de site-uri, aplicații și VPN-uri pentru criptare. Instalează certificate CA numai de la organizații în care ai încredere. \n\nDacă instalezi un certificat CA, proprietarul certificatului îți poate accesa datele, precum parole sau datele cardului de credit, de pe site-urile pe care le accesezi sau din aplicațiile pe care le folosești, chiar dacă acele date sunt criptate."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Nu instala"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Instalează oricum"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certificatul nu a fost instalat"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Permiți ca "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" să instaleze certificate pe acest dispozitiv?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Aceste certificate îți vor confirma identitatea prin trimiterea ID-ului unic al dispozitivului tău la aplicațiile și adresele URL de mai jos"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Nu permite"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Permite"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Afișează mai multe"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Aplicație de gestionare a certificatelor"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Niciuna"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Certificatele îți vor confirma identitatea când folosești aplicațiile și adresele URL de mai jos"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Dezinstalează certificatele"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Elimină aplicația"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Elimini aplicația?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Aplicația nu va gestiona certificate, dar va rămâne pe dispozitiv. Orice certificate instalate de aplicație vor fi dezinstalate."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# adresă URL}few{# adrese URL}other{# de adrese URL}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Semnal pentru apel de urgență"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Setează comportamentul la efectuarea unui apel de urgență"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Backup"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Activat"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Dezactivat"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Backup și restabilire"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Date personale"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Backup pentru date"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Creează o copie de rezervă pentru datele aplicației, parolele Wi-Fi și pentru alte setări pe serverele Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Cont de backup"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Gestionează contul de backup"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Include datele aplicației"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Restabilire automată"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"La reinstalarea unei aplicații, restabilește setările și datele pentru care ai creat o copie de rezervă"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Serviciul de backup nu este activ"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"În prezent, niciun cont nu stochează datele cu copii de rezervă"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Vrei să oprești crearea copiei de rezervă pentru parolele Wi-Fi, marcaje, alte setări, datele aplicațiilor și să ștergi toate copiile aflate pe serverele Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Vrei să nu li se mai facă backup datelor de pe dispozitiv (de exemplu, parolele Wi-Fi și istoricul apelurilor) și datelor din aplicații (de exemplu, setările și fișierele stocate de aplicații) și să ștergi toate copiile de pe serverele la distanță?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Fă backup automat pentru datele dispozitivului (de exemplu, parolele Wi-Fi și istoricul apelurilor) și pentru datele aplicațiilor (de exemplu, setările și fișierele stocate de aplicații) de la distanță.\n\nCând activezi backupul automat, datele dispozitivului și ale aplicațiilor sunt salvate periodic de la distanță. Datele unei aplicații pot fi orice date pe care le-a salvat aplicația (în funcție de setările dezvoltatorului), inclusiv date posibil sensibile, cum a fi persoanele de contact, mesajele și fotografiile."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Setările administratorului dispozitivului"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Aplicație de administrare a dispozitivului"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Dezactivează această aplicație de administrare a dispozitivului"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Dezinstalează aplicația"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Dezactivează și dezinstalează"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Aplicații pentru admin. dispozitivului"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nu este disponibilă nicio aplicație pentru administratorul dispozitivului"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nu există agenți de încredere disponibili"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Activezi aplicația de administrare?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Activează această aplicație de administrare a dispozitivului"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administratorul dispozitivului"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Activând această aplicație de administrare, veți permite aplicației <xliff:g id="APP_NAME">%1$s</xliff:g> să efectueze următoarele operațiuni:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Acest dispozitiv va fi gestionat și monitorizat de <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Această aplicație de administrare este activă și permite aplicației <xliff:g id="APP_NAME">%1$s</xliff:g> să efectueze următoarele operațiuni:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Activezi Administratorul de profil?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Permiți supravegherea?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Dacă va continua, utilizatorul tău va fi gestionat de administrator, care ar putea să stocheze, pe lângă datele personale, și datele asociate.\n\nAdministratorul poate să monitorizeze și să gestioneze setările, accesul, aplicațiile și datele asociate acestui utilizator, inclusiv activitatea în rețea și informațiile despre locația dispozitivului."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Alte opțiuni sunt dezactivate de administrator"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Află mai multe"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Jurnal de notificări"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Istoricul notificărilor"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Ultimele %d ore"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Amânate"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Închise recent"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# notificare}few{# notificări}other{# de notificări}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Ton de apel și vibrații"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Detaliile rețelei"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sincronizare activată"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sincronizare dezactivată"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Se sincronizează acum…"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Eroare de sincronizare."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sincronizare eșuată"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sincronizare activă"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sincronizare"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Sincronizarea se confruntă în prezent cu probleme. Aceasta va fi funcțională în curând."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Adaugă un cont"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Profilul de serviciu nu este încă disponibil"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Aplicații pentru lucru"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Elimină profilul de serviciu"</string>
    <string name="background_data" msgid="321903213000101158">"Date de fundal"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplicațiile pot oricând sincroniza, trimite și primi date"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Dez. dat. de fundal?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Dezactivarea datelor de fundal crește durata de viață a bateriei și reduce nivelul de utilizare a datelor. Anumite aplicații pot utiliza în continuare conexiunea de date de fundal."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sincronizarea e ACTIVATĂ"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sincronizare DEZACTIVATĂ"</string>
    <string name="sync_error" msgid="846923369794727644">"Eroare de sincronizare"</string>
    <string name="last_synced" msgid="1527008461298110443">"Ultima sincronizare: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Se sincronizează acum…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Setări copie de rezervă"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Creează o copie de rezervă a setărilor tale"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sincronizează acum"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Anulează sincronizarea"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Atinge pentru a sincroniza acum<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">"Calendar"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Agendă"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Setări privind sincronizarea aplicației"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Datele și sincronizarea"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Schimbă parola"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Setări cont"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Elimină contul"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Adaugă un cont"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Elimini contul?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Această modificare nu este permisă de administratorul tău"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Sincronizarea manuală nu este posibilă"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"În prezent, sincronizarea pentru acest element este dezactivată. Pentru a schimba această setare, activează temporar datele de fundal și sincronizarea automată."</string>
    <string name="delete" msgid="8330605554706263775">"Șterge"</string>
    <string name="select_all" msgid="7898929601615536401">"Selectează-le pe toate"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Utilizarea datelor"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Date mobile și Wi-Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Sincronizare automată a datelor"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Autosincronizare date serviciu"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Schimbă data ciclului..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Ziua din lună pentru resetarea ciclului de utilizare a datelor:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Nicio aplic. nu a utilizat date în ac. perioadă."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Prim-plan"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Fundal"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"limitată"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Dezactivezi datele mobile?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Setează limita pentru date mobile"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Setează limita de date 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Setează limită date 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Setează limită date Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobile"</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">"Mobile"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Niciuna"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Date mobile"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Date 2G-3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Date 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"În prim-plan:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"În fundal:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Setări pentru aplicație"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Date de fundal"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Activează utilizarea datelor mobile în fundal"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Pt. a restricționa date fundal pt. aplicație, setează întâi o limită de date mobile."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Restricționezi datele de fundal?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Această funcție poate face ca o aplicație care depinde de datele de fundal să nu mai funcționeze când sunt disponibile numai rețele mobile.\n\nPoți găsi comenzi mai adecvate pentru utilizarea datelor în setările disponibile în cadrul aplicației."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Restricționarea datelor de fundal este posibilă numai dacă ai setat o limită pentru datele mobile."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Activezi sincronizarea datelor?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Oprești sincronizarea automată?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Această acțiune va economisi date și durata bateriei, dar va trebui să sincronizezi fiecare cont manual pentru a culege informațiile recente. În plus, nu vei primi notificări atunci când apar actualizări."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Data de resetare a ciclului de utilizare"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Data din fiecare lună:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Setează"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Setează un avertisment de utilizare a datelor"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Setează o limită de utilizare a datelor"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Limitarea utilizării datelor"</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">"alertă"</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">"limită"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Aplicații eliminate"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Aplicații și utilizatori eliminați"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Utilizarea rețelei"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Contorizată"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nume"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tip"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Adresă server"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Criptare PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"Secret L2TP"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identificator IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Cheie IPSec predistribuită"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Certificat de utilizator IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certificat CA IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certificat de server IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Afișează opțiunile avansate"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Domenii de căutare DNS"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Serverele DNS (de ex., 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Rute de redirecționare (ex.: 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Nume de utilizator"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Parolă"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Salvează informațiile contului"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(neutilizat)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(nu verifica serverul)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(primit de la server)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Acest tip de VPN nu poate fi conectat permanent"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Rețelele VPN activate permanent acceptă doar adrese de server numerice"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Trebuie specificat un server DNS pentru rețelele VPN activate permanent"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Adresele serverului DNS trebuie să fie numerice pentru rețelele VPN activate permanent"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Informațiile introduse nu acceptă rețelele VPN activate permanent"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Anulează"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Închide"</string>
    <string name="vpn_save" msgid="683868204634860888">"Salvează"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Conectează"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Înlocuiește"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Editați profilul VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Șterge"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Conectează-te la <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Vrei să te deconectezi de la această rețea VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Deconectează-te"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versiune"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Elimină profilul VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Înlocuiești rețeaua VPN existentă?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Setezi rețeaua VPN ca activată permanent?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Dacă activezi această setare, nu vei avea conexiune la internet până când nu se conectează rețeaua VPN"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Rețeaua VPN existentă va fi înlocuită și nu vei avea conexiune la internet până când nu se conectează rețeaua VPN"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Te-ai conectat deja la o rețea VPN activată permanent. Dacă te conectezi la altă rețea, rețeaua VPN existentă va fi înlocuită și modul activat permanent va fi dezactivat."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Te-ai conectat deja la o rețea VPN. Dacă te conectezi la altă rețea, rețeaua VPN existentă va fi înlocuită."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Activează"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"Nu te poți conecta la <xliff:g id="VPN_NAME">%1$s</xliff:g>"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Această aplicație nu acceptă rețelele VPN activate permanent"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Adaugă un profil VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Editează profilul"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Șterge profilul"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"VPN activat permanent"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nicio rețea VPN adăugată"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Menține conexiunea la rețelele VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Nu este acceptată de această aplicație"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Activată permanent"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Nesecurizată"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blochează conexiunile fără VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Este necesară conexiunea VPN?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Nesecurizată. Treci la o rețea VPN IKEv2."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Selectează un profil VPN pentru a rămâne conectat întotdeauna la rețea. Traficul de rețea va fi permis numai atunci când ești conectat(ă) la această rețea VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Niciuna"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Activarea permanentă a rețelei VPN necesită o adresă IP, atât pentru server, cât și pentru DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nu există nicio conexiune la rețea. Încercați din nou mai târziu."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"VPN s-a deconectat"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Niciuna"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Lipsește un certificat. Încearcă să editezi profilul."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistem"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Utilizator"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Dezactivează"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Activează"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Dezinstalează"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"De încredere"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Activezi certificatul CA de sistem?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Dezactivezi certificatul CA de sistem?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Elimini definitiv certificatul de utilizator CA?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Sunt folosite de"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Această intrare conține"</string>
    <string name="one_userkey" msgid="6363426728683951234">"O cheie de utilizator"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"Un certificat de utilizator"</string>
    <string name="one_cacrt" msgid="982242103604501559">"Un certificat CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d   certificate CA"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Detalii privind datele de conectare"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Date de conectare eliminate: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nu s-au instalat date de conectare ale utilizatorului"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Verificator ortografic"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Verificator ortografic pentru serviciu"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Introdu aici parola actuală pentru backupul complet"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Introdu aici o parolă nouă pentru backupurile complete"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Reintrodu aici noua parolă pentru backupul complet"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Setează parola pentru backup"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Anulează"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Actualizări de sistem suplimentare"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Rețeaua poate fi monitorizată"</string>
    <string name="done_button" msgid="6269449526248267">"Terminat"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Setează ca fiind de încredere sau elimină certificatul}few{Setează ca fiind de încredere sau elimină certificatele}other{Setează ca fiind de încredere sau elimină certificatele}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} a instalat o autoritate de certificare pe dispozitivul tău, ceea ce îi poate permite să monitorizeze activitatea în rețeaua dispozitivului, inclusiv e-mailurile, aplicațiile și site-urile securizate.\n\nPentru mai multe informații despre acest certificat, contactează administratorul.}few{{orgName} a instalat autorități de certificare pe dispozitivul tău, ceea ce le poate permite să monitorizeze activitatea în rețeaua dispozitivului, inclusiv e-mailurile, aplicațiile și site-urile securizate.\n\nPentru mai multe informații despre aceste certificate, contactează administratorul.}other{{orgName} a instalat autorități de certificare pe dispozitivul tău, ceea ce le poate permite să monitorizeze activitatea în rețeaua dispozitivului, inclusiv e-mailurile, aplicațiile și site-urile securizate.\n\nPentru mai multe informații despre aceste certificate, contactează administratorul.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} a instalat o autoritate de certificare pentru profilul tău de serviciu, ceea ce îi poate permite să monitorizeze activitatea în rețeaua de serviciu, inclusiv e-mailurile, aplicațiile și site-urile securizate.\n\nPentru mai multe informații despre acest certificat, contactează administratorul.}few{{orgName} a instalat autorități de certificare pentru profilul tău de serviciu, ceea ce le poate permite să monitorizeze activitatea în rețeaua de serviciu, inclusiv e-mailurile, aplicațiile și site-urile securizate.\n\nPentru mai multe informații despre aceste certificate, contactează administratorul.}other{{orgName} a instalat autorități de certificare pentru profilul tău de serviciu, ceea ce îi poate permite să monitorizeze activitatea în rețeaua de serviciu, inclusiv e-mailurile, aplicațiile și site-urile securizate.\n\nPentru mai multe informații despre aceste certificate, contactează administratorul.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"O terță parte îți poate monitoriza activitatea în rețea, inclusiv e-mailurile, aplicațiile și site-urile securizate.\n\nAcest lucru este posibil datorită unui certificat de încredere instalat pe dispozitivul tău."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Verifică certificatul}few{Verifică certificatele}other{Verifică certificatele}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Utilizatori multipli"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Utilizatori și profiluri"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Adaugă un utilizator/un profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Profil limitat"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Neconfigurat"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Neconfigurat – Profil cu permisiuni limitate"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Neconfigurat – Profil de serviciu"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrator"</string>
    <string name="user_you" msgid="3070562015202859996">"Tu (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Nu poți adăuga mai mulți utilizatori. Exclude un utilizator ca să adaugi altul."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Profilurile cu permisiuni limitate nu pot adăuga conturi"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Șterge <xliff:g id="USER_NAME">%1$s</xliff:g> de pe dispozitiv"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Setările ecranului de blocare"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Adaugă utilizatori din ecranul de blocare"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Treci la administrator când este andocat"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Te excluzi ca utilizator?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Ștergi utilizatorul?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Elimini acest profil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Elimini profilul?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Toate aplicațiile și datele vor fi șterse."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"În cazul în care continui, toate aplicațiile și datele din acest profil vor fi șterse."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Toate aplicațiile și datele vor fi șterse."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Se adaugă un utilizator nou…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Șterge utilizatorul"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Șterge"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Toate aplicațiile și datele din această sesiune vor fi șterse."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Șterge"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Invitat (tu)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Utilizatori"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Alți utilizatori"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Șterge activitatea invitatului"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Șterge toate aplicațiile și datele invitatului când ieși din modul pentru invitați"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Ștergi activitatea invitatului?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Aplicațiile și datele din această sesiune pentru invitați vor fi șterse acum și toate activitățile viitoare ale invitaților vor fi șterse de fiecare dată când ieși din modul pentru invitați"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"șterge, invitat, activitate, elimină, date, vizitator, golește"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Permite invitatului să inițieze apeluri"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Utilizatorul invitat va avea acces la istoricul apelurilor"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Activează apelurile telefonice și SMS-urile"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Setează acest utilizator ca administrator"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Șterge utilizatorul"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Activezi apelurile telefonice și SMS-urile?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Acest utilizator va avea acces la istoricul apelurilor și al SMS-urilor."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Elimini privilegiile de administrator?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Dacă elimini privilegiile de administrator pentru acest utilizator, tu sau alt administrator le puteți acorda din nou mai târziu"</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Informații în caz de urgență"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informații și agendă pentru <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Deschide <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Permite aplicații și conținut"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplicații cu restricții"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Extinde setările aplicației"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Alege aplicațiile de instalat"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Instalează aplicațiile disponibile"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Plăți contactless"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Aplicația de plată prestabilită"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Ca să plătești cu o aplicație de plată, apropie spatele dispozitivului de un terminal de plată"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Află mai multe"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Setezi aplicația pentru lucru ca aplicație de plată prestabilită?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Ca să plătești cu o aplicație de plată:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"profilul de serviciu trebuie să fie activat."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"Introdu PIN-ul, modelul sau parola pentru profilul de serviciu, dacă există."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Cum funcționează"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Plătește cu telefonul în magazine"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Aplicația de plată prestabilită"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nesetată"</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">"Folosește aplicația de plată prestabilită"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Folosește aplicația de plată prestabilită"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Întotdeauna"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Excepție: când este deschisă altă aplicație de plată"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"La un terminal contactless, plătește cu:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Plata la terminal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Configurează o aplicație de plată. Apoi, apropie spatele telefonului de orice terminal pe care apare simbolul de plată fără contact."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Am înțeles"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Mai multe…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Setează aplicația de plată prestabilită"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Actualizează aplicația de plată prestabilită"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"La un terminal contactless, plătește cu <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"La un terminal contactless, plătește cu <xliff:g id="APP_0">%1$s</xliff:g>.\n\n <xliff:g id="APP_1">%2$s</xliff:g> va fi înlocuită ca aplicație prestabilită de plată."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Setează ca prestabilit"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Actualizează"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Lucru"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Restricții"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Elimină restricțiile"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Schimbați codul PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Ajutor și feedback"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Cont pentru conținut"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID fotografie"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Pericole extreme"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Primește alerte de pericole extreme privind viața și bunurile"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Pericole grave"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Primește alerte pt. pericole grave privind viața și bunurile"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Alerte AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Primește buletine despre răpirile de copii"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Repetă"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Activează Managerul de apeluri"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Permite acestui serviciu să gestioneze modul de efectuare a apelurilor."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Manager de apeluri"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Alerte de urgență wireless"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Operatori de rețea"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Numele punctelor de acces"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Apelare avansată"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Apelare 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Folosește servicii LTE pentru a îmbunătăți apelurile vocale (recomandat)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Folosește servicii 4G pentru a îmbunătăți apelurile vocale (recomandat)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Folosește 5G pentru apeluri vocale"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Trimite agenda operatorului"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Trimite numerele de telefon din agendă pentru îmbunătățirea funcțiilor"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Trimiți agenda la <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Trimiți agenda operatorului?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Numerele de telefon din agendă vor fi trimise periodic la <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Cu ajutorul acestor informații se stabilește dacă persoanele de contact pot folosi anumite funcții, cum ar fi apelurile video sau unele funcții de mesagerie."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Numerele de telefon din agendă vor fi trimise periodic operatorului.<xliff:g id="EMPTY_LINE">

</xliff:g>Cu ajutorul acestor informații se stabilește dacă persoanele de contact pot folosi anumite funcții, cum ar fi apelurile video sau anumite funcții de mesagerie."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Tipul de rețea preferat"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (recomandat)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Mesaje MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Trimite și primește când datele mobile sunt dezactivate"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Comută automat la date mobile"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Folosește această rețea când are o disponibilitate mai mare"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Card SIM pentru serviciu"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Acces la aplicație și la conținut"</string>
    <string name="user_rename" msgid="8735940847878484249">"REDENUMIȚI"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Setează restricțiile aplicației"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Controlate de <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Această aplicație îți poate accesa conturile"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Această aplicație vă poate accesa conturile. Este controlată de <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Rețele Wi‑Fi și mobile"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Permite modificarea setărilor pentru rețele Wi‑Fi și mobile"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Permite modificarea împerecherilor și setărilor Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Locație"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Permite ca aplicațiile să utilizeze informațiile despre locație"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Înapoi"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Înainte"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formatează altfel"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"Cartele SIM"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Datele mobile sunt indisponibile"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Atinge pentru a selecta un card SIM de date"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Folosește întotdeauna pentru apeluri"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Alege SIM pentru date mobile"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Selectează un card SIM pentru SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Se comută cardul SIM pentru date. Poate dura până la un minut…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Folosești <xliff:g id="NEW_SIM">%1$s</xliff:g> pentru date mobile?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Când comuți la <xliff:g id="NEW_SIM">%1$s</xliff:g>, <xliff:g id="OLD_SIM">%2$s</xliff:g> nu va mai fi folosit pentru date mobile."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Folosește <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Apelează de pe"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Introdu numele cardului SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Slot pentru SIM %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Portocaliu"</string>
    <string name="color_purple" msgid="6603701972079904843">"Violet"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Starea cardului SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Stare card SIM (slot pentru SIM %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"Cartelele SIM s-au schimbat."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Atinge pentru a configura"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Întreabă de fiecare dată"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Selectează o opțiune"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Selectare SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Setări"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Rețea și internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Date mobile, Wi‑Fi, hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi, hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Dispozitive conectate"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, asociere"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, modul Cu mașina, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, modul Cu mașina"</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, modul cu mașina, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, modul cu mașina"</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">"Indisponibile, deoarece tehnologia NFC este dezactivată"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Pentru a folosi funcția, trebuie întâi să instalezi o aplicație pentru plăți"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Aplicații recente, aplicații prestabilite"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Accesul la notificări nu este disponibil pentru aplicații în profilul de lucru."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Parole și conturi"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Parole salvate, completare automată, conturi sincronizate"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Aplicații prestabilite"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Aplicații clonate"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Creează o a doua instanță a unei aplicații, astfel încât să poți folosi două conturi simultan."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Aplicații care pot fi clonate."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"Clonate: <xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g>, disponibile pentru clonare: <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g>"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Șterge toate clonele aplicației"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Nu s-au șters toate clonele aplicației"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Se creează…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Clonată"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Se creează clona <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"S-a creat clona <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Limbi, gesturi, oră, backup"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Limbile sistemului, limbile aplicațiilor, preferințe regionale, vorbire"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, conexiune la rețea, internet, wireless, date, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Notificare Wi-Fi, notificare Wi-Fi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"utilizarea datelor"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Folosește formatul de 24 de ore"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Deschide cu"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Aplicații"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"fus orar"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Cap de chat, sistem, alertă, fereastră, casetă de dialog, ecran peste alte aplicații, desen"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Lanternă, Lumină, Lanternă"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, comutator, control"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"celular, mobil, operator servicii mobile, wireless, date, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, apel, apelare"</string>
    <string name="keywords_display" msgid="874738809280751745">"ecran, ecran tactil"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"redu luminozitatea ecranului, ecran tactil, baterie, strălucitor"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"redu luminozitatea ecranului, noapte, nuanță, mod noapte, luminozitate, culoarea ecranului, culoare"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"fundal, personalizează, personalizează afișarea"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"dimensiunea textului"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"proiectare, proiectați, oglindirea ecranului, permiterea accesului la ecran, oglindire, permiteți accesul la ecran, proiectarea ecranului"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"spațiu, disc, hard disk, utilizarea dispozitivului"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"consum de energie, încărcare"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"vedeți utilizarea bateriei, utilizarea bateriei, utilizarea energiei"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"economisirea bateriei, economisirea energiei, economisire"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"preferințe adaptabile, baterie adaptabilă"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"ortografie, dicționar, verificare ortografică, corectare automată"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"instrument recunoaștere, introducere text, vorbire, rostește, limbă, mâini libere, recunoaștere, jignitor, cuvânt, audio, istoric, set căști-microfon bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"evaluați, limbă, valori prestabilite, rostiți, vorbire, redare vocală a textului, accesibilitate, cititor de ecran, orb"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"ceas, militar"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"resetează, restabilește, setări din fabrică"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"golește, șterge, restabilește, șterge, elimină, revino la setările din fabrică"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"imprimantă"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"bip difuzor, difuzor, volum, dezactivare sunet, fără sunet, audio, muzică, haptic, vibrații, vibrație"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"nu deranja, întrerupe, întrerupere, pauză"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"în apropiere, locație, istoric, raportare, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"cont, adaugă un cont, profil de serviciu, adaugă cont, elimină, șterge"</string>
    <string name="keywords_users" msgid="3497517660077620843">"restricție, restricționare, restricționat"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"corectarea textului, corectează, sunet, vibrații, automat, limbă, gest, sugerează, sugestie, temă, cuvânt, ofensator, introducere text, emoji, internațional"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"resetează, preferințe, valori prestabilite"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"aplicații, descărcare, sistem"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"aplicații, permisiuni, securitate"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"aplicații, prestabilite"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorați opțiuni optimizare, doze, standby aplicații"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"vibrantă, RGB, sRGB, culoare, naturală, standard"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, rezoluție, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"culoare, temperatură, D65, D73, alb, galben, albastru, cald, rece"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"glisează pentru a debloca, parolă, model, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"fixare pe ecran"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"provocare la serviciu, serviciu, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"profil de serviciu, profil gestionat, unificați, unificare, serviciu, profil"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"trezire, inactivitate, fără blocare, menține deblocat la pliere, pliere, închidere, pliază, închide, ecran dezactivat"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gesturi"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"portofel"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"plată, atingere, plăți"</string>
    <string name="keywords_backup" msgid="707735920706667685">"backup"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"gest"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"facială, deblocare, autorizare, conectare"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"chip, față, facială, deblocare, autentificare, conectare, amprentă, biometric"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, versiune PRL, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"rețea, starea rețelei mobile, starea acoperirii, puterea semnalului, tip de rețea mobilă, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"rețea, starea rețelei mobile, starea acoperirii, puterea semnalului, tip de rețea mobilă, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"rețea, starea rețelei mobile, starea acoperirii, puterea semnalului, tip de rețea mobilă, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"rețea, starea rețelei mobile, starea acoperirii, puterea semnalului, tip de rețea mobilă, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"număr de serie, versiune de hardware"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"informații despre baterie, data fabricării, numărul de cicluri, prima folosire"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"nivelul corecției de securitate Android, versiunea benzii de bază, versiune nucleu"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"temă, luminozitate, întunecat, mod, sensibilitate la lumină, fotofobie, întunecă, modul întunecat, migrenă"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"temă întunecată"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"eroare"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Afișare ambient, Afișare ecran de blocare"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"notificările pe ecranul de blocare, notificări"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"chip"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"amprentă, adaugă amprenta"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"chip, amprentă, adaugă amprenta"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"deblocare cu ceasul, adaugă deblocarea cu ceasul"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"redu luminozitatea ecranului, ecran tactil, baterie, luminozitate inteligentă, luminozitate dinamică, luminozitate automată"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"inteligent, redu luminozitatea ecranului, inactivitate, baterie, dezactivarea ecranului, atenție, afișaj, ecran, lipsă de activitate"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"cameră, inteligentă, rotire automată, rotiți, comutați, rotire, portret, peisaj, orientare, vertical, orizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"upgrade, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"Nu deranja, program, notificări, blochează, dezactivează sonorul, vibrații, inactivitate, serviciu, concentrare, sunet, sunet dezactivat, zi, zi din săptămână, weekend, seară din săptămână, eveniment"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"ecran, durată până la dezactivarea ecranului, timp limită, ecran de blocare"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memorie, memorie cache, date, șterge, golește, liber, spațiu"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"conectat, dispozitiv, căști, set căști-microfon, difuzoare, wireless, asociere, căști intraauriculare, muzică, conținut media"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"fundal, temă, grilă, personalizează"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"pictogramă, accent, culoare, ecran de pornire, ecran de blocare, comandă rapidă, mărimea ceasului"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"prestabilit, asistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"plată, prestabilită"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"notificare primită"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"tether usb, tether bluetooth, hotspot wi-fi"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"feedback tactil, vibrații, vibrație"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"senzor tactil, vibrații, ecran, sensibilitate"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"tactil, vibrații, telefon, apel, sensibilitate, sonerie"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"tactil, vibrații, telefon, apel, sonerie, treptat"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"tactil, vibrații, sensibilitate, notificare"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"tactil, vibrații, sensibilitate, alarmă"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"tactil, vibrații, sensibilitate, media"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"feedback tactil, vibrații, vibrație"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"economisirea bateriei, fix, persistent, economisirea energiei, baterie"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutină, program, economisirea bateriei, economisirea energiei, baterie, automat, procent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, apelare avansată, apelare 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, apelare avansată, apelare 5g"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"adaugă limbă, adaugă o limbă"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"dimensiunea textului, caractere mari, font mare, text mare, vedere slabă, mărește textul, instrument de mărire a fontului, mărirea fontului"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"afișaj ambiental activat permanent, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, etichetă, cititor"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volum, vibrații, Nu deranja"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Volum media"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Volumul proiectării"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Volumul apelului"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Volumul alarmei"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Volum pentru sonerie și notificări"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Volumul soneriei"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Volumul notificărilor"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Sonerie silențioasă"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Sonerie în modul vibrații"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Volumul pentru notificări este dezactivat, dispozitivul va vibra la notificări"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> este dezactivat"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Indisponibil deoarece soneria este dezactivată"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Ton de apel al telefonului"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Sunet de notificare prestabilit"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Sunet oferit de aplicație"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Sunet de notificare prestabilit"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Sunet de alarmă prestabilit"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Întâi vibrații, apoi sună din ce în ce mai tare"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Audio spațial"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonuri pentru tastatura numerică"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Sunet de blocare a ecranului"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Sunete și vibrații pentru încărcare"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Sunete la andocare"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Sunete pentru atingere și clic"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Afișează întotdeauna pictograma în modul vibrații"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Redare difuzor dispoz. andoc."</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Toate semnalele audio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Numai audio multimedia"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Dezactivează sunetul"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonuri"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrații"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Sunete la pornire"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Subtitrări live"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Adaugă subtitrări automate la fișierele media"</string>
    <string name="spatial_audio_speaker" product="default" msgid="3956755613908467186">"Difuzoarele telefonului"</string>
    <string name="spatial_audio_speaker" product="tablet" msgid="2261196916411018248">"Difuzoarele tabletei"</string>
    <string name="spatial_audio_speaker" product="device" msgid="3012868526054155189">"Difuzoarele dispozitivului"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Căști cu fir"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Sunetul de la dispozitivele media compatibile devine mai captivant"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Dezactivat"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Activat/<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Activat/<xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> și <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Sau poți activa funcția Audio spațial pentru dispozitivele Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Setări pentru dispozitivele conectate"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Niciunul}=1{Un program setat}few{# programe setate}other{# de programe setate}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Nu deranja"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Primește notificări doar de la persoane și aplicații importante"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Limitează întreruperile"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Activează Nu deranja"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarmele și sunetele media îl pot întrerupe"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Programe"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Șterge programele"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Ștergeți"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Editează"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Programe"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Program"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Program"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Dezactivează sunetul uneori"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Setează regulile pentru Nu deranja"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Program"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Folosește programul"</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">"Permite întreruperile care emit sunete"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blochează întreruperile vizuale"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Permite semnale vizuale"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opțiunile de afișare pentru notificările ascunse"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Când funcția „Nu deranja” este activată"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Fără sunet de la notificări"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Vei vedea notificările pe ecran"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Când sosesc notificările, telefonul nu va scoate niciun sunet și nu va vibra."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Fără imagini sau sunet de la notificări"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Nu vei vedea și nu vei auzi notificări"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Telefonul nu va afișa, vibra sau emite sunete pentru notificările noi sau existente. Reține că notificările importante pentru activitatea și starea dispozitivului vor fi afișate în continuare.\n\nCând dezactivezi modul Nu deranja, găsești notificările ratate dacă glisezi în jos din partea de sus a ecranului."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Personalizat"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Activează setarea personalizată"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Elimină setarea personalizată"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Fără sunet de la notificări"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Parțial ascunse"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Fără imagini sau sunet de la notificări"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Restricții personalizate"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Când ecranul este activat"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Când ecranul este dezactivat"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Dezactivează sunetul și vibrațiile"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Nu porni ecranul"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Dezactivează lumina intermitentă"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Nu afișa notificări pe ecran"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Ascunde pictogramele barei de stare din partea de sus a ecranului"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Ascunde punctele de notificare de pe pictogramele aplicațiilor"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Nu activa pentru notificări"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Ascunde din panoul tras în jos"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Niciodată"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Când ecranul este dezactivat"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Când ecranul este activat"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Sunet și vibrații"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Sunet, vibrații și semnale vizuale pentru notificări"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Sunet, vibrații și semnale vizuale pentru notificări"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Notificările necesare pentru activitatea de bază a dispozitivului și starea acestuia nu vor fi niciodată ascunse."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Fără sunet"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"alte opțiuni"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Adaugă"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Activează"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Activează acum"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Dezactivează acum"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Funcția Nu deranja este activată până la <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Modul Nu deranja rămâne activ până îl dezactivezi"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Modul Nu deranja a fost activat automat de un program (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Funcția Nu deranja a fost activată automat de o aplicație (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Modul Nu deranja este activat pentru <xliff:g id="RULE_NAMES">%s</xliff:g> cu setări personalizate."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Afișați setările personalizate"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Numai cu prioritate"</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">"Activat/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Activat"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Întreabă de fiecare dată"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Până când dezactivezi"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{O oră}few{# ore}other{# de ore}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{Un minut}few{# minute}other{# de minute}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Dezactivat}=1{Dezactivat / Un program se poate activa automat}few{Dezactivat / # programe se pot activa automat}other{Dezactivat / # de programe se pot activa automat}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Ce poate întrerupe modul Nu deranja"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Persoane"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Aplicații"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarme și alte întreruperi"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Programe"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Durata pentru Setări rapide"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"General"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Când este activată funcția Nu deranja, sunetele și vibrațiile vor fi dezactivate, cu excepția elementelor pe care le permiți mai sus."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Setări personalizate"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Examinează programul"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"OK"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Notificări"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Durata"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Mesaje, evenimente și mementouri"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Când este activat modul Nu deranja, sunetele pentru mesaje, mementouri și evenimente vor fi dezactivate, cu excepția elementelor pe care le permiți mai sus. Poți să modifici setările pentru mesaje ca să le permiți prietenilor, familiei sau altor persoane de contact să te contacteze."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Gata"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Setări"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Fără imagini sau sunet de la notificări"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Fără sunet de la notificări"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Nu vei vedea și nu vei auzi notificări. Sunt permise apelurile de la persoanele de contact marcate cu stea și de la apelanții care revin."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Setarea curentă)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Modifici setările pentru notificări ale modului „Nu deranja”?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Sunetele profilului de serviciu"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Folosește sunetele profilului personal"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Folosește aceleași sunete ca pentru profilul personal"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Ton de apel telefon serviciu"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Sunet prestabilit pentru notificarea de serviciu"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Sunet prestabilit pentru alarma de serviciu"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Aceleași ca la profilul personal"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Folosești sunetele profilului personal?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Confirmă"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Profilul tău de serviciu va folosi aceleași sunete ca profilul personal"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Notificări"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Istoricul notificărilor, conversații"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Conversație"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Gestionează"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Notificări de la aplicații"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Gestionează notificările de la aplicații individuale"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"General"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Notificări profil de serviciu"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Profil de serviciu"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prioritatea notificării adaptabile"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Setează automat ca Discrete notificările cu prioritate redusă"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Poziționare adaptivă a notificărilor"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Poziționează automat notificările după relevanță"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Feedback pentru notificările adaptabile"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Indică ajustările notificărilor și afișează opțiunea de a oferi feedback pentru sistem"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Resetează importanța notificărilor"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Resetează setările de importanță schimbate de utilizator și permite-i asistentului de notificări să stabilească priorități"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Acțiuni și răspunsuri sugerate"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Afișează automat acțiunile și răspunsurile sugerate"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Afișează notificările recente și pe cele amânate"</string>
    <string name="notification_history" msgid="8663811361243456201">"Istoricul notificărilor"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Folosește istoricul notificărilor"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Istoricul notificărilor a fost dezactivat"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Activează istoricul notificărilor pentru a vedea notificările recente și notificările amânate"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Nu ai notificări recente"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Notificările recente și amânate se vor afișa aici"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"Afișează setările pentru notificări"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"deschide notificarea"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Permite amânarea notificărilor"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Punct de notificare pe pictogramă"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Baloane"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Baloane"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Afișează conversația în balon"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Afișează o pictogramă flotantă deasupra aplicațiilor"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Activezi baloanele pentru dispozitiv?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Dacă activezi baloanele pentru această aplicație, se vor activa și cele pentru dispozitiv.\n\nAceasta afectează alte aplicații sau conversații care pot apărea în balon."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Activează"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Anulează"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Activate / Conversațiile pot apărea ca pictograme flotante"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Permite ca aplicațiile să afișeze baloane"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Unele conversații vor apărea ca pictograme flotante deasupra altor aplicații"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Toate conversațiile pot apărea în balon"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Conversațiile selectate pot apărea în balon"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Nimic nu poate apărea în balon"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Conversații"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Toate conversațiile pot apărea în balon, mai puțin"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Dezactivează baloanele pentru această conversație"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Activează baloanele pentru această conversație"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Glisează la dreapta pentru a respinge și la stânga pentru a afișa meniul"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Glisează la stânga pentru a respinge și la dreapta pentru a afișa meniul"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Ascunde notificările silențioase din bara de stare"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Lumină intermitentă"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Confidențialitate"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Omiterea ecranului de blocare"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"După deblocare, accesează ultimul ecran folosit. Notificările nu vor apărea pe ecranul de blocare. Glisează în jos din partea de sus ca să le vezi."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Ecran de blocare, Ecran de blocare, Omitere, Evitare"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Când este blocat profilul de serviciu"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Afișează doar notificări noi pe ecranul de blocare"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Elimină automat notificările afișate anterior de pe ecranul de pornire"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Notificări pe ecranul de blocare"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Afișează conversațiile prestabilite și silențioase"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Afișează conversațiile prestabilite și silențioase"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Ascunde conversațiile și notificările silențioase"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Nu afișa notificări"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Notificări sensibile"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Afișează conținut sensibil când ecranul este blocat"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Notificări sensibile pentru profilul de lucru"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Afișează conținutul sensibil pentru profilul de serviciu când ecranul este blocat"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Afișează integral conținutul notificărilor"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Afișează conținutul sensibil doar când ecranul este deblocat"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Nu afișa nicio notificare"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Cum vrei să se afișeze ecranul de blocare?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Ecran de blocare"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Afișează tot conținutul notificărilor de serviciu"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Ascunde conținutul de lucru sensibil"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Cum vrei să fie afișate notificările din profil când dispozitivul este blocat?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Notificări din profil"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Notificări"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Notificări din aplicații"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Categoria notificării"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Comportament"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Conversații"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Secțiunea de conversație"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Permite aplicației să folosească secțiunea de conversație"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nu este o conversație"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Elimină din secțiunea cu conversații"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Aceasta este o conversație"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Adaugă în secțiunea cu conversații"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Nu există conversații cu prioritate"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# conversație prioritară}few{# conversații prioritare}other{# de conversații prioritare}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Conversații cu prioritate"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Se afișează în partea de sus a secțiunii de conversație și apar în baloane flotante"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Se afișează în partea de sus a secțiunii de conversație"</string>
    <string name="other_conversations" msgid="551178916855139870">"Conversații fără prioritate"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Conversații pe care le-ai modificat"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Conversații recente"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Șterge conversațiile recente"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"S-au eliminat conversațiile recente"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Conversația a fost eliminată"</string>
    <string name="clear" msgid="5092178335409471100">"Șterge"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Conversațiile cu prioritate și cele modificate vor apărea aici"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"După ce marchezi o conversație ca având prioritate sau modifici conversațiile în orice alt mod, acestea vor apărea aici. \n\nPentru a modifica setările conversațiilor: \nglisează în jos din partea de sus a ecranului pentru a deschide panoul de notificări tras în jos, apoi atinge lung o conversație."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimizează"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Evidențiere pe ecran"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Silențios"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Prestabilite"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Permite întreruperi"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Permite aplicației să emită sunete, să vibreze și/sau să trimită notificări pe ecran"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritate"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Se afișează în partea de sus a secțiunii de conversație, apare ca un balon flotant, afișează fotografia de profil pe ecranul de blocare"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> nu acceptă majoritatea funcțiilor pentru conversații. Nu poți să setezi o conversație ca având prioritate și conversațiile nu vor apărea în baloane flotante."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"În panoul de notificări tras în jos, restrânge notificările pe un rând"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Fără sunet sau vibrații"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Fără sunet sau vibrații și apare în partea de jos a secțiunii de conversație"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Poate să sune sau să vibreze, în funcție de setările dispozitivului"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Când dispozitivul este deblocat, afișează notificările ca un banner în partea de sus a ecranului"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Toate notificările din „<xliff:g id="APP_NAME">%1$s</xliff:g>”"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Toate notificările din <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Aproximativ # notificare pe zi}few{Aproximativ # notificări pe zi}other{Aproximativ # de notificări pe zi}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Aproximativ # notificare pe săptămână}few{Aproximativ # notificări pe săptămână}other{Aproximativ # de notificări pe săptămână}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Niciodată"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Notificări pe dispozitive și în aplicații"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Gestionează aplicațiile și dispozitivele care pot citi notificări"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Accesul la notificările privind profilul de serviciu este blocat"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Notificări optimizate"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Primite acțiuni sugerate, răspunsuri și altele"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Fără"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Nicio aplicație instalată nu a solicitat accesul la notificări."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Permite accesul la notificări"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Notificările optimizate au înlocuit Notificările adaptive Android de pe Android 12. Această funcție afișează acțiuni și răspunsuri sugerate și îți organizează notificările. \n\nNotificările optimizate pot accesa conținutul notificărilor, inclusiv informații cu caracter personal, precum mesajele și numele persoanelor de contact. În plus, funcția poate să închidă sau să răspundă la notificări, de exemplu, să răspundă la apeluri telefonice și să gestioneze opțiunea Nu deranja."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Permiți accesul la notificări pentru <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Aplicația <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> va putea să citească toate notificările, inclusiv informațiile cu caracter personal, cum ar fi numele persoanelor de contact, fotografiile și textul mesajelor primite. În plus, va putea să amâne sau să închidă notificări ori să declanșeze butoane pentru acțiuni din acestea, inclusiv să răspundă la apeluri telefonice. \n\nAstfel, aplicația va putea să activeze sau să dezactiveze starea Nu deranja și să modifice setările aferente."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Aplicația <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> va putea:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"să citească notificările;"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Poate să citească notificările, inclusiv informațiile cu caracter personal, cum ar fi agenda, mesajele și fotografiile."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"să răspundă la mesaje;"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Poate să răspundă la mesaje și să declanșeze butoane pentru acțiuni din notificări, inclusiv să amâne sau să închidă notificări și să răspundă la apeluri."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"să modifice setările."</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Poate să activeze sau să dezactiveze starea Nu deranja și să modifice setările aferente."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Dacă dezactivezi accesul notificărilor pentru <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, este posibil să se dezactiveze și accesul când starea este Nu deranja."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Dezactivează"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Anulează"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"În timp real"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Comunicări în desfășurare din aplicațiile folosite, navigare, apeluri telefonice și altele"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Conversații"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS-uri, mesaje text și alte comunicări"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Notificări"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Poate să sune sau să vibreze, în funcție de setări"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Silențioase"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Notificări care nu sună și nu vibrează"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Au permisiunea"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nu au permisiunea"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Vezi toate aplicațiile"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Modifică setările pentru fiecare aplicație care trimite notificări"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Aplicații care apar pe dispozitiv"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Aplicația nu acceptă setările optimizate"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Mai multe setări"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Mai multe setări sunt disponibile în această aplicație"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Servicii de ajutor pentru RV"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nicio aplicație instalată nu a solicitat să fie rulată ca un serviciu de ajutor pentru RV."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Permiți accesul la serviciul RV pentru <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> va putea rula când folosești aplicațiile în modul de realitate virtuală."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Când dispozitivul este în RV"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Redu estomparea (recomandat)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Redu pâlpâirea"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Picture-in-picture"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Niciuna dintre aplicațiile instalate nu acceptă Picture-in-picture"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip picture in"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Picture-in-picture"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Permite picture-in-picture"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Permite acestei aplicații să creeze o fereastră picture-in-picture în timp ce aplicația este deschisă sau după ce ieși (de exemplu, pentru a continua vizionarea unui videoclip). Această fereastră se afișează peste alte aplicații pe care le folosești."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Aplicații personale și profesionale conectate"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Conectat(ă)"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Neconectat(ă)"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Nicio aplicație conectată"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"mai multe profiluri aplicație conectată aplicații pentru lucru și personale"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Conectate"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Conectezi aceste aplicații"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Aplicațiile conectate au permisiuni în comun și își pot accesa reciproc datele."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Conectează aplicațiile doar dacă ai încredere că nu-i vor permite administratorului IT accesul la datele cu caracter personal."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Poți deconecta oricând aplicații din setările de confidențialitate ale dispozitivului."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Ai încredere să permiți accesul aplicației pentru lucru <xliff:g id="NAME">%1$s</xliff:g> la datele tale cu caracter personal?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Conectează aplicațiile doar dacă ai încredere că nu-i vor permite administratorului IT accesul la datele cu caracter personal."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Datele aplicațiilor"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Aplicația poate accesa datele din aplicația ta personală <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Permisiuni"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Aplicația poate folosi permisiunile aplicației personale <xliff:g id="NAME">%1$s</xliff:g>, precum accesul la locație, la stocare sau la persoanele de contact."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nicio aplicație conectată"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# aplicație conectată}few{# aplicații conectate}other{# de aplicații conectate}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Ca să conectezi aceste aplicații, instalează <xliff:g id="NAME">%1$s</xliff:g> în profilul de serviciu"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Ca să conectezi aceste aplicații, instalează <xliff:g id="NAME">%1$s</xliff:g> în profilul personal"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Atinge ca să instalezi aplicația"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Acces la funcția Nu deranja"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Permite modul Nu deranja"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Nicio aplicație instalată nu a solicitat accesul Nu deranja"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Nu ai permis notificările de la această aplicație"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"La solicitarea ta, Android blochează această categorie de notificări pe dispozitiv"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"La solicitarea ta, Android blochează acest grup de notificări pe dispozitiv"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Aplicația nu trimite notificări"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Categorii"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Altele"</string>
    <string name="no_channels" msgid="4716199078612071915">"Această aplicație nu a postat nicio notificare"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Setări suplimentare în aplicație"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# categorie a fost ștearsă}few{# categorii au fost șterse}other{# de categorii au fost șterse}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blochează-le pe toate"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Aceste notificări nu se afișează niciodată"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Afișează notificările"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nu afișa niciodată notificările în umbră sau pe dispozitive periferice"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Permite notificările pe ecran complet"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Permite afișarea notificărilor pe ecran complet când dispozitivul e blocat"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Permite un punct de notificare"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Afișează punctul de notificare"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Ignoră Nu deranja"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Permite acestor notificări să te întrerupă când este activat modul Nu deranja"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Ecran de blocare"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Terminat"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Lumină intermitentă"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibrație"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Sunet"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Cu prioritate"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Numele programului"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Introdu numele programului"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Numele programului este folosit deja"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Adaugă mai multe"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Adaugă programul evenimentului"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Adaugă programul pentru intervalul orar"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Alege tipul de program"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Ștergi regula „<xliff:g id="RULE">%1$s</xliff:g>”?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Șterge"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Aceste setări nu pot fi modificate momentan. O aplicație (<xliff:g id="APP_NAME">%1$s</xliff:g>) a activat automat funcția Nu deranja cu comportament personalizat."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Aceste setări nu pot fi modificate momentan. O aplicație a activat automat funcția Nu deranja cu comportament personalizat."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Aceste setări nu pot fi modificate momentan. Funcția Nu deranja a fost activată cu comportament personalizat."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Interval orar"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Eveniment"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"În timpul evenimentelor pentru"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Orice calendar"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Când răspunsul este"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Da, Poate sau Niciun răspuns"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Da sau Poate"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Da"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Regula nu a fost găsită."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Activat/<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">"Zile"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Niciuna"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarma poate să modifice ora de încheiere"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Programul se dezactivează când sună alarma"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Comportamentul modului Nu deranja"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Folosește setările prestabilite"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Creează setări personalizate pentru acest program"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Pentru „<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">"Conversații"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Toate conversațiile"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Conversații cu prioritate"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"conversații prioritare"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Niciuna"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Niciuna}=1{O conversație}few{# conversații}other{# de conversații}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Cine poate întrerupe"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Chiar dacă aplicațiile de mesagerie sau apeluri nu îți pot trimite notificări, persoanele alese aici te pot contacta prin aceste aplicații"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Apeluri"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Apeluri"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"apeluri"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Apeluri care pot întrerupe"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Pentru a te asigura că apelurile permise emit sunete, verifică dacă dispozitivul este setat să sune"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Pentru „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>”, apelurile primite sunt blocate. Poți să modifici setările ca să le permiți prietenilor, familiei sau altor persoane de contact să te contacteze."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Contacte marcate cu stea"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Niciuna}=1{{contact_1}}=2{{contact_1} și {contact_2}}=3{{contact_1}, {contact_2} și {contact_3}}few{{contact_1}, {contact_2} și încă #}other{{contact_1}, {contact_2} și încă #}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Fără nume)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Mesaje"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"mesaje"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Mesaje"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Mesaje care îl pot întrerupe"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Pentru a te asigura că mesajele permise emit sunete, verifică dacă dispozitivul este setat să sune"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Pentru „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>”, mesajele primite sunt blocate. Poți să modifici setările ca să le permiți prietenilor, familiei sau altor persoane de contact să ia legătura cu tine."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Toate mesajele ajung la tine"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Toate apelurile ajung la tine"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Niciuna}=1{O persoană de contact}few{# persoane de contact}other{# de persoane de contact}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Oricine"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Contacte din Agendă"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Persoane din agendă marcate cu stea"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Niciunul"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Niciunul"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarme"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"De la temporizatoare, alarme, sisteme de securitate și alte aplicații"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarme"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarme"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Sunete media"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Sunete provenite de la videoclipuri, jocuri și alte fișiere media"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"media"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Media"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Sunete la atingere"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Sunete provenite de la tastatură și alte butoane"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"sunete la atingere"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Sunete la atingere"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Mementouri"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"De la sarcini și mementouri"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"mementouri"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Mementouri"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Evenimentele din calendar"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"De la evenimentele viitoare din calendar"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"evenimente"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Evenimente"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Permite aplicațiilor să ignore"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Aplicații care pot întrerupe"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Selectează mai multe aplicații"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nicio aplicație selectată"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Nicio aplicație nu îl poate întrerupe"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Adaugă aplicații"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Toate notificările"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Anumite notificări"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Persoanele selectate te pot contacta chiar dacă nu permiți ca aplicațiile să întrerupă"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Nicio aplicație nu îl poate întrerupe}=1{{app_1} îl poate întrerupe}=2{{app_1} și {app_2} îl pot întrerupe}=3{{app_1}, {app_2} și {app_3} îl pot întrerupe}few{{app_1}, {app_2} și încă # îl pot întrerupe}other{{app_1}, {app_2} și încă # îl pot întrerupe}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Aplicații"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Notificări care pot întrerupe"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Permite toate notificările"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nimic nu îl poate întrerupe}=1{{sound_category_1} îl poate întrerupe}=2{{sound_category_1} și {sound_category_2} îl pot întrerupe}=3{{sound_category_1}, {sound_category_2} și {sound_category_3} îl pot întrerupe}few{{sound_category_1}, {sound_category_2} și încă # îl pot întrerupe}other{{sound_category_1}, {sound_category_2} și încă # îl pot întrerupe}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nimic nu îl poate întrerupe"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Nimeni nu îl poate întrerupe"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Anumite persoane îl pot întrerupe"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Oricine îl poate întrerupe"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Apelanți care revin"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Permite apelanți care revin"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"oricine"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"agendă"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"persoane din agendă marcate cu stea"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"apelanți care revin"</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> și <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Dacă aceeași persoană apelează a doua oară într-un interval de <xliff:g id="MINUTES">%d</xliff:g> minute"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Ora de începere"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Ora de încheiere"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"La <xliff:g id="FORMATTED_TIME">%s</xliff:g> a doua zi"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Schimbă la „Numai alarme” pe o perioadă nedefinită"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Schimbă la Numai alarme pentru un minut, până la {time}}few{Schimbă la Numai alarme pentru # minute, până la {time}}other{Schimbă la Numai alarme pentru # de minute, până la {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Schimbă la Numai alarme pentru o oră, până la {time}}few{Schimbă la Numai alarme pentru # ore, până la {time}}other{Schimbă la Numai alarme pentru # de ore, până la {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Schimbă la „Numai alarme” până la <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Schimbă la „Întrerupe întotdeauna”"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Avertisment"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Închide"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Trimite feedback despre dispozitiv"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Introdu codul PIN de administrator"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Activat(ă)"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Dezactivat(ă)"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Activat"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Dezactivat"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Activată"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Dezactivată"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Fixarea aplicației"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Cu ajutorul fixării aplicației, poți fixa aplicația actuală pentru a rămâne vizibilă până la anularea fixării. Această funcție poate fi folosită, de exemplu, pentru a-i permite unui prieten de încredere să joace un anumit joc."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Atunci când o aplicație este fixată, aceasta poate deschide alte aplicații și pot fi accesate date cu caracter personal. \n\nPentru a folosi fixarea aplicației: 	\n1. activează fixarea aplicației; 	\n2. deschide Recente; 	\n3. atinge pictograma aplicației din partea de sus a ecranului, apoi atinge Fixează."</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Atunci când o aplicație este fixată, aceasta poate deschide alte aplicații și pot fi accesate date cu caracter personal. \n\nDacă vrei să permiți în siguranță accesul cuiva la dispozitivul tău, folosește un utilizator invitat. \n\nPentru a folosi fixarea aplicației: 	\n1. activează fixarea aplicației; 	\n2. deschide Recente; 	\n3. atinge pictograma aplicației din partea de sus a ecranului, apoi atinge Fixează."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Atunci când o aplicație este fixată: \n\n•		pot fi accesate date cu caracter personal \n		(cum ar fi agenda și conținutul e-mailurilor); \n•		aplicația fixată poate deschide alte aplicații. \n\nFolosește fixarea aplicației numai cu persoane în care ai încredere."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Solicită mai întâi modelul pentru deblocare"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Solicită codul PIN înainte de a anula fixarea"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Solicită parola înainte de a anula fixarea"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Blochează dispozitivul la anularea fixării"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Confirmă ștergerea profilului SIM"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Confirmă-ți identitatea înainte să ștergi un eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Protecția avansată a memoriei beta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Protecția avansată a memoriei"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Această funcție beta te ajută să protejezi dispozitivul împotriva erorilor care îți pot periclita securitatea."</string>
    <string name="memtag_on" msgid="824938319141503923">"Activată"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Dezactivată"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Activată după repornire"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Dezactivată după repornire"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Momentan indisponibilă pentru dispozitivul tău"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Activată permanent pentru dispozitivul tău"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Va trebui să repornești dispozitivul pentru a activa sau dezactiva Protecția avansată a memoriei. Când este activată, este posibil să observi o performanță mai lentă a dispozitivului."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Repornești dispozitivul?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Va trebui să repornești dispozitivul pentru a activa Protecția avansată a memoriei."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Va trebui să repornești dispozitivul pentru a dezactiva Protecția avansată a memoriei."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Repornește"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Nu acum"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Află mai multe despre Protecția avansată a memoriei."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Acest profil de serviciu este gestionat de:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Gestionat de <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Deschide în mod prestabilit"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Deschide linkurile acceptate"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Permite deschiderea linkurilor web în această aplicație"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Linkuri de deschis în această aplicație"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Linkuri acceptate"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Alte preferințe prestabilite"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Adaugă un link"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"O aplicație poate verifica linkurile pentru a putea fi deschise automat în aplicația respectivă."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# link verificat}few{# linkuri verificate}other{# de linkuri verificate}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Linkul este verificat și se deschide automat în această aplicație.}few{Linkurile sunt verificate și se deschid automat în această aplicație.}other{Linkurile sunt verificate și se deschid automat în această aplicație.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Afișează lista de linkuri verificate"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Se caută alte linkuri acceptate…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Anulează"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# link acceptat}few{# linkuri acceptate}other{# de linkuri acceptate}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Adaugă"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Se deschide în <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> utilizați din <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"memoria internă"</string>
    <string name="storage_type_external" msgid="125078274000280821">"stocarea externă"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> folosiți din <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Spațiu de stocare utilizat"</string>
    <string name="change" msgid="273206077375322595">"Schimbă"</string>
    <string name="change_storage" msgid="8773820275624113401">"Schimbă stocarea"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Notificări"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Activate"</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">"Dezactivat"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# categorie dezactivată}few{# categorii dezactivate}other{# de categorii dezactivate}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# permisiune suplimentară}few{# permisiuni suplimentare}other{# de permisiuni suplimentare}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nicio permisiune acordată"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nicio permisiune solicitată"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Controlează accesul aplicațiilor la date"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Tabloul de bord de confidențialitate"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Arată aplicațiile care au folosit recent permisiuni"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Aplicații nefolosite"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# aplicație nefolosită}few{# aplicații nefolosite}other{# de aplicații nefolosite}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Setările aplicațiilor nefolosite"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Întrerupe activitatea în aplicațiile nefolosite"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Elimină permisiunile, șterge fișierele temporare și oprește notificările"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Toate aplicațiile"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Aplicații instalate"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Aplicații instantanee"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Dezactivate"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Avansate"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Manager de permisiuni"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Actualizări privind permiterea accesului la date pentru locație"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Examinează aplicațiile care au schimbat modul în care pot permite accesul la datele tale privind locațiile"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Atinge pentru a activa"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Atinge de două ori oriunde pe ecran pentru a activa dispozitivul"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Deschiderea linkurilor"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Nu deschide linkurile acceptate"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Deschide „<xliff:g id="DOMAIN">%s</xliff:g>”"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Deschide <xliff:g id="DOMAIN">%s</xliff:g> și alte adrese URL"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Permite aplicației să deschidă linkurile acceptate"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Întreabă de fiecare dată"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Nu permite aplicației să deschidă linkuri"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Aplicația susține că gestionează # link}few{Aplicația susține că gestionează # linkuri}other{Aplicația susține că gestionează # de linkuri}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Aplicația susține că gestionează următoarele linkuri:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Asistent și intrare vocală"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Aplicația asistent digital"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Aplicația asistent digital prestabilită"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Sunt de acord"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Aplicația browser"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Aplicația Telefon"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistem)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Stocare per aplicație"</string>
    <string name="usage_access" msgid="5487993885373893282">"Acces la datele de utilizare"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Permite accesul la datele de utilizare"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Durata de folosire a dispozitivului"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Accesul la datele de utilizare permite unei aplicații să înregistreze ce alte aplicații folosiți și cât de des le folosești, precum și operatorul, setările de limbă și alte detalii."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memorie"</string>
    <string name="always_running" msgid="9012705720688200252">"Rulează întotdeauna (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Rulează uneori (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Rulează rar (<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">"Optimizarea bateriei"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Neoptimizate"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Neoptimizată"</string>
    <string name="high_power_off" msgid="317000444619279018">"Se optimizează utilizarea bateriei"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimizarea bateriei nu este disponibilă"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Permiți aplicației să ruleze încontinuu în fundal?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Dacă permiți aplicației <xliff:g id="APP_NAME">%1$s</xliff:g> să ruleze încontinuu în fundal, autonomia bateriei poate scădea. \n\nPoți modifica opțiunea ulterior din Setări &gt; Aplicații."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Utilizare de la ultima încărcare completă: <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> în ultimele 24 de ore"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Bateria nu a fost folosită de la ultima încărcare completă"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Trimiți raportul de eroare?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Administratorul IT a solicitat un raport de eroare pentru a remedia problemele acestui dispozitiv. Este posibil să se permită accesul la date și aplicații."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Administratorul IT a solicitat un raport de eroare pentru a remedia problemele acestui dispozitiv. Este posibil să se permită accesul la date și aplicații, iar funcționarea dispozitivului poate fi încetinită temporar."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Raportul de eroare se trimite administratorului IT. Contactează-l pentru mai multe detalii."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Trimite"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Refuză"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Fără transfer de date"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Încarcă dispozitivul conectat"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Transfer de fișier"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Cameră web"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Fă conversia videoclipurilor în AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videoclipurile vor putea fi redate în mai multe playere media, dar calitatea poate fi redusă"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Tethering prin USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Folosește conexiunea USB pentru"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Configurație USB prestabilită"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Aceste setări se vor aplica atunci când este conectat un alt dispozitiv și telefonul este deblocat. Conectează-te numai la dispozitive de încredere."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Opțiuni pentru alimentare"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Opțiuni pentru transferul de fișiere"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Preferințe USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB controlat de"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Dispozitiv conectat"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Acest dispozitiv"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Se comută…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Nu s-a putut comuta"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Încărcarea acestui dispozitiv"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Se încarcă dispozitivul conectat"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Transfer de fișiere"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Tethering prin USB"</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">"Cameră web"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Transfer de fișier și alimentarea altui dispozitiv"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Tethering prin USB și alimentarea altui dispozitiv"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP și alimentarea altui dispozitiv"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI și alimentarea altui dispozitiv"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Cameră web și alimentare"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Verificare de fundal"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Folosește textul de pe ecran"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Permite aplicației asistent să acceseze conținutul ecranului ca text"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Folosește captura de ecran"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Permite aplicației asistent să acceseze o imagine a ecranului"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Iluminare intermitentă a ecranului"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Marginile ecranului iluminează intermitent când aplicația asistent accesează text de pe ecran sau din captura de ecran"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Aplicațiile asistent te pot ajuta pe baza informațiilor din ecranul afișat. Pentru a-ți oferi o asistență integrată, unele aplicații acceptă atât serviciile cu lansatoare, cât și pe cele de intrare vocală."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Utilizare medie a memoriei"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Utilizare maximă a memoriei"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Utilizarea memoriei"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Utilizarea de către aplicații"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detalii"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"În ultimele 3 ore s-a folosit o memorie medie de <xliff:g id="SIZE">%1$s</xliff:g>"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"În ultimele 3 ore memoria nu a fost folosită deloc"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sortează după utilizarea medie"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sortează după utilizarea maximă"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Performanță"</string>
    <string name="total_memory" msgid="5244174393008910567">"Memoria totală"</string>
    <string name="average_used" msgid="690235917394070169">"Utilizare medie (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Disponibilă"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memorie utilizată de aplicații"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 aplicație a folosit memorie în ultima {time}}few{# aplicații au folosit memorie în ultima {time}}other{# de aplicații au folosit memorie în ultima {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frecvență"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Utilizare maximă"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Nu s-au folosit date"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Permiți accesul la Nu deranja pentru <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Aplicația va putea să activeze/dezactiveze setarea Nu deranja și să modifice setări similare."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Trebuie să rămână activat deoarece accesul notificărilor este activat"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Revoci accesul la Nu deranja pentru <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Toate regulile din modul Nu deranja create de această aplicație vor fi eliminate."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Nu se optimizează"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Se optimizează"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Este posibil ca bateria să se descarce mai rapid. Aplicațiile vor putea să folosească bateria în fundal."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Recomandată pentru o autonomie mai bună a bateriei"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Nicio aplicație"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Dezactivarea accesului la datele de utilizare pentru această aplicație nu împiedică administratorul să urmărească utilizarea datelor pentru aplicații în profilul tău de serviciu"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Afișare peste alte aplicații"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Afișare peste alte aplicații"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Permite afișarea peste alte aplicații"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Permite acestei aplicații să se afișeze peste alte aplicații pe care le folosești. Aceasta poate vedea unde atingi sau poate schimba ceea ce apare pe ecran."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Acces la toate fișierele"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Permite gestionarea fișierelor"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Permite aplicației să citească, să modifice și să șteargă toate fișierele de pe dispozitiv sau din spațiile de stocare conectate. Dacă îi permiți, aplicația poate accesa fișierele fără consimțământul tău explicit."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Poate accesa toate fișierele"</string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Notificări pe ecran complet"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Permite notificările pe ecran complet de la această aplicație"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Permite aplicației să afișeze notificări care ocupă întregul ecran când dispozitivul e blocat. Aplicațiile le pot folosi pentru a evidenția alarme, apeluri primite sau alte informații urgente."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Aplicații de gestionare media"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Aplicația poate gestiona conținutul media"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Dacă îi permiți, aplicația poate să modifice sau să șteargă fișiere media create cu alte aplicații fără a te întreba. Aplicația trebuie să aibă permisiunea de a accesa fișierele."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Media, Fișier, Management, Manager, Gestionează, Editează, Editor, Aplicație, Aplicație, Program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"rv realitate virtuală instrument de ascultare stereo serviciu de ajutor"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Afișare peste alte aplicații"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplicații cu permisiune"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Permisă"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nepermisă"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instalare aplicații din surse necunoscute"</string>
    <string name="write_settings" msgid="6864794401614425894">"Modificarea setărilor de sistem"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"scrie modifică setări de sistem"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Pot instala alte aplicații"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Pot modifica setările de sistem"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Pot modifica setările de sistem"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Modificarea setărilor de sistem"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Permite modificarea setărilor de sistem"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Având această permisiune, o aplicație poate să modifice setările de sistem."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Permiți din această sursă"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Două răsuciri pentru camera foto"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Deschide aplicația Cameră foto răsucind din încheietura mâinii de două ori"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Dimensiunea afișării"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Mărește sau micșorează toate elementele de pe ecran"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"densitate afișaj, zoom ecran, scară, scalare"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Previzualizare"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Micșorează"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Mărește"</string>
    <string name="disconnected" msgid="3469373726996129247">"Neconectat"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Neconectată"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> aplicații instalate"</string>
    <string name="storage_summary" msgid="5903562203143572768">"Spațiu folosit: <xliff:g id="PERCENTAGE">%1$s</xliff:g>; spațiu liber: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tema întunecată, dimensiunea fontului, luminozitate"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Memorie folosită în medie: <xliff:g id="USED_MEMORY">%1$s</xliff:g> din <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g>"</string>
    <string name="users_summary" msgid="8473589474976307510">"Te-ai conectat ca <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Actualizat la Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Actualizare disponibilă"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Blocată de politica de la locul de muncă"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Nu se poate modifica volumul"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Nu se pot iniția apeluri"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Nu se pot trimite SMS-uri"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Nu se poate folosi camera foto"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Nu se pot face capturi de ecran"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Nu se poate deschide aplicația"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blocată de creditor"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Acord parental necesar"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Dă telefonul părinților ca să înceapă configurarea"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Dă telefonul părinților ca să permită modificarea acestei setări."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Pentru mai multe informații, contactează administratorul IT"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Mai multe detalii"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Administratorul poate să monitorizeze și să gestioneze aplicațiile și datele asociate profilului de serviciu, inclusiv setările, permisiunile, accesul la nivelul companiei, activitatea în rețea și informațiile despre locația dispozitivului."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Administratorul poate să monitorizeze și să gestioneze aplicațiile și datele asociate acestui utilizator, inclusiv setările, permisiunile, accesul la nivelul companiei, activitatea în rețea și informațiile despre locația dispozitivului."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Administratorul poate să monitorizeze și să gestioneze aplicațiile și datele asociate acestui dispozitiv, inclusiv setările, permisiunile, accesul la nivelul companiei, activitatea în rețea și informațiile despre locația dispozitivului,"</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Este posibil ca administratorul dispozitivului să acceseze date asociate dispozitivului, să gestioneze aplicații și să modifice setările acestuia."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Dezactivează"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Activează"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Afișează"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Ascunde"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspotul este activ"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Modul Avion este activat"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Rețelele nu sunt disponibile"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Funcția Nu deranja este activată"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Sunetul telefonului este dezactivat"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Cu excepții"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Economisire baterie activată"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funcții restricționate"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Datele mobile sunt dezactivate"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internetul este disponibil numai prin Wi-Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Economizor de date"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funcții restricționate"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Profil de serviciu dezactivat"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Pentru aplicații și notificări"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Pornește sunetul"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Soneria a fost dezactivată"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Pentru apeluri și notificări"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Doar vibrații"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Pentru apeluri și notificări"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Setează programul pe Lumină de noapte"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Setează colorarea automată a ecranului în fiecare seară"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Lumina de noapte este activată"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Ecran cu tentă de chihlimbar"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Tonuri de gri"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Afișează numai pe gri"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Restrânge"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Temperatura culorii: rece"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Folosește culori mai reci pentru afișare"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Pentru a aplica modificarea culorilor, dezactivează ecranul"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Senzor laser al camerei foto"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Actualizări automate de sistem"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Aplică actualizările când repornește dispozitivul"</string>
    <string name="usage" msgid="287782903846013936">"Utilizare"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Utilizarea datelor mobile"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Date utilizate de aplicații"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Utilizarea datelor Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Utilizarea datelor în rețele diferite de cele de operator"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Utilizarea datelor ethernet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> de date mobile"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"Date Wi-Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"Date ethernet: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Alertă și limită de date"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Ciclul de utilizare a datelor mobile"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Avertisment pentru date: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Limită de date: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Avertisment pentru date: <xliff:g id="ID_1">^1</xliff:g> / Limită de date: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="operator_warning" msgid="5672761970087591211">"Cuantificarea datelor de către operator poate fi diferită de cea de pe dispozitiv"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Sunt excluse datele folosite în rețele de operator"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Date utilizate: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Setează avertisment pentru date"</string>
    <string name="data_warning" msgid="2925054658166062884">"Avertisment pentru date"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Avertismentul pentru date și limita de date sunt măsurate de dispozitiv, dar pot fi diferite față de datele operatorului."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Setează limita de date"</string>
    <string name="data_limit" msgid="8731731657513652363">"Limită de date"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"S-au folosit <xliff:g id="ID_1">%1$s</xliff:g> în perioada <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Configurează"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Alte aplicații incluse în utilizare"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{O aplicație are permisiunea să folosească date nerestricționate când Economizorul de date este activat}few{# aplicații au permisiunea să folosească date nerestricționate când Economizorul de date este activat}other{# de aplicații au permisiunea să folosească date nerestricționate când Economizorul de date este activat}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Date principale"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Date Wi‑Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> folosiți"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Mai mult de <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Rămas: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graficul arată utilizarea datelor între <xliff:g id="START_DATE">%1$s</xliff:g> și <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Nu există date în acest interval de date"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{A mai rămas # zi}few{Au mai rămas # zile}other{Au mai rămas # de zile}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Nu a mai rămas timp"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"A rămas mai puțin de o zi"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Actualizat de <xliff:g id="ID_1">^1</xliff:g> acum <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Actualizat acum <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Actualizat de <xliff:g id="ID_1">^1</xliff:g> chiar acum"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Actualizat chiar acum"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Afișează planul"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Vezi detaliile"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Economizor de date"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Date nerestricționate"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Datele de fundal sunt dezactivate"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Activat"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Dezactivat"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Folosește economizorul de date"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Utilizare nerestricționată a datelor"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Permite acces nerestricționat la date când Economizorul de date e activat"</string>
    <string name="home_app" msgid="6056850504746902747">"Aplicația din ecranul de pornire"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Adaugă încă o amprentă"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Deblochează cu un alt deget"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Activată"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Se va activa la <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Dezactivată"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Utilizarea bateriei pentru aplicații"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Setează utilizarea bateriei pentru aplicații"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Afișează setările"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Consultă"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"OK"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Este util acest mesaj?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Pictogramă de avertizare cu sfaturi pentru baterie"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Activează luminozitatea adaptivă pentru a prelungi autonomia bateriei"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Redu durata până la dezactivarea ecranului pentru a prelungi autonomia bateriei"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> a consumat mai multă baterie"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> a consumat mai multă baterie decât de obicei"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> a consumat mai multă baterie în fundal"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> a consumat mai multă baterie decât de obicei în fundal"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> a consumat mai multă baterie în prim-plan"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> a consumat mai multă baterie decât de obicei în prim-plan"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Utilizare intensă a bateriei"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Utilizare intensă a bateriei în fundal"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Utilizare intensă a bateriei în prim-plan"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Fără restricții"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimizată"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Restricționată"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Verificator ortografic prestabilit"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Alege verificatorul ortografic"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Folosește verificatorul ortografic"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Neselectat"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"cheie"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grup"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(rezumat)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"importanță"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"explicație"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"poate afișa insigna"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intenție"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"intenție de ștergere"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intenție de trecere în ecran complet"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"acțiuni"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"titlu"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"date introduse de la distanță"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"vizualizare personalizată"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"conținut suplimentar"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"pictogramă"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"dimensiune pachet"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"notificare trimisă"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"canal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Obiectul clasificării lipsește."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Obiectul clasificării nu conține această cheie."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Decupajul ecranului"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"decupare ecran"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Prestabilit pentru dispozitiv"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Nu s-a reușit aplicarea suprapunerii"</string>
    <string name="special_access" msgid="1767980727423395147">"Acces special pentru aplicații"</string>
    <string name="special_access_more" msgid="132919514147475846">"Vezi mai multe"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Activități de durată în fundal"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Permite activitățile îndelungate în fundal"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Activități de durată în fundal"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Permite aplicației să execute activități îndelungate în fundal. Astfel, aplicația poate să execute activități care se pot finaliza în mai mult de câteva minute, cum ar fi descărcările și încărcările. \n\nDacă permisiunea este refuzată, sistemul va limita timpul în care aplicația poate executa astfel de activități în fundal."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"activități îndelungate, transfer de date, activități în fundal"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Resetează limitarea frecvenței pentru ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Limitarea frecvenței pentru ShortcutManager a fost resetată"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Controlează informațiile de pe ecranul de blocare"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Afișează sau ascunde conținutul notificării"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Sfaturi și asistență"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Cea mai mică lățime"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Nicio aplicație instalată nu a solicitat accesul la SMS-urile premium"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"SMS-urile premium pot genera costuri care se vor adăuga la factura operatorului. Dacă activezi permisiunea pentru o aplicație, vei putea trimite SMS-uri premium folosind acea aplicație."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Acces la SMS-uri premium"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Dezactivat"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Conectat la <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Conectat la mai multe dispozitive"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Mod demonstrativ pentru IU sistem"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Temă întunecată"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Dezactivată temporar de Economisirea bateriei"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Dezactivat temporar de Economisirea bateriei"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Dezactivează Economisirea bateriei"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Pornit temporar de Economisirea bateriei"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Încearcă Tema întunecată"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Ajută la extinderea autonomiei bateriei"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Casete dezvoltator pentru setări rapide"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Dezactivează expirarea autorizării adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Dezactivează revocarea automată a autorizărilor adb pentru sistemele care nu s-au reconectat în timpul prestabilit (șapte zile) sau configurat de utilizator (minimum o zi)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Urmă Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Senzori dezactivați"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Setările profilului de serviciu"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Caută persoane de contact din directorul de serviciu în aplicațiile personale"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Căutările tale și apelurile primite pot fi vizibile pentru administratorul IT"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Calendar cu profil combinat"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Afișează evenimente de serviciu pe calendarul personal"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Când aplicațiile pentru lucru sunt dezactivate, acestea sunt întrerupte, nu pot fi accesate și nu îți pot trimite notificări."</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Gestionează spațiul de stocare"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Pentru a elibera spațiu de stocare, managerul spațiului de stocare elimină de pe dispozitiv fotografiile și videoclipurile cărora le-ai făcut backup."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Elimină fotografii și videoclipuri"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Managerul spațiului de stocare"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Folosește Managerul stocării"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gesturi"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Deschide rapid camera foto"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Pentru a deschide rapid camera foto, apasă de două ori butonul de pornire. Funcționează de pe orice ecran."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Întoarce camera foto pentru un selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Mod de navigare"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigare cu 2 butoane"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Pentru a schimba aplicațiile, glisează în sus pe butonul ecran de pornire. Pentru a vedea toate aplicațiile, glisează din nou în sus. Pentru a reveni, atinge butonul înapoi."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Siguranță și urgențe"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Apel de urgență, informații medicale, alerte"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigare prin gesturi"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Pentru a merge la ecranul de pornire, glisează în sus din partea de jos a ecranului. Pentru a schimba aplicațiile, glisează în sus din partea de jos, ține, apoi eliberează. Pentru a reveni, glisează din partea stângă sau dreaptă."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigare cu 3 butoane"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Accesează ecranul anterior sau ecranul de pornire și comută între aplicații folosind butoanele din josul ecranului."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navigarea sistemului, navigare cu 2 butoane, navigare cu 3 butoane, navigare prin gesturi, glisare"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Asistent digital"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Glisează pentru a invoca asistentul"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Glisează în sus dintr-un colț de jos pentru a invoca aplicația asistent digital."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Ține apăsat butonul ecran de pornire pentru Asistent"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Apasă lung butonul ecran de pornire pentru a invoca aplicația asistent digital."</string>
    <string name="low_label" msgid="6525629096999711220">"Scăzută"</string>
    <string name="high_label" msgid="357503396626018487">"Ridicată"</string>
    <string name="left_edge" msgid="1513576842959071849">"Marginea din stânga"</string>
    <string name="right_edge" msgid="1505309103265829121">"Marginea din dreapta"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"O sensibilitate mai mare poate intra în conflict cu gesturile făcute pe marginile ecranului în aplicație."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Sensibilitatea gestului „Înapoi”"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Sensibilitatea la navigarea prin gesturi"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigare cu butoane"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigare prin gesturi, sensibilitatea gestului „Înapoi”, gestul „Înapoi”"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigare, butonul ecran de pornire"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Modul cu o mână"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Folosește modul cu o mână"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Comandă rapidă pentru modul cu o mână"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"accesibilitate"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Glisează în jos pentru următoarele acțiuni:"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Folosește comanda rapidă pentru"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Trage în jos de partea de sus a ecranului, ca să fie mai ușor de ajuns cu o singură mână"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Cum să folosești modul cu o mână"</b>\n" • Verifică dacă navigarea prin gesturi este selectată în setările de navigare prin sistem\n • Glisează în jos în apropierea marginii de jos a ecranului"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Trage ecranul pentru a-l putea accesa"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Partea de sus a ecranului se va deplasa, astfel încât să o poți accesa cu degetul mare."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Afișează notificările"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Vor apărea notificările și setările."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Ca să verifici ora, notificările și alte informații, atinge ecranul de două ori."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Ecran la activare"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Ca să verifici ora, notificările și alte informații, atinge ecranul."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Apel de urgență"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Folosește funcția Apel de urgență"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Apasă rapid butonul de pornire de cel puțin cinci ori pentru a iniția acțiunile de mai jos"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Se redă alarma cu numărătoare inversă"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Se redă un semnal sonor puternic la inițierea funcției Apel de urgență"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Cere ajutor"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Apelează pentru ajutor"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Numărul de apelat pentru ajutor"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Atinge pentru a modifica"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Dacă introduci un număr care nu este de urgență:\n • dispozitivul trebuie să fie deblocat pentru a folosi Apelul de urgență;\n • este posibil să nu ți se răspundă la apel."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Glisează amprenta pentru notificări"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Glisează amprenta"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Vezi notificările rapid"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Activat"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Dezactivat"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Bootloaderul este deja deblocat"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Conectează-te la internet sau contactează operatorul"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Nu este disponibilă pe dispozitivele blocate de operator"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Repornește dispozitivul pentru a activa funcția de protecție a dispozitivului."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Un spațiu total disponibil de <xliff:g id="SIZE">%1$s</xliff:g>\n\nData ultimei rulări: <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Aplicații instantanee"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Deschide linkuri în aplicații, chiar dacă acestea nu sunt instalate"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Aplicații instantanee"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Preferințe pentru aplicații instantanee"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Aplicații instalate"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Spațiul de stocare este acum gestionat de managerul spațiului de stocare"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Conturi pentru <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Sincronizează automat datele aplicațiilor"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Permite aplicațiilor să actualizeze date automat"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sincronizarea contului"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sincronizare activată pentru <xliff:g id="ID_1">%1$d</xliff:g> din <xliff:g id="ID_2">%2$d</xliff:g> articole"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sincronizare activată pentru toate articolele"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sincronizare dezactivată pentru toate elementele"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informații privind dispozitivul gestionat"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Modificări și setări gestionate de organizația dvs."</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Modificări și setări gestionate de <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Pentru a oferi acces la datele tale de serviciu, organizația poate să modifice setările și să îți instaleze un software pe dispozitiv.\n\nPentru mai multe detalii, contactează administratorul organizației."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Tipuri de informații care pot fi văzute de organizația ta"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Modificări făcute de administratorul organizației dvs."</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Accesul tău la acest dispozitiv"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Date asociate contului dvs. de serviciu, cum ar fi e-mailul și calendarul"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lista de aplicații de pe dispozitiv"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Timpul petrecut și cantitatea de date utilizate pentru fiecare aplicație"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Cel mai recent jurnal de trafic de rețea"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Cel mai recent raport de eroare"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Cel mai recent jurnal de securitate"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Niciuna"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Aplicații instalate"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Numărul de aplicații este estimat. Este posibil ca acesta să nu includă aplicațiile instalate în afara Magazinului Play."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimum # aplicație}few{Minimum # aplicații}other{Minimum # de aplicații}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Permisiuni pentru locație"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Permisiuni pentru microfon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Permisiuni pentru camera foto"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Aplicații prestabilite"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# aplicație}few{# aplicații}other{# de aplicații}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Tastatură prestabilită"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Setat la <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Rețeaua VPN activată permanent a fost activată"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Rețeaua VPN activată permanent a fost activată în profilul tău personal"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Rețeaua VPN activată permanent a fost activată în profilul tău de serviciu"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Proxy global HTTP setat"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Date de conectare de încredere"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Acreditări de încredere în profilul personal"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Acreditări de încredere în profilul de serviciu"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Cel puțin # certificat CA}few{Cel puțin # certificate CA}other{Cel puțin # de certificate CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administratorul poate să blocheze dispozitivul și să reseteze parola"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administratorul poate să șteargă toate datele dispozitivului"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Încercări nereușite de introducere a parolei înainte de a șterge toate datele dispozitivului"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Încercări nereușite de introducere a parolei înainte de a șterge datele din profilul de serviciu"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# încercare}few{# încercări}other{# de încercări}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Acest dispozitiv este gestionat de organizația ta."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Acest dispozitiv este gestionat de <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">"Află mai multe"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Setare restricționată"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Sunt permise setările restricționate pentru <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Pentru securitatea ta, setarea este momentan indisponibilă."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informații privind dispozitivul finanțat"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Creditorul poate să modifice setările și să instaleze software pe dispozitiv în timpul configurării.\n\nDacă omiți o plată, creditorul poate să-ți blocheze dispozitivul și să modifice setările acestuia.\n\nPentru a afla mai multe, contactează creditorul."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Dacă dispozitivul este finanțat, nu poți să:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Instalează aplicații din afara Magazinului Play"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Repornește dispozitivul în modul sigur"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Adaugă mai mulți utilizatori pe dispozitiv"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Modifică data, ora și fusurile orare"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Folosește Opțiuni dezvoltator"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Creditorul poate:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Accesează numărul IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Revino la setările din fabrică ale dispozitivului dacă apare o eroare"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Dacă dispozitivul este blocat, îl poți folosi numai pentru următoarele acțiuni:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Inițiază apeluri de urgență"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Vezi informații despre sistem, cum ar fi data, ora, starea rețelei și nivelul bateriei"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Pornește sau oprește dispozitivul"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Vezi notificări și mesaje text"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Accesează aplicațiile permise de creditor"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"După ce achiți toată suma:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Toate restricțiile sunt eliminate de pe dispozitiv"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Poți să dezinstalezi aplicația Creditor"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Informații privind dispozitivul finanțat"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Aplicația Cameră foto}few{Aplicațiile Cameră foto}other{Aplicațiile Cameră foto}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Aplicația Calendar"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Aplicația Agendă"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Aplicația Client de e-mail}few{Aplicațiile Client de e-mail}other{Aplicațiile Client de e-mail}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Aplicația Harta"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Aplicația Telefon}few{Aplicațiile Telefon}other{Aplicațiile Telefon}}"</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">"Acest dispozitiv"</string>
    <string name="storage_games" msgid="1176568610086802469">"Jocuri"</string>
    <string name="storage_files" msgid="7968460921272772299">"Fișiere"</string>
    <string name="storage_images" msgid="2055893015567979387">"Imagini"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videoclipuri"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Aplicații"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Documente și altele"</string>
    <string name="storage_system" msgid="8472410119822911844">"Sistem"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Coș de gunoi"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Golești coșul de gunoi?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"În coșul de gunoi sunt <xliff:g id="TOTAL">%1$s</xliff:g> fișiere. Toate elementele vor fi șterse definitiv și nu vei putea să le restabilești."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Coșul de gunoi este gol"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Goliți coșul de gunoi"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> folosiți"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> în total"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Șterge aplicația"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Vrei să elimini această aplicație instantanee?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Deschide"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Jocuri"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Spațiu utilizat"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(dezinstalat pentru <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(dezactivat pentru <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Serviciu de completare automată"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Serviciu de completare automată prestabilit"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Parole"</string>
    <string name="credman_chosen_app_title" msgid="4547405511458518096">"Parole, chei de acces și servicii de date"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Furnizori suplimentari"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# parolă}few{# parole}other{# de parole}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automată, completare, completare automată, parolă"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"date, cheie de acces, parolă"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"auto, completare, completare automată, date, cheie de acces, parolă"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Asigură-te că ai încredere în această aplicație&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Completarea automată Google&gt;%1$s&lt;/xliff:g&gt; folosește conținutul de pe ecran pentru a stabili ce se poate completa automat."</string>
    <string name="credman_autofill_confirmation_message" msgid="4951846866327737417">"&lt;b&gt;Folosești &lt;xliff:g id=app_name example=Furnizorul&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Furnizorul&gt;%1$s&lt;/xliff:g&gt; folosește elementele de pe ecran pentru a stabili ce se poate completa automat. De acum înainte, parolele noi, cheile de acces și alte informații se vor salva aici."</string>
    <string name="credman_picker_title" msgid="2642776965060619988">"Parole, chei de acces și servicii de date"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Dezactivezi %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Dezactivezi serviciul?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Informațiile salvate, cum ar fi parole, chei de acces, metode de plată și altele, nu vor fi completate când te conectezi. Pentru a folosi informațiile salvate, alege o parolă, o cheie de acces sau un serviciu de date."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Folosești %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s folosește elementele de pe ecran ca să afle ce se poate completa automat."</string>
    <string name="credman_error_message_title" msgid="4741457523969373713">"Limita pentru parole, chei de acces și servicii de date"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Poți avea până la cinci parole, chei de acces și servicii de date active simultan. Dezactivează un serviciu pentru a adăuga mai multe."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Dezactivează"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Completare automată"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Nivel de înregistrare"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Număr maxim de solicitări pe sesiune"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Seturi de date cu vizibilitate maximă"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Resetează la valorile prestabilite"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Opțiunile dezvoltatorului de completare automată au fost resetate"</string>
    <string name="location_category" msgid="3496759112306219062">"Locație"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indicator de locația pentru bara de stare"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Afișează pentru toate locațiile, inclusiv rețeaua și conectivitatea"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Forțează măsurători GNSS complete"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Urmărește toate constelațiile și frecvențele GNSS fără ciclu de funcționare"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Metodă de introducere text"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Scriere de mână cu creionul"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Când este activată, metoda de introducere text actuală primește MotionEvent de la creion, dacă este focalizat un editor."</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema dispozitivului"</string>
    <string name="default_theme" msgid="4815428567082263639">"Prestabilită"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Numele rețelei"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Afișează numele rețelei în bara de stare"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Aplicație instantanee"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Dezactivezi managerul spațiului de stocare?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Actualizează funcția Nu deranja"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Întrerupe notificările pentru a-ți păstra concentrarea"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funcție indisponibilă"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Această funcție a fost dezactivată deoarece îți încetinește telefonul"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Afișează întotdeauna caseta de dialog pentru blocări"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Afișează caseta de dialog de fiecare dată când se blochează o aplicație"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Selectează aplicația compatibilă cu ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nu există niciun set de aplicații compatibile cu ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplicație compatibilă cu ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Preferințe pentru driverul plăcii grafice"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Modifică setările driverului plăcii grafice"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Când sunt disponibile mai multe drivere ale plăcii grafice, puteți alege să folosiți driverul actualizat al plăcii grafice pentru aplicațiile instalate pe dispozitiv."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Activează pentru toate aplicațiile"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Selectează driverul plăcii grafice"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Prestabilit"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Driverul jocului"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Developer Driver"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Driverul plăcii grafice de sistem"</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="4648827560023949786">"Experimental: activează ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Avertisment: activează ANGLE ca driver OpenGL ES prestabilit. Funcția este experimentală și poate să nu fie compatibilă cu unele aplicații pentru camera foto și pentru videoclipuri."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Este nevoie de o repornire pentru a schimba driverul de sistem OpenGL ES"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Modificări ale compatibilității aplicației"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Activează / dezactivează modificările compatibilității aplicației"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Modificări activate prestabilite"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Modificări dezactivate prestabilite"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Compatibilitatea aplicațiilor poate fi modificată numai pentru aplicațiile care pot fi remediate. Instalează o aplicație care poate fi remediată și încearcă din nou."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Depinde de altă setare"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Cont"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Numele dispozitivului"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Informații de bază"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Legislație și reglementări"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Detalii despre dispozitiv"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identificatorii dispozitivului"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Control Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Permite aplicației să controleze conexiunea Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Permite-i acestei aplicații să activeze sau să dezactiveze conexiunea Wi-Fi, să scaneze și să se conecteze la rețelele Wi-Fi, să adauge sau să elimine rețele sau să pornească un hotspot numai local"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Lansează prin NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Permite lansarea la scanarea unei etichete NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Permite lansarea aplicației la scanarea unei etichete NFC.\nDacă permisiunea este activată, aplicația va fi disponibilă ca opțiune oricând este detectată o etichetă."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Redă media către"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Redă <xliff:g id="LABEL">%s</xliff:g> pe"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Acest dispozitiv"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Indisponibil în timpul apelurilor"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Preia apelul pe"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Acest APN nu poate fi modificat."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Dezactivezi soneria"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Apasă simultan butonul de pornire și pe cel de volum pentru"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Comandă rapidă pentru dezactivarea soneriei"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"vibrații"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"dezactivarea sunetului"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrație"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Dezactivezi sunetul"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Pentru activare, mai întâi modifică opțiunea Apasă lung butonul de pornire din meniul de pornire."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detalii despre rețea"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Numele dispozitivului este vizibil pentru aplicațiile de pe telefon. Poate fi văzut și de alte persoane când te conectezi la dispozitivele Bluetooth sau la o rețea Wi-Fi sau când configurezi un hotspot Wi-Fi."</string>
    <string name="devices_title" msgid="649715719278562515">"Dispozitive"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Alege o rețea"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Deconectată"</string>
    <string name="network_connected" msgid="7637745547242487795">"Conectată"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Se conectează…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Nu s-a putut conecta"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nicio rețea găsită."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Nu s-au găsit rețele. Încearcă din nou."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(interzisă)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Niciun card SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Fără"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Necesită un card SIM pentru a se conecta"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Necesită un card SIM <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> pentru a se conecta"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Mod de rețea preferat: de preferat WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Mod de rețea preferat: numai GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Mod de rețea preferat: numai WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Mod de rețea preferat: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Mod de rețea preferat: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Mod de rețea preferat: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Mod de rețea preferat: numai CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Mod de rețea preferat: numai EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Mod de rețea preferat: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Mod de rețea preferat: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Mod de rețea preferat: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Mod de rețea preferat: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Mod de rețea preferat: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Mod de rețea preferat: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Mod de rețea preferat: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Mod de rețea preferat: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Mod de rețea preferat: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Mod de rețea preferat: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Mod de rețea preferat: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Mod de rețea preferat: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Mod de rețea preferat: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Mod de rețea preferat: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Mod de rețea preferat: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Mod de rețea preferat: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Mod de rețea preferat: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Mod de rețea preferat: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Mod de rețea preferat: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Mod de rețea preferat: numai NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Mod de rețea preferat: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Mod de rețea preferat: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Mod de rețea preferat: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Mod de rețea preferat: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Mod de rețea preferat: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Mod de rețea preferat: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Mod de rețea preferat: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Mod de rețea preferat: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Mod de rețea preferat: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Mod de rețea preferat: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (recomandat)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (recomandat)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (recomandat)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Selectează automat rețeaua"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Setări operator"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Configurează serviciul de date"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Date mobile"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Accesează datele folosind rețeaua mobilă"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefonul va comuta automat la acest operator când se află în aria de acoperire"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Niciun SIM disponibil"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Preferință pentru apeluri"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Preferințe pentru SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Întreabă mereu"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Adaugă o rețea"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Prestabilit pentru apeluri"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Prestabilit pentru SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Prestabilit pentru apeluri și SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Prestabilit pentru date mobile"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Date mobile active"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Date mobile dezactivate"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Disponibil"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Adaugă un card SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Activ/SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inactiv/SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Activ / eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inactiv / eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Numele și culoarea cardului SIM"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Nume"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Culoare (folosită de aplicațiile compatibile)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Salvează"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Folosește cardul SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Dezactivat"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Pentru a dezactiva acest SIM, îndepărtează cardul SIM"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Atinge pentru a activa <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Șterge SIM-ul"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Tipul de rețea preferat"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Schimbă modul de operare a rețelei"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Tipul de rețea preferat"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Versiunea setărilor pentru operator"</string>
    <string name="call_category" msgid="641461844504128789">"Se apelează"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Apelare video prin operator"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Selectează sistemul"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Schimbă modul de roaming CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Selectează sistemul"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Rețea"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Abonament CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Comută între RUIM/SIM și NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"abonament"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Înregistrare automată…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Permiți roamingul de date?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Consultă furnizorul de rețea în privința prețurilor."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Utilizarea datelor în aplicație"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Mod nevalid de rețea <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignoră."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Numele punctelor de acces"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Indisponibil când este conectat la <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Vezi mai multe"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Activezi <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Activezi SIM-ul?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Treci la <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Folosești cardul SIM?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Folosești <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Doar un SIM poate fi activ odată.\n\nCând treci la <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, nu se anulează serviciul <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Doar un eSIM poate fi activ la un moment dat.\n\nTrecerea la <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> nu va anula serviciul <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Doar un SIM poate fi activ odată.\n\nDacă faci această schimbare, nu se anulează serviciul <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Poți folosi două carduri SIM în același timp. Ca să folosești <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, dezactivează un alt SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Treci la <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">"Dezactivează <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Dacă dezactivezi un card SIM, nu se anulează serviciul"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Se conectează la rețea…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Se trece la <xliff:g id="CARRIER_NAME">%1$s</xliff:g> pentru apeluri și mesaje…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Nu poți schimba operatorul"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Nu poți schimba operatorul din cauza unei erori."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Dezactivezi <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Dezactivezi SIM-ul?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Se dezactivează cardul SIM<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Nu se poate dezactiva operatorul"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"A apărut o eroare și operatorul tău nu a putut fi dezactivat."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Folosești două carduri SIM?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Acest dispozitiv poate avea două carduri SIM active simultan. Pentru a folosi în continuare câte un card SIM odată, atingeți „Nu, mulțumesc”."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Repornești dispozitivul?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Da"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Repornește"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nu, mulțumesc"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Anulează"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Schimbă"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Nu se poate activa SIM-ul"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Încearcă din nou să activezi SIM-ul. Dacă problema persistă, repornește dispozitivul."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Activarea rețelei"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Schimbarea operatorului"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> este activ"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Atinge pentru a actualiza setările SIM"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Ai trecut la <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Ai trecut la alt operator"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Rețeaua ta mobilă s-a modificat"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Configurați-vă celălalt card SIM"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Alege cardul SIM activ sau folosește două carduri SIM în același timp"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Alege un număr"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Pe dispozitiv este disponibil un număr, însă numai unul poate fi folosit odată}=2{Pe dispozitiv sunt disponibile două numere, însă numai unul poate fi folosit odată}few{Pe dispozitiv sunt disponibile # numere, însă numai unul poate fi folosit odată}other{Pe dispozitiv sunt disponibile # de numere, însă numai unul poate fi folosit odată}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Se activează<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Nu s-a putut activa în acest moment"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Folosești <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> va fi folosit pentru date mobile, apeluri și SMS-uri."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nu există carduri SIM disponibile"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Pentru a folosi datele mobile, funcțiile de apel și SMS-urile mai târziu, accesează setările pentru rețea"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Ștergi acest eSIM?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Dacă ștergi acest SIM, vei elimina serviciul <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> de pe acest dispozitiv.\n\nServiciile <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> nu vor fi anulate."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Șterge"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Se șterge SIM-ul…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Nu se poate șterge SIM-ul"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Acest SIM nu poate fi șters din cauza unei erori.\n\nRepornește dispozitivul și încearcă din nou."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Conectează la dispozitiv"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Aplicația <xliff:g id="APPNAME">%1$s</xliff:g> vrea să folosească o rețea Wi-Fi temporară pentru a se conecta la dispozitiv"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nu s-au găsit dispozitive. Asigură-te că dispozitivele sunt pornite și gata de conectare."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Reîncearcă"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"A intervenit ceva. Această aplicație a anulat solicitarea de a alege un dispozitiv."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Conectare reușită"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Nu s-a conectat"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Afișează-le pe toate"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Se caută dispozitivul…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Se conectează la dispozitiv…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Stânga"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Dreapta"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Carcasă"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Panou de setări"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Forțează modul desktop"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Forțează modul desktop experimental pe ecrane secundare"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Permite aplicații fără redimensionare în ferestre multiple"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Permite aplicațiile fără redimensionare în ferestre multiple"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Modifică funcția Force-Dark"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Modifică funcția Force-Dark să fie activată mereu"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Confidențialitate"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Permisiuni, activitatea contului, date cu caracter personal"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Comenzi"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Elimină"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Păstrează"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Elimini această sugestie?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Spațiul de stocare este insuficient. <xliff:g id="PERCENTAGE">%1$s</xliff:g> folosit - <xliff:g id="FREE_SPACE">%2$s</xliff:g> liber"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Trimite feedback"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Ai vrea să ne dai feedback pentru această sugestie?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> s-a copiat în clipboard."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Utilizarea accesibilității"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{O aplicație are acces complet la dispozitivul tău}few{# aplicații au acces complet la dispozitivul tău}other{# de aplicații au acces complet la dispozitivul tău}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Informații importante"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"CONTINUAȚI"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NU, MULȚUMESC"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Locație"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Operatorul tău îți poate colecta locația atunci când folosești acest serviciu pentru apeluri de urgență\n\nConsultă politica de confidențialitate a operatorului pentru detalii."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Poți pierde accesul la timpul sau datele rămase. Consultă operatorul înainte de eliminare."</string>
    <string name="content_capture" msgid="868372905432812238">"Conținutul aplicației"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Permite aplicațiilor să trimită conținut la sistemul Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Capturează datele privind memoria heap a sistemului"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Memory Tagging Extension (MTE) simplifică identificarea problemelor legate de siguranța memoriei în aplicație și protejează codul nativ al acesteia."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Activarea MTE poate cauza funcționarea mai lentă a dispozitivului."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Află mai multe despre MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Activează funcția MTE până când o dezactivezi"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Va trebui să repornești dispozitivul pentru a activa MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Va trebui să repornești dispozitivul pentru a dezactiva MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Activează MTE pentru o singură sesiune"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Sistemul va reporni și îți va da posibilitatea să experimentezi cu Memory Tagging Extension (MTE). MTE poate afecta negativ stabilitatea și performanța sistemului. Se va reseta la următoarea repornire."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Repornește pentru o singură sesiune cu funcția MTE activată"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"Funcția MTE este deja activă"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Se capturează datele privind memoria heap a sistemului"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Nu s-au putut captura datele privind memoria heap a sistemului"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Capturează automat datele privind memoriile heap ale sistemului"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Capturează automat datele privind memoria heap pentru sistemul Android când folosește prea multă memorie"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Deconectează"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Apeluri de urgență"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Apelurile de urgență prin Apelare prin Wi-Fi nu sunt acceptate de operator.\nDispozitivul comută automat la o rețea mobilă pentru a face un apel de urgență.\nApelurile de urgență sunt posibile numai în zonele cu acoperire a rețelelor de telefonie mobilă."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Folosește Wi-Fi pentru apeluri ca să îmbunătățești calitatea"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Metodă de apelare de rezervă"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Dacă <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> sau roamingul nu este disponibil, folosește SIM-ul de date mobile pentru apeluri prin <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"metodă de apelare de rezervă"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Mesaj MMS primit"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Nu se poate trimite mesajul MMS"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Atinge pentru a permite mesageria MMS pentru <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> când datele mobile sunt dezactivate"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Mesaj MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problemă cu combinația de SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Folosirea operatorului <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> poate limita funcționalitatea. Atinge ca să afli mai multe."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Combinație de SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informații despre politica de serviciu"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Setări gestionate de administratorul IT"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Handler pentru rapoartele de eroare"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Stabilește ce aplicație gestionează comanda rapidă pentru Raportul de eroare pe dispozitivul tău."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personal"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Serviciu"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Valoare prestabilită"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Nu există"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Această opțiune nu mai este validă. Încearcă din nou."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Apasă lung pe butonul de pornire"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Apasă lung butonul de pornire pentru a accesa"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Meniul de pornire"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Asistent digital"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Accesează asistentul digital"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Accesează meniul de pornire"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Pentru utilizare, setează mai întâi un ecran de blocare"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Meniul de pornire:\napasă simultan pe butonul de pornire și pe cel de creștere a volumului"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Împiedică sunatul:\napasă pe un buton de volum pentru comanda rapidă"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Durata cât ții apăsat"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Ajustează sensibilitatea alegând cât să ții apăsat butonul de pornire"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Scurtă"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Lungă"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Afișează Wallet"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Permite accesul la Wallet de pe ecranul de blocare"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Afișează aplicația Scanner de coduri QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Permite accesul la aplicația Scanner de coduri QR de pe ecranul de blocare"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Afișează comenzile dispozitivului"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"De pe ecranul de blocare"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Folosește comenzile dispozitivelor"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Pentru a folosi funcția, mai întâi activează opțiunea Afișează comenzile dispozitivului"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Dimensiunea ceasului se schimbă în funcție de conținutul ecranului de blocare"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Ceas dinamic"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Comenzi rapide"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="few"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$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">"Dezactivezi VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"În plus, astfel vei dezactiva conexiunea 5G.\nÎn timpul unui apel vocal, nu poți folosi internetul și unele aplicații pot să nu funcționeze."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Suspendă execuția pentru aplicațiile din cache"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Nu expiră niciodată."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Închirierea nu expiră niciodată."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Permite suprapunerile pe ecrane din Setări"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Permite aplicații care se pot afișa deasupra altora prin suprapunerea pe ecranele de Setări"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Permite modemul de testare"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Permite dispozitivului să ruleze serviciul de modem de testare pentru testarea codului de măsurare. Nu activa această funcție în timpul folosirii normale a telefonului."</string>
    <string name="media_controls_title" msgid="403271085636252597">"Media"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Fixează playerul media"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Pentru a relua rapid redarea, playerul media rămâne deschis în Setări rapide"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Afișează conținutul media pe ecranul de blocare"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Pentru a relua rapid redarea, playerul media rămâne deschis pe ecranul de blocare"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Afișează recomandările de conținut media"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Pe baza activității tale"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Ascunde playerul"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Afișează playerul"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"media"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth se va activa"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"Carduri SIM"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Apeluri și SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Apelare prin Wi-Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Inițiază și primește apeluri prin Wi-Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Apeluri"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferate"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"Preferat pentru apeluri"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"Preferat pentru SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"indisponibile"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Temporar indisponibil"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Niciun card SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Preferințe privind rețeaua"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"conexiune la rețea, internet, wireless, date, wifi, wi-fi, wi fi, celular, mobil, operator servicii mobile, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Resetezi conexiunea la internet?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Se resetează conexiunea la internet…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Remediază problemele legate de conectivitate"</string>
    <string name="networks_available" msgid="3299512933684383474">"Sunt disponibile rețele"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Pentru a schimba rețeaua, deconectează ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Conexiuni W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Permite ca Google Fi să folosească rețele W+ pentru a îmbunătăți viteza și acoperirea"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Rețea W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"Cartele eSIM"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Activ"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Inactiv"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Prestabilit pentru <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"apeluri"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"date mobile"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Pentru a îmbunătăți experiența cu dispozitivul, aplicațiile și serviciile pot să caute în continuare rețele Wi‑Fi chiar și atunci când conexiunea Wi-Fi este dezactivată. Această permisiune poate fi folosită, de exemplu, pentru a îmbunătăți funcțiile și serviciile bazate pe locație. Poți să schimbi acest aspect din setările pentru căutarea de rețele Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Modifică"</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">"Conectat"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Conectat temporar"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Folosește temporar <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Nicio conexiune"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Datele mobile nu se conectează automat"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Dezactivezi datele mobile?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Nu vei avea acces la date sau la internet prin intermediul <xliff:g id="CARRIER">%s</xliff:g>. Internetul va fi disponibil numai prin Wi-Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"operatorului dvs."</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Organizația ta nu acceptă"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Indisponibil deoarece modul ora de culcare este activat"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"S-a finalizat resetarea importanței notificărilor."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Aplicații"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Un dispozitiv solicită acces la mesajele tale. Atinge pentru detalii."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Permiți accesul la mesaje?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Un dispozitiv Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, solicită acces la mesajele dvs.\n\nNu te-ai mai conectat la <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Un dispozitiv solicită acces la persoanele de contact și la jurnalul tău de apeluri. Atinge pentru detalii."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Permiți accesul la agendă și la jurnalul de apeluri?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Un dispozitiv Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, solicită acces la persoanele tale de contact și la jurnalul de apeluri. Aici sunt incluse date despre apelurile primite și date.\n\nNu te-ai mai conectat la <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Luminozitate"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Ecran de blocare"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Aspect"</string>
    <string name="category_name_color" msgid="937514550918977151">"Culoare"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Alte comenzi de afișare"</string>
    <string name="category_name_general" msgid="7737273712848115886">"General"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Folosește Tema întunecată"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Folosește Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Folosește dezactivarea soneriei"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Folosește un hotspot Wi‑Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Folosește fixarea aplicațiilor"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Folosește opțiuni pentru dezvoltatori"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Folosește serviciul de printare"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Permite utilizatori multipli"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"permite, mai mulți, utilizatori, acceptă, mulți"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Folosește remedierea erorilor wireless"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Folosește preferințele pentru driverul plăcii grafice"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Folosește Lumina de noapte"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Folosește NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Folosește luminozitatea adaptivă"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Folosește apelarea prin Wi-Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Vezi toate aplicațiile"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Redirecționare intuitivă"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Redirecționarea intuitivă este activată"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Redirecționarea intuitivă este dezactivată"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Setări pentru apeluri"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Se actualizează setările…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Eroare în setările pentru apeluri"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Eroare de rețea sau de SIM."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"Cardul SIM nu este activat."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Introduceți numerele de telefon"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Introdu numărul de telefon"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Lipsește numărul de telefon."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Activează conexiunea 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"Tehnologia 2G este mai puțin sigură, dar îți poate îmbunătăți conexiunea în unele locații. Pentru apeluri de urgență, tehnologia 2G este mereu permisă."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> necesită 2G pentru a fi disponibil"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Activează criptarea"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Criptarea oferă mai multă siguranță, dar există riscul să nu te poți conecta în unele locații. Pentru apelurile de urgență nu este necesară criptarea."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Toate serviciile"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Afișează accesările clipboardului"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Afișează un mesaj când aplicațiile accesează text, imagini sau alte tipuri de conținut pe care le-ai copiat"</string>
    <string name="all_apps" msgid="3054120149509114789">"Toate aplicațiile"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Nu permite"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra-Wideband (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Identifică poziția relativă a dispozitivelor din apropiere care au UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Dezactivează modul Avion pentru a folosi UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"Tehnologia UWB nu este disponibilă în locația actuală"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Acces la cameră"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Acces la microfon"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Pentru aplicații și servicii"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Pentru aplicații și servicii. Chiar dacă setarea este dezactivată, datele de la microfon pot fi trimise când apelezi un număr de urgență."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Înapoi"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Înainte"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Previzualizarea culorii"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Solicitare de acces la SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Un dispozitiv solicită acces la cartela SIM. Atinge pentru detalii."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Permiți accesul la SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Un dispozitiv Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, vrea să acceseze date de pe cartela ta SIM. Aici este inclusă agenda.\n\nDupă ce se conectează, <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> va primi toate apelurile primite la <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Este disponibil un dispozitiv Bluetooth"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Un dispozitiv solicită conectarea. Atinge pentru detalii."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Te conectezi la dispozitivul Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> solicită conectarea la acest telefon.\n\nNu te-ai mai conectat la <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Nu te conecta"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Conectează-te"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Setări TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Activată"</string>
    <string name="tare_off" msgid="6305694402929756726">"Dezactivată"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Revii la setările implicite?"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Setări restabilite la cele standard."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Echilibru maxim la încărcarea completă"</string>
    <string name="tare_balances" msgid="731881382594747961">"Solduri"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Limite de consum"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Limita inițială de consum"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Limita minimă de consum"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Limita maximă de consum"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modificatori"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Acțiuni (costul producției)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Acțiuni (preț de bază)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Recompense pentru fiecare eveniment"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Recompense/secundă de eveniment"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Numărul maxim de recompense pe zi"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Instalarea aplicației"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Activitate principală"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Notificare văzută"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Notificare văzută în decurs de 15 minute"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interacțiune cu notificarea"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interacțiune cu widgetul"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Altă interacțiune a utilizatorului"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Se începe sarcina cu prioritate maximă"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Rulează sarcina cu prioritate maximă"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Se începe sarcina cu prioritate ridicată"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Rulează sarcina cu prioritate ridicată"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Se începe sarcina prestabilită"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Rulează sarcina prestabilită"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Se începe sarcina cu prioritate scăzută"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Rulează sarcina cu prioritate scăzută"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Se începe sarcina cu prioritate minimă"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Rulează sarcina cu prioritate minimă"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Penalizare pentru timpul limită al sarcinii"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Echilibru minim la încărcarea completă (scutit)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Echilibru minim la încărcarea completă (aplicație fără interfață grafică)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Echilibru minim la încărcarea completă (aplicațiile rămase)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Echilibru minim la încărcarea completă (actualizări de aplicație)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Încărcarea"</item>
    <item msgid="658627268149681677">"Doze"</item>
    <item msgid="1599558140284643834">"Modul de economisire a bateriei"</item>
    <item msgid="588427840913221601">"Starea procesului"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Confirmă"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Previzualizează"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Alege un screensaver"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Afișează informații suplimentare"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Afișează informații cum ar fi ora, condițiile meteo sau altele pe screensaver"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Afișează comenzile pentru locuință"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Afișează butonul de comenzi pentru locuință din screensaver"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Mai multe setări"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Alege screensaverul"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Alege ce vei vedea pe ecran când tableta este andocată. Dispozitivul poate consuma mai multă energie când folosește un screensaver."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Personalizează"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Personalizează <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Este nevoie de o repornire pentru a activa asistența cu formă liberă."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Este nevoie de o repornire pentru a impune modul computer pe ecranele secundare."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Repornește acum"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Repornește mai târziu"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Audio spațial"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Sunetul de la dispozitivele media compatibile devine mai captivant"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Urmărirea mișcărilor capului"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Sunetul se modifică pe măsură ce miști capul, pentru o experiență mai naturală"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="584337314155926373">"Permisiunile de sincronizare"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="3426601558010545762">"Acordă pentru <xliff:g id="REMOTE_DEVICE_NAME">%1$s</xliff:g> aceleași permisiuni pentru aplicație pe care le ai pe <xliff:g id="LOCAL_DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Tipul de dispozitiv audio"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Necunoscut"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Difuzor"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Căști"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Aparat auditiv"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Set auto"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Altele"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Limita vitezei de descărcare a rețelei"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Configurează limita lățimii de bandă de intrare a rețelei, care se aplică tuturor rețelelor care asigură conexiune la internet."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Configurează limita vitezei de descărcare a rețelei"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Nicio limită"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Dezactivează restricțiile pentru procese secundare"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Dezactivează restricțiile pentru folosirea resurselor sistemului de către procesele secundare ale aplicațiilor"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Activează forțat rolul Note"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Activează integrările de sistem pentru luat notițe prin intermediul rolului Note. Dacă rolul Note este deja activat, nu face nimic. Necesită repornirea."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Transmite"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Difuzează <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Ascultă transmisii care se redau în apropiere"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Difuzează conținut media pe dispozitive din apropiere sau ascultă transmisia unui alt utilizator"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Transmisii"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Ascultați"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Găsește transmisii"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Închide transmisia"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Scanează codul QR"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Introdu parola"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Nu se poate conecta. Încearcă din nou."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Parolă greșită"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Nu se poate asocia transmisiunii"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Pentru a începe să asculți, centrează codul QR de mai jos"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Codul QR nu are un format valid"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Convertește în eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Transferă cardul eSIM pe alt dispozitiv"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# aplicație}few{# aplicații}other{# de aplicații}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Aplicații instalate în fundal"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Producătorul dispozitivului poate să instaleze aplicații în fundal pe dispozitiv sau să permită operatorului și altor parteneri să facă acest lucru.\n\nAplicațiile afișate aici nu sunt necesare pentru funcționarea normală a dispozitivului. Poți dezinstala aplicațiile pe care nu le dorești."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Nicio aplicație instalată în fundal"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Dezinstalează aplicația"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Aplicații instalate în ultima lună}few{Aplicații instalate în ultimele # luni}other{Aplicații instalate în ultimele # de luni}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Aplicații instalate cu peste # lună în urmă}few{Aplicații instalate cu peste # luni în urmă}other{Aplicații instalate cu peste # de luni în urmă}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Raport de dimensiuni"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Încearcă un nou raport de dimensiuni ca să vezi aplicația dacă nu a fost creată pentru a se potrivi cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Încearcă un nou raport de dimensiuni ca să vezi aplicația dacă nu a fost creată pentru a se potrivi cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Unele aplicații pot să nu fie optimizate pentru anumite raporturi de dimensiuni."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Încearcă un nou raport de dimensiuni ca să vezi aplicația dacă nu a fost creată pentru a se potrivi cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Încearcă un nou raport de dimensiuni ca să vezi aplicația dacă nu a fost creată pentru a se potrivi cu <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Unele aplicații pot să nu fie optimizate pentru anumite raporturi de dimensiuni."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Aplicații sugerate"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Ap. modificate"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Prestabilit pentru aplicație"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Ecran complet"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Jumătate de ecran"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Raportul de dimensiuni al dispozitivului"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16:9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g> de la <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Aplicația va reporni când schimbi raportul de dimensiuni. Este posibil să pierzi modificările nesalvate. Unele aplicații pot să nu fie optimizate pentru anumite raporturi de dimensiuni."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Raportul de dimensiuni (experimental)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Raportul de dimensiuni (experiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Raportul de dimensiuni (labs)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Experimental"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Experiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Labs"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Senzor de amprentă"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Notificări flash"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Despre notificările flash"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Dezactivate"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Activate / blițul camerei foto"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Activată / iluminarea ecranului"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Activate / blițul camerei foto și iluminarea ecranului"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Se aprinde blițul camerei foto sau ecranul când primești notificări sau când se activează alarme"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Aprinde ecranul când primești notificări sau când se aud alarme"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Folosește cu atenție notificările flash dacă ai sensibilitate la lumină"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"clipire, lumină, persoană cu deficiențe de auz, pierderea auzului"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Previzualizează"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Blițul camerei foto"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Iluminarea ecranului"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Culoarea iluminării ecranului"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Albastru"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azuriu"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cyan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Verde primăvăratic"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Verde"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Verde chartreuse"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Galben"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Portocaliu"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Roșu"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Trandafiriu"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violet"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Gata"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Anulează"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Contrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Mediu"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Ridicat"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Aplicația se poate deschide într-o singură fereastră"</string>
</resources>
