<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/**
 * Copyright (C) 2014 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="app_label" msgid="1527793174155125990">"Configurarea profilului de serviciu"</string>
    <string name="provisioning_error_title" msgid="6320515739861578118">"Hopa!"</string>
    <string name="setup_work_profile" msgid="1468934631731845267">"Configurați profilul de serviciu"</string>
    <string name="company_controls_workspace" msgid="2808025277267917221">"Organizația dvs. controlează acest profil și menține siguranța acestuia. Dvs. controlați restul conținutului de pe dispozitiv."</string>
    <string name="company_controls_device" msgid="8230957518758871390">"Organizația dvs. va controla acest dispozitiv și îi va asigura protecția."</string>
    <string name="the_following_is_your_mdm" msgid="6613658218262376404">"Următoarea aplicație va trebui să vă acceseze profilul:"</string>
    <string name="the_following_is_your_mdm_for_device" msgid="6717973404364414816">"Dispozitivul va fi gestionat de următoarea aplicație:"</string>
    <string name="next" msgid="1004321437324424398">"Înainte"</string>
    <string name="setting_up_workspace" msgid="7862472373642601041">"Se configurează profilul de serviciu…"</string>
    <string name="admin_has_ability_to_monitor_profile" msgid="7051310668406162979">"Administratorul poate să monitorizeze și să gestioneze setările, accesul la nivelul companiei, aplicațiile, permisiunile și datele asociate acestui profil, inclusiv activitatea în rețea și informațiile despre locația dispozitivului, istoricul apelurilor și istoricul căutărilor persoanelor de contact.<xliff:g id="LINE_BREAK">

</xliff:g>Contactați administratorul IT pentru mai multe informații, inclusiv politicile de confidențialitate ale organizației dvs."</string>
    <string name="admin_has_ability_to_monitor_device" msgid="6303112630697870695">"Administratorul IT poate să monitorizeze și să gestioneze setările, accesul la nivelul companiei, aplicațiile, permisiunile și datele asociate acestui dispozitiv, inclusiv activitatea în rețea și informațiile despre locația dispozitivului, istoricul apelurilor și istoricul căutărilor persoanelor de contact.<xliff:g id="LINE_BREAK">

</xliff:g>Contactați administratorul IT pentru mai multe informații, inclusiv politicile de confidențialitate ale organizației dvs."</string>
    <string name="theft_protection_disabled_warning" msgid="3708092473574738478">"Pentru a folosi funcțiile de protecție împotriva furtului, trebuie să aveți o blocare a ecranului protejată prin parolă pentru dispozitiv."</string>
    <string name="contact_your_admin_for_more_info" msgid="9209568156969966347">"Contactați administratorul IT pentru mai multe informații, inclusiv politicile de confidențialitate ale organizației dvs."</string>
    <string name="learn_more_link" msgid="3012495805919550043">"Aflați mai multe"</string>
    <string name="cancel_setup" msgid="2949928239276274745">"Anulați"</string>
    <string name="ok_setup" msgid="4593707675416137504">"Ok"</string>
    <string name="user_consent_msg" msgid="8820951802130353584">"Sunt de acord"</string>
    <string name="url_error" msgid="5958494012986243186">"Acest link nu se poate afișa."</string>
    <string name="navigation_button_description" msgid="6106309408994461239">"Navigați în sus"</string>
    <string name="terms" msgid="8295436105384703903">"Termeni"</string>
    <string name="work_profile_info" msgid="5433388376309583996">"Informații despre profilul de serviciu"</string>
    <string name="managed_device_info" msgid="1529447646526616811">"Informații privind dispozitivul gestionat"</string>
    <string name="default_managed_profile_name" msgid="5370257687074907055">"Profilul de serviciu"</string>
    <string name="delete_profile_title" msgid="2841349358380849525">"Ștergeți profilul existent?"</string>
    <string name="opening_paragraph_delete_profile" msgid="4913885310795775967">"Aveți deja un profil de serviciu. Este gestionat folosind următoarea aplicație:"</string>
    <string name="read_more_delete_profile" msgid="7789171620401666343">"Înainte de a continua, "<a href="#read_this_link">"citiți aici"</a>"."</string>
    <string name="sure_you_want_to_delete_profile" msgid="6927697984573575564">"În cazul în care continuați, toate aplicațiile și datele din acest profil vor fi șterse."</string>
    <string name="delete_profile" msgid="2299218578684663459">"Ștergeți"</string>
    <string name="cancel_delete_profile" msgid="5155447537894046036">"Anulați"</string>
    <string name="encrypt_device_text_for_profile_owner_setup" msgid="7828515754696057140">"Pentru a vă configura profilul de serviciu, dispozitivul trebuie criptat. Procesul poate dura un timp."</string>
    <string name="encrypt_device_text_for_device_owner_setup" msgid="5194673142404735676">"Pentru a configura dispozitivul, acesta trebuie mai întâi criptat. Procesul poate dura un timp."</string>
    <string name="encrypt_this_device_question" msgid="8719916619866892601">"Criptați acest dispozitiv?"</string>
    <string name="encrypt" msgid="1749320161747489212">"Criptați"</string>
    <string name="continue_provisioning_notify_title" msgid="5191449100153186648">"Criptare completă"</string>
    <string name="continue_provisioning_notify_text" msgid="1066841819786425980">"Atingeți pentru a continua configurarea profilului de serviciu"</string>
    <string name="managed_provisioning_error_text" msgid="7063621174570680890">"Nu s-a putut configura profilul de serviciu. Contactați departamentul IT sau încercați din nou mai târziu."</string>
    <string name="cant_add_work_profile" msgid="9217268909964154934">"Nu se poate adăuga profilul de serviciu"</string>
    <string name="cant_replace_or_remove_work_profile" msgid="7861054306792698290">"Nu se poate înlocui sau elimina profilul de serviciu"</string>
    <string name="work_profile_cant_be_added_contact_admin" msgid="5393019630297157418">"La acest dispozitiv nu se poate adăuga un profil de serviciu. Dacă aveți întrebări, contactați administratorul IT."</string>
    <string name="change_device_launcher" msgid="4523563368433637980">"Schimbați lansatorul dispozitivului"</string>
    <string name="launcher_app_cant_be_used_by_work_profile" msgid="3524366082000739743">"Această aplicație lansator nu poate fi folosită de profilul dvs. de serviciu"</string>
    <string name="cancel_provisioning" msgid="3408069559452653724">"Anulați"</string>
    <string name="pick_launcher" msgid="4257084827403983845">"OK"</string>
    <string name="user_setup_incomplete" msgid="6494920045526591079">"Configurarea utilizatorului nu s-a finalizat"</string>
    <string name="default_owned_device_username" msgid="3915120202811807955">"Utilizatorul dispozitivului de serviciu"</string>
    <string name="setup_work_device" msgid="6003988351437862369">"Se configurează dispozitivul..."</string>
    <string name="device_doesnt_allow_encryption_contact_admin" msgid="5124643338424539794">"Acest dispozitiv nu permite criptarea, care este necesară pentru configurare. Pentru ajutor, contactați administratorul IT."</string>
    <string name="stop_setup_reset_device_question" msgid="7547191251522623210">"Opriți configurarea și resetați dispozitivul?"</string>
    <string name="this_will_reset_take_back_first_screen" msgid="4623290347188404725">"Astfel veți reseta dispozitivul și veți reveni la primul ecran"</string>
    <string name="device_owner_cancel_message" msgid="2529288571742712065">"Opriți configurarea și ștergeți datele de pe dispozitiv?"</string>
    <string name="device_owner_cancel_cancel" msgid="1052951540909389275">"Anulați"</string>
    <string name="device_owner_error_ok" msgid="2002250763093787051">"Ok"</string>
    <string name="reset" msgid="6467204151306265796">"Resetați"</string>
    <string name="cant_set_up_profile" msgid="4341825293970158436">"Nu se poate configura profilul"</string>
    <string name="cant_set_up_device" msgid="4120090138983350714">"Nu se poate configura dispozitivul"</string>
    <string name="something_went_wrong" msgid="3593223774041784329">"A apărut o eroare"</string>
    <string name="couldnt_set_up_device" msgid="5137950404283642302">"Nu s-a putut configura dispozitivul. Pentru ajutor, contactați administratorul IT."</string>
    <string name="contact_your_admin_for_help" msgid="2009904021552323731">"Contactați administratorul IT pentru ajutor"</string>
    <string name="reset_device" msgid="5483853913241939262">"Resetați dispozitivul și încercați să îl configurați din nou"</string>
    <string name="device_already_set_up" msgid="507881934487140294">"Dispozitivul este deja configurat"</string>
    <string name="error_wifi" msgid="1850288843966836571">"Nu s-a putut conecta la Wi-Fi"</string>
    <string name="device_has_reset_protection_contact_admin" msgid="2662050020376475656">"Pe dispozitivul dvs. este activată protecția împotriva resetării. Pentru ajutor, contactați administratorul IT."</string>
    <string name="frp_clear_progress_title" msgid="8628074089458234965">"Se șterge"</string>
    <string name="frp_clear_progress_text" msgid="1740164332830598827">"Așteptați..."</string>
    <string name="error_hash_mismatch" msgid="1145488923243178454">"Nu s-a putut folosi aplicația pentru administratori din cauza unei erori de sumă de control. Pentru ajutor, contactați administratorul IT."</string>
    <string name="error_download_failed" msgid="3274283629837019452">"Nu s-a putut descărca aplicația pentru administratori"</string>
    <string name="error_package_invalid" msgid="555402554502033988">"Nu se poate folosi aplicația pentru administratori deoarece este coruptă sau lipsesc componente. Pentru ajutor, contactați administratorul IT."</string>
    <string name="error_installation_failed" msgid="2282903750318407285">"Eroare la instalarea aplicației pentru administratori"</string>
    <string name="profile_owner_cancel_message" msgid="6868736915633023477">"Opriți configurarea?"</string>
    <string name="profile_owner_cancel_cancel" msgid="4408725524311574891">"Nu"</string>
    <string name="profile_owner_cancel_ok" msgid="5951679183850766029">"Da"</string>
    <string name="profile_owner_cancelling" msgid="5679573829145112822">"Se anulează..."</string>
    <string name="work_profile_setup_later_title" msgid="9069148190226279892">"Opriți configurarea profilului?"</string>
    <string name="work_profile_setup_later_message" msgid="122069011117225292">"Puteți configura profilul de serviciu mai târziu din aplicația de administrare a dispozitivelor folosită de organizația dvs."</string>
    <string name="continue_button" msgid="7177918589510964446">"Continuați"</string>
    <string name="work_profile_setup_stop" msgid="6772128629992514750">"Opriți"</string>
    <string name="dismiss" msgid="9009534756748565880">"Închideți"</string>
    <string name="profile_owner_info" msgid="8975319972303812298">"Sunteți pe punctul de a crea un profil de serviciu care va fi gestionat și monitorizat de organizația dvs. Se impun condiții."</string>
    <string name="profile_owner_info_with_terms_headers" msgid="7373591910245655373">"Sunteți pe punctul de a crea un profil de serviciu care va fi gestionat și monitorizat de organizația dvs. Trebuie respectate condiții impuse de <xliff:g id="TERMS_HEADERS">%1$s</xliff:g>."</string>
    <string name="profile_owner_info_comp" msgid="9190421701126119142">"Va fi creat un profil pentru aplicațiile dvs. de serviciu. Acest profil și restul dispozitivului vor fi gestionate și monitorizate de organizația dvs. Se impun condiții."</string>
    <string name="profile_owner_info_with_terms_headers_comp" msgid="2012766614492554556">"Va fi creat un profil pentru aplicațiile dvs. de serviciu. Acest profil și restul dispozitivului vor fi gestionate și monitorizate de organizația dvs. Trebuie respectate condiții impuse de <xliff:g id="TERMS_HEADERS">%1$s</xliff:g>."</string>
    <string name="device_owner_info" msgid="3716661456037934467">"Acest dispozitiv va fi gestionat, monitorizat și păstrat în siguranță de <xliff:g id="YOUR_ORGANIZATION">%1$s</xliff:g>. Se aplică termeni. <xliff:g id="VIEW_TERMS">%2$s</xliff:g>"</string>
    <string name="device_owner_info_with_terms_headers" msgid="1254243288669282977">"Acest dispozitiv va fi gestionat, monitorizat și păstrat în siguranță de <xliff:g id="YOUR_ORGANIZATION">%1$s</xliff:g>. Se aplică termenii din <xliff:g id="TERMS_HEADERS">%2$s</xliff:g>. <xliff:g id="VIEW_TERMS">%3$s</xliff:g>"</string>
    <string name="link_isnt_secure_and_cant_be_opened_until_device_setup_finished" msgid="1604497932637832657">"Acest link nu este sigur și nu poate fi deschis până când nu se încheie configurarea dispozitivului: <xliff:g id="LINK_RAW_TEST">%1$s</xliff:g>"</string>
    <string name="contact_device_provider" msgid="2843488903902493030">"Contactați <xliff:g id="IT_ADMIN">%1$s</xliff:g> pentru a afla mai multe."</string>
    <string name="if_questions_contact_admin" msgid="3509427015901582047">"Dacă aveți întrebări, contactați administratorul IT"</string>
    <string name="setup_isnt_finished_contact_admin" msgid="8849644190723875952">"Configurarea nu este finalizată. Pentru ajutor, contactați administratorul IT."</string>
    <string name="for_help_contact_admin" msgid="5922538077702487859">"Pentru ajutor, contactați administratorul IT"</string>
    <string name="organization_admin" msgid="5975914478148511290">"Administrator IT"</string>
    <string name="your_org_app_used" msgid="5336414768293540831">"<xliff:g id="YOUR_ORGANIZATION">%1$s</xliff:g> va gestiona și monitoriza acest dispozitiv utilizând următoarea aplicație:"</string>
    <string name="your_organization_beginning" msgid="5952561489910967255">"Organizația dvs."</string>
    <string name="your_organization_middle" msgid="8288538158061644733">"organizația dvs."</string>
    <string name="view_terms" msgid="7230493092383341605">"Consultați condițiile"</string>
    <string name="accept_and_continue" msgid="1632679734918410653">"Acceptați și cont."</string>
    <string name="back" msgid="6455622465896147127">"Înapoi"</string>
    <string name="set_up_your_device" msgid="1896651520959894681">"Configurați dispozitivul"</string>
    <string name="info_anim_title_0" msgid="3285414600215959704">"Schimbați modul în care lucrați"</string>
    <string name="info_anim_title_1" msgid="2657512519467714760">"Separați datele de serviciu de cele personale"</string>
    <string name="one_place_for_work_apps" msgid="2595597562302953960">"O singură locație pentru aplicațiile de serviciu"</string>
    <string name="info_anim_title_2" msgid="4629781398620470204">"Dezactivați serviciul atunci când terminați"</string>
    <string name="provisioning" msgid="4512493827019163451">"Se asigură accesul"</string>
    <string name="copying_certs" msgid="5697938664953550881">"Se configurează certificatele CA"</string>
    <string name="setup_profile" msgid="5573950582159698549">"Configurați-vă profilul"</string>
    <string name="profile_benefits_description" msgid="758432985984252636">"Folosind un profil de serviciu, puteți separa datele profesionale de cele personale"</string>
    <string name="comp_profile_benefits_description" msgid="379837075456998273">"Folosind un profil de serviciu, vă puteți păstra aplicațiile de serviciu într-un singur loc"</string>
    <string name="setup_profile_encryption" msgid="5241291404536277038">"Configurați profilul. Criptarea"</string>
    <string name="setup_profile_progress" msgid="7742718527853325656">"Configurați profilul. Se afișează progresul"</string>
    <string name="setup_device" msgid="6725265673245816366">"Configurarea dispozitivului"</string>
    <string name="setup_device_encryption" msgid="7852944465414197103">"Configurați dispozitivul. Criptarea"</string>
    <string name="setup_device_progress" msgid="7035335208571175393">"Configurați dispozitivul. Se afișează progresul"</string>
    <string name="learn_more_label" msgid="2723716758654655009">"Butonul Aflați mai multe"</string>
    <string name="mdm_icon_label" msgid="3399134595549660561">"Pictograma <xliff:g id="ICON_LABEL">%1$s</xliff:g>"</string>
    <string name="section_heading" msgid="3924666803774291908">"Titlul secțiunii <xliff:g id="SECTION_HEADING">%1$s</xliff:g>."</string>
    <string name="section_content" msgid="8875502515704374394">"Conținutul secțiunii <xliff:g id="SECTION_HEADING">%1$s</xliff:g>: <xliff:g id="SECTION_CONTENT">%2$s</xliff:g>"</string>
    <string name="expand" msgid="37188292156131304">"Extindeți"</string>
    <string name="collapse" msgid="7817530505064432580">"Restrângeți"</string>
    <string name="access_list_of_links" msgid="7094123315959323372">"Accesați o listă de linkuri"</string>
    <string name="access_links" msgid="7991363727326168600">"Accesați linkurile"</string>
    <string name="access_terms" msgid="1982500872249763745">"Accesați condițiile"</string>
    <string name="read_terms" msgid="1745011123626640728">"Citiți condițiile"</string>
    <string name="close_list" msgid="9053538299788717597">"Închideți lista"</string>
    <string name="cancel_setup_and_factory_reset_dialog_title" msgid="5416045931532004811">"Încheiați configurarea și reveniți la setările din fabrică?"</string>
    <string name="cancel_setup_and_factory_reset_dialog_msg" msgid="808442439937994485">"Dacă încheiați această configurare, dispozitivul va reveni la setările din fabrică, iar dvs. veți reveni la primul ecran."</string>
    <string name="cancel_setup_and_factory_reset_dialog_cancel" msgid="2810966091829264727">"Anulați"</string>
    <string name="cancel_setup_and_factory_reset_dialog_ok" msgid="7168008267496150529">"Resetați dispozitivul"</string>
    <string name="join_two_items" msgid="6110273439759895837">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> și <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_last" msgid="7469666990442158802">"<xliff:g id="ALL_BUT_LAST_ITEM">%1$s</xliff:g> și <xliff:g id="LAST_ITEM_0">%2$s</xliff:g>"</string>
    <string name="join_many_items_first" msgid="8365482726853276608">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="ALL_BUT_FIRST_AND_LAST_ITEM">%2$s</xliff:g>"</string>
    <string name="join_many_items_middle" msgid="8569294838319639963">"<xliff:g id="ADDED_ITEM">%1$s</xliff:g>, <xliff:g id="REST_OF_ITEMS">%2$s</xliff:g>"</string>
    <string name="take_a_few_minutes" msgid="6282806501305322838">"Poate dura câteva minute"</string>
    <string name="work_profile_description" msgid="8524116010729569213">"Aplicațiile dvs. de lucru vor fi păstrate în acest profil și vor fi gestionate de organizația dvs."</string>
    <string name="device_owner_description" msgid="168013145812679664">"Acest dispozitiv va fi păstrat în siguranță și gestionat de organizația dvs."</string>
    <string name="setup_provisioning_header" msgid="4282483198266806271">"Se pregătește configurarea dispozitivului de serviciu…"</string>
    <string name="setup_provisioning_header_description" msgid="2567041263563823566">"Se configurează aplicația pentru administratori"</string>
    <string name="brand_screen_header" msgid="8865808542690116648">"Dispozitivul aparține organizației dvs."</string>
    <string name="brand_screen_subheader" msgid="7664792208784456436">"Următoarea aplicație va fi folosită pentru a gestiona și monitoriza acest telefon"</string>
    <string name="account_management_disclaimer_header" msgid="8013083414694316564">"Contul dvs. este gestionat"</string>
    <string name="account_management_disclaimer_subheader" msgid="5146471918840236988">"Administratorul IT folosește gestionarea dispozitivelor mobile pentru a aplica politicile de securitate"</string>
    <string name="downloading_administrator_header" msgid="8660294318893902915">"Se pregătește pentru configurarea pentru serviciu…"</string>
    <string name="work_profile_provisioning_accept_header_post_suw" msgid="1353127953275291089">"Să configurăm profilul de serviciu"</string>
    <string name="work_profile_provisioning_step_1_header" msgid="7914961694921466366">"Aplicațiile de serviciu sunt păstrate în profilul de serviciu"</string>
    <string name="work_profile_provisioning_step_2_header" msgid="6001172190404670248">"Întrerupeți aplicațiile de serviciu când încheiați ziua"</string>
    <string name="work_profile_provisioning_step_3_header" msgid="4316106639726774330">"Datele din profilul de serviciu sunt vizibile pentru administratorul IT"</string>
    <string name="work_profile_provisioning_progress_label" msgid="2627905308998389193">"Se configurează profilul de serviciu…"</string>
    <string name="work_profile_provisioning_summary" msgid="3436190271657388747">"Aplicațiile pentru lucru sunt păstrate în profilul de serviciu. Puteți întrerupe aplicațiile pentru lucru când încheiați ziua. Datele din profilul de serviciu sunt vizibile pentru administratorul IT."</string>
    <string name="fully_managed_device_provisioning_accept_header" msgid="2944032660440403130">"Să configurăm dispozitivul de serviciu"</string>
    <string name="fully_managed_device_provisioning_step_1_header" msgid="6396274703116708592">"Păstrați aplicațiile de serviciu la îndemână"</string>
    <string name="fully_managed_device_provisioning_step_2_header" msgid="7165472083121590030">"Dispozitivul nu este privat"</string>
    <string name="fully_managed_device_provisioning_step_2_subheader" msgid="2848998570491578119">"Administratorul IT poate vedea datele și activitatea de pe acest dispozitiv."</string>
    <string name="fully_managed_device_provisioning_permissions_header" msgid="2852101532084770993">"Activitatea și datele dvs."</string>
    <string name="fully_managed_device_provisioning_permissions_secondary_header" msgid="4419374850927705136">"Permisiuni pentru aplicații"</string>
    <string name="fully_managed_device_provisioning_permissions_secondary_subheader" msgid="8328298923037335068">"Administratorul IT poate seta permisiuni pentru aplicațiile de pe acest dispozitiv, de exemplu, pentru microfon, camera foto și locație."</string>
    <string name="fully_managed_device_provisioning_progress_label" msgid="3925516135130021966">"Se configurează dispozitivul…"</string>
    <string name="fully_managed_device_provisioning_summary" msgid="1090645190066781456">"Folosiți acest dispozitiv ca să accesați cu ușurință aplicațiile pentru lucru. Acest dispozitiv nu este privat, iar administratorul IT vă poate vedea datele și activitatea."</string>
    <string name="fully_managed_device_with_permission_control_provisioning_summary" msgid="6634797147105465856">"Folosiți acest dispozitiv ca să accesați cu ușurință aplicațiile pentru lucru. Acest dispozitiv nu este privat, iar administratorul IT vă poate vedea datele și activitatea. În plus, administratorul IT poate seta permisiuni pentru aplicațiile de pe acest dispozitiv, de exemplu, pentru microfon, camera foto și locație."</string>
    <string name="fully_managed_device_provisioning_return_device_title" msgid="8500829014794276683">"Returnați dispozitivul administratorului IT"</string>
    <string name="fully_managed_device_provisioning_return_device_subheader" msgid="6194410367910957686">"Reveniți la ecranul anterior sau resetați dispozitivul și returnați-l administratorului IT."</string>
    <string name="fully_managed_device_cancel_setup_button" msgid="4910041382610777599">"Anulați configurarea"</string>
    <string name="fully_managed_device_reset_and_return_button" msgid="6451125722998550681">"Resetați și returnați dispozitivul"</string>
    <string name="cope_provisioning_step_1_header" msgid="1945759718804756423">"Aplicațiile de serviciu se află în profilul de serviciu, gestionate de administratorul IT"</string>
    <string name="cope_provisioning_step_2_header" msgid="2388399739294883042">"Aplicațiile personale sunt izolate, ascunse de cele de serviciu"</string>
    <string name="cope_provisioning_step_3_header" msgid="7161795433847296201">"Administratorul IT poate să controleze dispozitivul și să blocheze aplicații"</string>
    <string name="cope_provisioning_summary" msgid="993014104601034878">"Aplicațiile pentru lucru se păstrează în profilul de serviciu și sunt gestionate de administratorul IT. Aplicațiile personale sunt separate și ascunse de cele pentru lucru. Administratorul IT poate să controleze acest dispozitiv și să blocheze anumite aplicații."</string>
    <string name="just_a_sec" msgid="6244676028626237220">"O secundă…"</string>
    <string name="fully_managed_device_provisioning_privacy_title" msgid="4017627906103556021">"Memento privind confidențialitatea"</string>
    <string name="fully_managed_device_provisioning_privacy_body" msgid="2219074604343348608">"Administratorul IT vă poate vedea datele și activitatea pe acest dispozitiv"</string>
    <string name="financed_device_screen_header" msgid="6875169548352717124">"Acest dispozitiv este oferit de <xliff:g id="CREDITOR_NAME">%s</xliff:g>"</string>
    <string name="financed_make_payments_subheader_title" msgid="7880606710044254210">"Faceți plăți pentru acest dispozitiv"</string>
    <string name="financed_make_payments_subheader_description" msgid="1222254084091306375">"<xliff:g id="CREDITOR_NAME_0">%1$s</xliff:g> poate să instaleze aplicația <xliff:g id="CREDITOR_NAME_1">%2$s</xliff:g> ca să puteți face plăți pentru acest dispozitiv."</string>
    <string name="financed_restrict_device_subheader_title" msgid="2138828664816418195">"Dispozitivul poate fi restricționat"</string>
    <string name="financed_restrict_device_subheader_description" msgid="5683975693718163300">"<xliff:g id="CREDITOR_NAME">%1$s</xliff:g> poate să restricționeze accesul la acest dispozitiv dacă nu faceți plăți."</string>
    <string name="error_role_holder_hash_mismatch" msgid="6201584198247885437">"Nu se poate configura dispozitivul. Contactați administratorul IT și menționați „Sumă de verificare nevalidă”."</string>
    <string name="error_role_holder_download_install_failed" msgid="8151968372180693228">"Încercați din nou mai târziu sau contactați administratorul IT pentru ajutor"</string>
    <string name="error_role_holder_package_invalid" msgid="2631207759497988833">"Nu se poate configura dispozitivul. Contactați administratorul IT și menționați „Componente lipsă sau deteriorate”."</string>
    <string name="setting_up" msgid="1478847967385506664">"Se configurează…"</string>
</resources>
