<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="lt">
<translation id="101438888985615157">Pasukti ekraną 180 laipsnių kampu</translation>
<translation id="1016912092715201525">Konfigūruojamos „<ph name="PRODUCT_NAME" />“ vykdomos numatytosios naršyklės patikros; naudotojams šio nustatymo keisti neleidžiama.

      Jei įgalinsite šį nustatymą, paleidžiant „<ph name="PRODUCT_NAME" />“ visada tikrins, ar ji yra numatytoji naršyklė, ir, jei galima, automatiškai užsiregistruos.

      Jei šis nustatymas bus išjungtas, „<ph name="PRODUCT_NAME" />“ niekada netikrins, ar ji yra numatytoji naršyklė, o naudotojams bus neleidžiama naudoti šios parinkties nustatymo valdiklių.

      Nenustačius šio nustatymo „<ph name="PRODUCT_NAME" />“ leis naudotojui valdyti numatytosios naršyklės parinktis ir nurodyti, ar turi būti pateikti naudotojui skirti pranešimai, jei naršyklė nėra numatytoji.

      Pastaba „<ph name="MS_WIN_NAME" />“ administratoriams: įgalinti šį nustatymą galima tik įrenginiuose, kuriuose veikia versija „Windows 7“. Jei įrenginyje įdiegta „Windows 8“ arba vėlesnė versija, turite pritaikyti „numatytųjų programų susiejimų“ failą, kuris paverčia „<ph name="PRODUCT_NAME" />“ protokolų <ph name="HHTPS_PROTOCOL" /> ir <ph name="HTTP_PROTOCOL" /> (ir pasirinktinai protokolo <ph name="FTP_PROTOCOL" /> bei failų formatų <ph name="HTML_EXTENSION" />, <ph name="HTM_EXTENSION" />, <ph name="PDF_EXTENSION" />, <ph name="SVG_EXTENSION" />, <ph name="WEBP_EXTENSION" /> ir kt.) dorokle. Jei reikia daugiau informacijos, žr. <ph name="SUPPORT_URL" />.</translation>
<translation id="1017967144265860778">Energijos valdymas prisijungimo ekrane</translation>
<translation id="1019101089073227242">Nustatyti naudotojo duomenų katalogą</translation>
<translation id="1022361784792428773">Plėtinių, kurių diegti naudotojams turi būti neleidžiama (arba „*“, jei neleidžiama nė vieno), ID</translation>
<translation id="102492767056134033">Nustatyti numatytąją ekrano klaviatūros būseną prisijungimo ekrane</translation>
<translation id="1027000705181149370">Nurodoma, ar į naudotojo profilį turi būti perduodami autentifikavimo slapukai, kuriuos nustatė SAML IdP.

      Jei prisijungiantis naudotojas autentifikuojamas naudojant SAML IdP, IdP nustatyti slapukai pirmiausia įrašomi į laikiną profilį. Šiuos slapukus galima perkelti į naudotojo profilį, kad būtų galima toliau autentifikuoti.

     Kai ši politika nustatyta kaip „tiesa“, IdP nustatyti slapukai perkeliami į naudotojo profilį kaskart, kai jie prisijungiant autentifikuojami pagal SAML IdP.

      Kai ši politika nustatyta kaip „netiesa“ arba nenustatyta, IdP nustatyti slapukai perkeliami į naudotojo profilį, tik kai naudotojas pirmą kartą prisijungia įrenginyje.

      Ši politika paveikia tik tuos naudotojus, kurių domenas sutampa su įrenginio registracijos domenu. Kitų naudotojų atvejais IdP nustatyti slapukai perkeliami į naudotojo profilį, tik kai naudotojas pirmą kartą prisijungia įrenginyje.</translation>
<translation id="1035385378988781231">Ši politika valdo, ar „<ph name="PRODUCT_NAME" />“ tinklo failų bendrinimo įrenginių funkcija naudoja NTLM tapatybei nustatyti.

      Kai ši politika nustatyta kaip „Tiesa“, NTLM naudojama mažų ir vidutinio dydžio įmonių bendrinimo įrenginių tapatybei nustatyti, jei reikia.
      Kai ši politika nustatyta kaip „Netiesa“, mažų ir vidutinio dydžio įmonių bendrinimo įrenginių tapatybės nustatymas naudojant NTLM išjungtas.

      Nenustačius politikos numatytoji vertė yra išjungta įmonių valdomiems naudotojams ir įgalinta nevaldomiems naudotojams.</translation>
<translation id="1040446814317236570">PAC URL perdavimo įgalinimas (skirta https://)</translation>
<translation id="1044878202534415707">Teikiamos aparatinės įrangos statistikos, pvz., centrinio procesoriaus / laisvosios prieigos atminties naudojimo, ataskaitos.

      Jei ši politika nustatyta į „false“, nebus teikiamos statistikos ataskaitos.
      Jei ji nustatyta į „true“ arba yra nenustatyta, statistikos ataskaitos bus teikiamos.</translation>
<translation id="1046484220783400299">Laikinai įgalinti nebenaudojamas žiniatinklio platformos funkcijas</translation>
<translation id="1047128214168693844">Neleisti jokioje svetainėje stebėti naudotojo buvimo vietos</translation>
<translation id="1049138910114524876">Konfigūruojama „<ph name="PRODUCT_OS_NAME" />“ prisijungimo ekrane priverstinai vykdoma lokalė.

      Jei ši politika nustatyta, prisijungimo ekranas visada bus pateikiamas lokale, kuria pateikta pirma šios politikos vertė (politika apibrėžta kaip sąrašas, kad būtų suderinama ir ateityje).  Jei ši politika nenustatyta arba nustatytas tuščias sąrašas, prisijungimo ekranas bus pateikiamas paskutinės naudotojo sesijos lokale.  Jei ši politika nustatyta į netinkamą lokalės vertę, prisijungimo ekranas bus pateikiamas atsargine lokale (šiuo metu tai en-US).</translation>
<translation id="1062011392452772310">Įgalinti nuotolinį įrenginio patvirtinimą</translation>
<translation id="1062407476771304334">Pakeisti</translation>
<translation id="1079801999187584280">Neleisti naudoti kūrėjo įrankių</translation>
<translation id="1093082332347834239">Jei šis nustatymas įgalintas, nuotolinės pagalbos prieglobos serveris bus vykdomas su „<ph name="UIACCESS_PERMISSION_NAME" />“ leidimais. Taip nuotoliniai naudotojai galės sąveikauti su pakeltais langais vietiniame naudotojo staliniame kompiuteryje.

          Jei šis nustatymas išjungtas arba nesukonfigūruotas, nuotolinės pagalbos prieglobos serveris bus vykdomas naudotojo kontekste ir nuotoliniai naudotojai negalės sąveikauti su pakeltais langais staliniame kompiuteryje.</translation>
<translation id="1096105751829466145">Numatytasis paieškos teikėjas</translation>
<translation id="1099282607296956954">Įgalinti visų svetainių atskyrimą</translation>
<translation id="1100570158310952027">
      Politikoje nurodytas šaltinių (URL) arba prieglobos serverio pavadinimo šablonų
      (pvz., *.example.com), kuriems nebus taikomi nesaugių šaltinių apribojimai,
      sąrašas.

      Siekiama leisti organizacijoms nustatyti pasenusių programų, negalinčių
      taikyti TLS, baltojo sąrašo šaltinius arba darbinį serverį vidiniams žiniatinklio
      tobulinimams atlikti, kad organizacijų kūrėjai galėtų išbandyti funkcijas,
      kurioms reikia saugaus konteksto, ir darbiniame serveryje nereikėtų diegti
      TLS. Ši politika taip pat neleis, kad „omnibox“ šaltinis būtų pažymėtas kaip
      „Nesaugus“.

      Šioje politikoje nustačius URL sąrašą poveikis toks pat, kaip nustačius
      komandinės eilutės žymą „--unsafely-treat-insecure-origin-as-secure“ į
      kableliais atskirtų tų pačių URL sąrašą. Jei ši politika nustatyta, bus
      nepaisoma komandinės eilutės žymos.

      Ši politika nepaisys „UnsafelyTreatInsecureOriginAsSecure“ (jei yra).

      Daugiau informacijos apie saugius kontekstus pateikiama adresu
      https://www.w3.org/TR/secure-contexts/.
      </translation>
<translation id="1117535567637097036">Protokolų doroklės, nustatytos pagal šią politiką, nenaudojamos apdorojant „Android“ tikslus.</translation>
<translation id="1118093128235245168">Leisti svetainėms prašyti naudotojo suteikti galimybę pasiekti prijungtą USB įrenginį</translation>
<translation id="1128903365609589950">Konfigūruojamas katalogas, kurį „<ph name="PRODUCT_NAME" />“ naudos, kad išsaugotų talpykloje saugomus failus diske.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME" />“ naudos pateiktą katalogą neatsižvelgiant į tai, ar naudotojas nurodė žymą „--disk-cache-dir“, ar ne. Kad neprarastumėte duomenų ir išvengtumėte kitų netikėtų klaidų, ši politika neturėtų būti nustatyta tomo šakniniame kataloge ar kitais tikslais naudojamame kataloge, nes „<ph name="PRODUCT_NAME" />“ tvarko savo turinį.

      Galimų naudoti kintamųjų sąrašą rasite apsilankę adresu https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Jei ši politika nenustatyta, bus naudojamas numatytasis talpyklos katalogas ir naudotojas galės jo nepaisyti naudodamas komandos eilutės žymą „--disk-cache-dir“.</translation>
<translation id="1135264353752122851">Konfigūruojama, kurie klaviatūros išdėstymai leidžiami „<ph name="PRODUCT_OS_NAME" />“ naudotojų sesijoms.

      Jei ši politika nustatyta, naudotojas gali pasirinkti tik vieną iš šios politikos nurodytų įvesties metodų. Jei ši politika nenustatyta arba nustatyta kaip tuščias sąrašas, naudotojas gali pasirinkti visus palaikomus įvesties metodus. Jei dabartinis įvesties metodas neleidžiamas pagal šią politiką, įvesties metodas bus perjungtas į aparatinės įrangos klaviatūros išdėstymą (jei leidžiama) arba pirmą tinkamą įrašą šiame sąraše. Visų netinkamų ar nepalaikomų įvesties metodų šiame sąraše bus nepaisoma.</translation>
<translation id="1138294736309071213">Ši politika aktyvi tik dirbant mažmeninės prekybos režimu.

      Nustatoma trukmė iki ekrano užsklandos parodymo įrenginių prisijungimo ekrane dirbant mažmeninės prekybos režimu.

      Politikos vertė turėtų būti nurodyta milisekundėmis.</translation>
<translation id="1151353063931113432">Leisti vaizdus šiose svetainėse</translation>
<translation id="1152117524387175066">Pateikti įrenginio „Dev“ perjungimo būseną paleidžiant.

      Jei ši politika nustatyta kaip „False“, „Dev“ perjungimo būsena nebus pateikta.</translation>
<translation id="1160479894929412407">Leisti QUIC protokolą</translation>
<translation id="1160939557934457296">Neleisti tęsti veiksmų iš Saugaus naršymo įspėjimo puslapio</translation>
<translation id="1189817621108632689">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose neleidžiama pateikti vaizdų, sąrašą.

          Nenustačius šios politikos, visose svetainėse naudojama visuotinė numatytoji vertė iš politikos „DefaultImagesSetting“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.

          Atkreipkite dėmesį, kad anksčiau ši politika per klaidą buvo įgalinta „Android“, bet ši funkcija šioje platformoje niekada nebuvo visiškai palaikoma.</translation>
<translation id="1198465924256827162">Įrenginio būsenos įkėlimo nustatymo dažnis milisekundėmis.

      Jei ši politika nenustatyta, numatytasis dažnis yra 3 val. Minimalus
      leistinas dažnis yra 60 sekundžių.</translation>
<translation id="1204263402976895730">Įgalinti įmonės spausdintuvai</translation>
<translation id="1219695476179627719">Nurodoma, ar įrenginyje turėtų būti grąžinta pagal politiką „<ph name="DEVICE_TARGET_VERSION_PREFIX_POLICY_NAME" />“ nustatyta versija, jei jame jau paleista naujesnė versija.

      Numatytasis nustatymas yra „RollbackDisabled“.</translation>
<translation id="1221359380862872747">Įkelti nurodytus URL prisijungiant prie demonstracinės versijos</translation>
<translation id="1223789468190631420">Saugus naršymas įgalina patikimų šaltinių būseną</translation>
<translation id="122899932962115297">Baltasis sąrašas, kuriuo valdoma, kuriuos sparčiojo atrakinimo režimus naudotojas gali konfigūruoti ir naudoti norėdamas atrakinti užrakinimo ekraną.

          Ši vertė yra eilučių sąrašas. Galiojantys sąrašo įrašai yra: „all“, „PIN“, „FINGERPRINT“. Prie sąrašo pridėjus „all“ naudotojui bus pasiekiami visi sparčiojo atrakinimo režimai, įskaitant tuos, kurie bus įdiegti ateityje. Priešingu atveju bus pasiekiami tik sąraše pateikiami sparčiojo atrakinimo režimai.

          Pavyzdžiui, jei norite leisti naudoti visus sparčiojo atrakinimo režimus, naudokite ["all"]. Jei norite leisti atrakinti naudojant PIN kodą arba kontrolinį kodą, naudokite ["PIN", "FINGERPRINT"]. Jei norite išjungti visus sparčiojo atrakinimo režimus, naudokite [].

          Pagal numatytuosius nustatymus tvarkomuose įrenginiuose nepasiekiami jokie sparčiojo atrakinimo režimai.</translation>
<translation id="123081309365616809">Įgalinamas turinio perdavimas į įrenginį</translation>
<translation id="1243570869342663665">Valdomas „SafeSites“ turinio suaugusiesiems filtravimas.</translation>
<translation id="1257550411839719984">Numatytojo atsisiuntimų katalogo nustatymas</translation>
<translation id="1265053460044691532">Apribokite laiką, per kurį per SAML autentifikuotas naudotojas gali prisijungti neprisijungęs</translation>
<translation id="1291880496936992484">Įspėjimas: RC4 bus visiškai pašalinta iš „<ph name="PRODUCT_NAME" />“ įdiegus 52 versiją (maždaug 2016 m. rugsėjo mėn.) ir ši politika nebegalios.

      Jei politika nenustatyta arba nustatyta į „false“, TLS RC4 šifruotieji programų komplektai nebus įgalinti. Priešingu atveju ją galima nustatyti į „true“, kad būtų išsaugotas suderinamumas su pasenusiu serveriu. Tai laikina priemonė; serverį reikia iš naujo sukonfigūruoti.</translation>
<translation id="1297182715641689552">Naudoti .pac tarpinio serverio scenarijų</translation>
<translation id="1304973015437969093">Automatiškai diegiami plėtinių / programų ID ir atnaujinimo URL</translation>
<translation id="1307454923744766368">Šaltiniai arba prieglobos serverio pavadinimo šablonai, kuriems netaikomi
      nesaugių šaltinių apribojimai</translation>
<translation id="1313457536529613143">Nurodomas ekrano užtemdymo delsos mastelio keitimo procentas, kai aptinkama naudotojo veikla ekranui esant užtemdytam ar iškart po to, kai ekranas išjungiamas.

         Jei ši politika nustatyta, ji nurodo ekrano užtemdymo delsos mastelio keitimo procentą, kai aptinkama naudotojo veikla ekranui esant užtemdytam ar iškart po to, kai ekranas išjungiamas. Kai užtemdymo delsa nustatyta, ekrano išjungimo, užrakinimo ir neveikos būsenos delsos koreguojamos siekiant išlaikyti vienodą laiką nuo pirminės sukonfigūruotos užtemdymo delsos.

          Jei ši politika nenustatyta, naudojamas numatytasis skalės mastelio faktorius.

          Skalės mastelio faktorius turi būti 100 proc. arba daugiau.</translation>
<translation id="131353325527891113">Rodyti naudotojų vardus prisijungimo ekrane</translation>
<translation id="1327466551276625742">Įgalinti tinklo konfigūracijos raginimą, kai esate neprisijungę</translation>
<translation id="1330145147221172764">Įgalinti ekrano klaviatūrą</translation>
<translation id="13356285923490863">Politikos pavadinimas</translation>
<translation id="1352174694615491349">Taikant šią politiką leidžiamas HTTP/2 ryšių susijungimas, kai naudojami kliento sertifikatai. Kad galėtų įvykti susijungimas, galimo naujo ryšio prieglobos serverio pavadinimas ir esamo ryšio prieglobos serverio pavadinimas turi atitikti vieną arba daugiau šioje politikoje aprašytų šablonų. Politika yra prieglobų sąrašas, kuriame naudojamas „URLBlacklist“ filtro formatas: example.com atitinka example.com ir visus padomenius (pvz., sub.example.com), o .example.net tiksliai atitinka .example.net.

      Dėl susijungimo užklausų įvairioms priegloboms per ryšius, kuriuose naudojami kliento sertifikatai, gali kilti saugos ir privatumo problemų, nes visoms užklausoms bus suteiktos adaptyviosios prieigos teisės, net jei naudotojas tam tiesiogiai nesuteikė leidimo. Ši politika yra laikina ir būsimame leidime bus pašalinta. Žr. adresu https://crbug.com/855690.

      Jei ši politika nenustatyta, bus taikoma numatytoji elgsena – neleisti HTTP/2 ryšiui susijungti su ryšiais, kuriuose naudojami kliento sertifikatai.</translation>
<translation id="1353966721814789986">Paleisties puslapiai</translation>
<translation id="1359553908012294236">Jei ši politika nustatyta į „true“ arba yra nesukonfigūruota, „<ph name="PRODUCT_NAME" />“ įgalins svečių prisijungimą. Svečių prisijungimas yra „<ph name="PRODUCT_NAME" />“ profiliai, kur visi langai naudojami inkognito režimu.

      Jei ši politika nustatyta į „false“, „<ph name="PRODUCT_NAME" />“ neleis pradėti svečio profilių.</translation>
<translation id="1363275621236827384">Įgalinti užklausas į „Quirks Server“, skirtas aparatinės įrangos profiliams</translation>
<translation id="1372267489642113556">
      Įgalinus politiką kiekvienas pavadinimą turintis šaltinis, įtrauktas
      į kableliais atskirtų verčių sąrašą, vykdys atskirą procesą. Taip pat bus atskiriami
      šaltiniai, pavadinti pagal subdomenus, pvz., nurodžius https://example.com/ taip pat
      bus atskiriamas ir subdomenas https://foo.example.com/ kaip svetainės
      https://example.com/ dalis.
      Išjungus politiką nebus taikomas svetainių atskyrimas, o „IsolateOrigins“ ir „SitePerProcess“ bandymai bus išjungti. Naudotojai vis tiek galės neautomatiškai įgalinti „SitePerProcess“.
      Nesukonfigūravus politikos naudotojas galės pakeisti šį nustatymą.
      Sistemoje „<ph name="PRODUCT_OS_NAME" />“ taip pat rekomenduojama nustatyti tą pačią įrenginio politikos „<ph name="DEVICE_LOGIN_SCREEN_ISOLATE_ORIGINS_POLICY_NAME" />“ vertę. Jei abiejų tipų politikos nustatytos vertės neatitinka viena kitos, pradedant naudotojo sesiją gali būti uždelsta, kol taikoma naudotojo politikos nurodyta vertė.

      PASTABA: ši politika netaikoma sistemoje „Android“. Kad įgalintumėte „IsolateOrigins“ sistemoje „Android“, naudokite politikos nustatymą „IsolateOriginsAndroid“.
      </translation>
<translation id="1384459581748403878">Nuoroda: <ph name="REFERENCE_URL" /></translation>
<translation id="1387596372902085462">Nurodoma, ar įgalinti patikimumo nustatymus „Symantec Corporation“ pasenusioje PKI infrastruktūroje</translation>
<translation id="1393485621820363363">Įgalinti įmonės įrenginių spausdintuvai</translation>
<translation id="1397855852561539316">Numatytojo paieškos teikėjo siūlymo URL</translation>
<translation id="1413936351612032792">Informacijos apie „Linux“ programų pateikimas</translation>
<translation id="142346659686073702">Leidimas nesusietiems naudotojams naudoti „Crostini“</translation>
<translation id="1426410128494586442">Taip</translation>
<translation id="1427655258943162134">Tarpinio serverio adresas arba URL</translation>
<translation id="1435659902881071157">Įrenginio lygio tinklo konfigūracija</translation>
<translation id="1438739959477268107">Numatytasis rakto generavimo nustatymas</translation>
<translation id="1454846751303307294">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose neleidžiama paleisti „JavaScript“, sąrašą.

          Nenustačius šios politikos visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „Numatytasis „JavaScript“ nustatymas“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="1456822151187621582">„Windows“ („<ph name="PRODUCT_OS_NAME" />“ klientai):</translation>
<translation id="1464848559468748897">Kontroliuokite naudotojų elgseną kelių profilių sesijoje „<ph name="PRODUCT_OS_NAME" />“ įrenginiuose.

      Jei ši politika nustatyta į „MultiProfileUserBehaviorUnrestricted“, naudotojas gali būti pirminiu arba antriniu kelių profilių sesijos naudotoju.

      Jei ši politika nustatyta į „MultiProfileUserBehaviorMustBePrimary“, naudotojas gali būti tik pirminis kelių profilių sesijos naudotoju.

      Jei ši politika nustatyta į „MultiProfileUserBehaviorNotAllowed“, naudotojas negali dalyvauti kelių profilių sesijoje.

      Jei nustatysite šį nustatymą, naudotojai negalės jo pakeisti ar nepaisyti.

      Jei nustatymas pakeičiamas, kai naudotojas yra prisijungęs prie kelių profilių sesijos, bus patikrinti atitinkami visų sesijos naudotojų nustatymai. Sesija bus uždaryta, jei bet kuriam iš naudotojų nebeleidžiama dalyvauti sesijoje.

      Jei politika nenustatyta, numatytoji vertė „MultiProfileUserBehaviorMustBePrimary“ taikoma įmonėms tvarkomiems naudotojams, o „MultiProfileUserBehaviorUnrestricted“ – netvarkomiems naudotojams.</translation>
<translation id="1465619815762735808">Paleisti spustelėjus</translation>
<translation id="1468307069016535757">Nustatyti numatytąją didelio kontrasto pasiekiamumo funkciją prisijungimo ekrane.

          Jei ši politika nustatyta, didelio kontrasto režimas bus įgalintas, kai bus rodomas prisijungimo ekranas.

          Jei ši politika nenustatyta, didelio kontrasto režimas bus išjungtas, kai bus rodomas prisijungimo ekranas.

          Jei nustatysite šią politiką, naudotojai galės laikinai nepaisyti jos įgalinę arba išjungę didelio kontrasto režimą. Tačiau naudotojo pasirinkimas nėra ilgalaikis ir numatytasis nustatymas atkuriamas, kai prisijungimo ekranas rodomas iš naujo arba kai naudotojas vieną minutę neatlieka jokių veiksmų prisijungimo ekrane.

          Jei ši politika nenustatyta, didelio kontrasto režimas yra išjungtas, kai prisijungimo ekranas rodomas pirmą kartą. Naudotojai gali bet kada įgalinti arba išjungti didelio kontrasto režimą, o jo būsena skirtingiems naudotojams prisijungimo ekrane bus vienoda.</translation>
<translation id="1468707346106619889">Jei ši politika nustatyta į „true“, Sujungiamasis darbalaukis bus leidžiamas ir
      įgalintas pagal numatytuosius nustatymus. Taip programoms bus leidžiama užimti kelis ekranus.
      Naudotojas gali išjungti Sujungiamojo darbalaukio režimą atskiruose ekranuose atžymėdamas
      jį ekrano nustatymuose.

      Jei ši politika nustatyta į „false“ arba nenustatyta, Sujungiamasis darbalaukis bus
      išjungtas. Tokiu atveju naudotojas negalės įgalinti funkcijos.</translation>
<translation id="1474273443907024088">TLS klaidingo paleidimo išjungimas</translation>
<translation id="1477934438414550161">1.2 versijos TLS</translation>
<translation id="1484146587843605071">„<ph name="PRODUCT_NAME" />“ nepaisys tarpinio serverio iš čia pateikto prieglobos serverių sąrašo.

          Ši politika galioja, tik jei pasirinkote neautomatinius tarpinio serverio nustatymus skiltyje „Pasirinkti, kaip nurodyti tarpinio serverio nustatymus“.

          Jei pasirinkote kitą tarpinio serverio politikos nustatymo režimą, šios politikos neturėtumėte nustatyti.

          Jei reikia išsamesnių pavyzdžių, apsilankykite adresu
          <ph name="PROXY_HELP_URL" /></translation>
<translation id="1502843533062797703">Įgalinti trečiosios šalies programinės įrangos įdėjimo blokavimą</translation>
<translation id="1504431521196476721">Nuotolinis patvirtinimas</translation>
<translation id="1507957856411744193">Jei ši politika nustatyta į „true“, „<ph name="PRODUCT_NAME" />“ prisijungs prie perdavimo įrenginių, pasiekiamų visais IP adresais, o ne tik RFC1918 / RFC4193 privačiais adresais.

          Jei ši politika nustatyta į „false“, „<ph name="PRODUCT_NAME" />“ prisijungs prie perdavimo įrenginių, pasiekiamų tik RFC1918 / RFC4193 privačiais adresais.

          Jei ši politika nenustatyta, „<ph name="PRODUCT_NAME" />“ prisijungs prie perdavimo įrenginių, pasiekiamų tik RFC1918 / RFC4193 privačiais adresais, nebent įgalinta funkcija „CastAllowAllIPs“.

          Jei politika „EnableMediaRouter“ nustatyta į „false“, šios politikos vertė nedaro jokio poveikio.</translation>
<translation id="1509692106376861764">Ši politika nebenaudojama 29 ir naujesnėse „<ph name="PRODUCT_NAME" />“ versijose.</translation>
<translation id="1514888685242892912">Įgalinti „<ph name="PRODUCT_NAME" />“</translation>
<translation id="1522425503138261032">Leisti svetainėse stebėti naudotojo buvimo vietą</translation>
<translation id="152657506688053119">Alternatyvių numatytojo paieškos teikėjo URL sąrašas</translation>
<translation id="1530812829012954197">Visada pateikti šiuos URL šablonus prieglobos naršyklėje</translation>
<translation id="1541170838458414064">Spausdinamo puslapio dydžio apribojimas</translation>
<translation id="1553684822621013552">Kai ši politika yra galiojanti, ARC įgalinama naudotojui
      (taikomos papildomos politikos nustatymų patikros – ARC vis tiek bus
      nepasiekiama, jei trumpalaikis režimas arba kelios paskyros įgalintos
      dabartinėje naudotojo sesijoje).

      Jei šis nustatymas išjungtas arba nesukonfigūruotas, įmonių naudotojai
      negali naudoti ARC.</translation>
<translation id="1561424797596341174">Nuotolinės prieigos prieglobos derinimo versijų politikos pakeitimai</translation>
<translation id="1561967320164410511">Papildomi U2F asmeninės atestacijos plėtiniai</translation>
<translation id="1574554504290354326">Šis nustatymas nebenaudojamas. Vietoje jo naudokite „SafeBrowsingExtendedReportingEnabled“. „SafeBrowsingExtendedReportingEnabled“ įgalinimas arba išjungimas atitinka „SafeBrowsingExtendedReportingOptInAllowed“ nustatymą į „False“.

      Nustačius šią politiką į „False“ naudotojai nebegalės pasirinkti siųsti tam tikros sistemos informacijos ir puslapių turinio į „Google“ serverius. Jei šis nustatymas nustatytas į „True“ arba nesukonfigūruotas, naudotojai galės siųsti tam tikrą sistemos informaciją ir puslapių turinį į Saugaus naršymo sistemą, kad padėtų aptikti pavojingas programas ir svetaines.

      Daugiau informacijos apie Saugų naršymą pateikiama adresu https://developers.google.com/safe-browsing.</translation>
<translation id="1583248206450240930">Naudoti „<ph name="PRODUCT_FRAME_NAME" />“ pagal numatytuosius nustatymus</translation>
<translation id="1599424828227887013">Įgalinti nurodytų šaltinių svetainių atskyrimą „Android“ įrenginiuose</translation>
<translation id="1608755754295374538">URL, kuriems bus suteikta prieiga prie garso užfiksavimo įrenginių be paraginimo</translation>
<translation id="1615221548356595305">Leisti šių prieglobų HTTP/2 ryšių susijungimą, net jei naudojami kliento sertifikatai</translation>
<translation id="1617235075406854669">Įgalinti naršyklės ištrynimą ir atsisiuntimo istoriją</translation>
<translation id="163200210584085447">Šiame sąraše pateikti šablonai bus atitaikomi
      pagal užklausą pateikiančio URL saugos kilmę. Jei bus rasta atitiktis, prieiga prie vaizdo įrašus
      fiksuojančių įrenginių bus suteikta SAML prisijungimo puslapiuose. Neradus atitikties,
      prieiga bus automatiškai uždrausta. Pakaitos simbolių šablonai
      neleidžiami.</translation>
<translation id="1634989431648355062">Leisti papildinį „<ph name="FLASH_PLUGIN_NAME" />“ šiose svetainėse</translation>
<translation id="1655229863189977773">Nustatyti disko talpyklos dydį baitais</translation>
<translation id="166427968280387991">Tarpinis serveris</translation>
<translation id="1668836044817793277">Ar automatiškai be delsos paleistai viešojo terminalo programai bus leidžiama valdyti „<ph name="PRODUCT_OS_NAME" />“ versiją.

      Ši politika valdo, ar automatiškai be delsos paleistai viešojo terminalo programai bus leidžiama valdyti „<ph name="PRODUCT_OS_NAME" />“ versiją (jos apraše nurodžius „required_platform_version“) ir ją naudoti kaip automatinio naujinio tikslinės versijos priešdėlį.

      Jei politika nustatyta į „true“, automatiškai be delsos paleistos viešojo terminalo programos aprašo rakto „required_platform_version“ vertė naudojama kaip automatinio naujinio tikslinės versijos priešdėlis.

      Jei politika nesukonfigūruota arba nustatyta į „false“, aprašo rakto „required_platform_version“ nepaisoma ir automatinis atnaujinimas tęsiamas įprastai.

      Įspėjimas: nerekomenduojama viešojo terminalo programai perduoti leidimo valdyti „<ph name="PRODUCT_OS_NAME" />“ versiją, nes ji gali neleisti įrenginiui gauti naujinių ir svarbių saugos pataisų. Perdavus leidimą valdyti „<ph name="PRODUCT_OS_NAME" />“ versiją gali kilti grėsmė naudotojų saugai.</translation>
<translation id="1675002386741412210">Palaikoma naudojant:</translation>
<translation id="1689963000958717134">Leidžiama naudoti tinklo konfigūraciją, kad būtų taikoma visiems „<ph name="PRODUCT_OS_NAME" />“ įrenginio naudotojams. Tinklo konfigūracija yra JSON suformatuota eilutė, kaip nurodyta atvirojo tinklo konfigūracijos formato, aprašyto šiuo adresu: <ph name="ONC_SPEC_URL" /></translation>
<translation id="1708496595873025510">Nustatykite variantų pirminės reikšmės pateikimo apribojimą</translation>
<translation id="172374442286684480">Leisti visose svetainėse nustatyti vietinius duomenis</translation>
<translation id="1734716591049455502">Konfigūruoti nuotolinės prieigos parinktis</translation>
<translation id="1736269219679256369">Leidžiama tęsti iš SSL įspėjimo puslapio</translation>
<translation id="1749815929501097806">Nustatomos paslaugų teikimo sąlygos, su kuriomis naudotojas turi sutikti prieš pradėdamas vietinės įrenginio paskyros sesiją.

      Jei ši politika nustatyta, „<ph name="PRODUCT_OS_NAME" />“ atsisiųs paslaugų teikimo sąlygas ir pateiks jas naudotojui, kai prasidės vietinės įrenginio paskyros sesija. Naudotojui bus leista pradėti sesiją, tik kai jis sutiks su paslaugų teikimo sąlygomis.

      Jei ši politika nenustatyta, rodomos paslaugų teikimo sąlygos.

      Politika turėtų būti nustatyta į URL, kuriuo „<ph name="PRODUCT_OS_NAME" />“ gali atsisiųsti paslaugų teikimo sąlygas. Paslaugų teikimo sąlygas turi sudaryti paprastasis tekstas, pateiktas kaip MIME tipo tekstas / paprastasis tekstas. Neleidžiamas joks žymėjimas.</translation>
<translation id="1750315445671978749">Blokuoti visus atsisiuntimus</translation>
<translation id="1781356041596378058">Ši politika taip pat valdo galimybę pasiekti „Android“ kūrėjo parinktis. Jei šią politiką nustatysite į „Tiesa“, naudotojai negalės pasiekti kūrėjo parinkčių. Jei šią politiką nustatysite į „Netiesa“ arba jos nenustatysite, naudotojai galės pasiekti kūrėjo parinktis palietę versijos numerį septynis kartus „Android“ nustatymų programoje.</translation>
<translation id="1797233582739332495">Pasikartojančio raginimo, kuriame nurodoma, kad būtina paleisti iš naujo, rodymas naudotojui</translation>
<translation id="1803646570632580723">Paleidimo priemonėje prisegtų rodomų programų sąrašas</translation>
<translation id="1808715480127969042">Blokuoti slapukus šiose svetainėse</translation>
<translation id="1810261428246410396">Leisti momentinį įrenginio kaip modemo naudojimą.</translation>
<translation id="1827523283178827583">Naudoti fiksuotus tarpinius serverius</translation>
<translation id="1843117931376765605">Atnaujinti naudotojo politikos dažnį</translation>
<translation id="1844620919405873871">Konfigūruojama su sparčiuoju atrakinimu susijusi politika.</translation>
<translation id="1847960418907100918">Nurodomi parametrai, naudojami atliekant intuityviąją paiešką naudojant POST. Jie sudaryti iš kableliais atskirtų pavadinimų / verčių porų. Jei vertė yra šablono parametras, pvz., {searchTerms} anksčiau pateiktame pavyzdyje, ji pakeičiama realiais paieškos terminų duomenimis.

          Ši politika pasirenkama. Jei nenustatyta, intuityviosios paieškos užklausa siunčiama naudojant GET metodą.

          Šios politikos laikomasi, tik jei įgalinta politika „DefaultSearchProviderEnabled“.</translation>
<translation id="1852294065645015766">Leisti automatiškai leisti mediją</translation>
<translation id="1859859319036806634">Įspėjimas: atsarginės TLS versijos naudojimas bus pašalintas iš „<ph name="PRODUCT_NAME" />“ įdiegus 52 versiją (maždaug 2016 m. rugsėjo mėn.), tada ši politika nustos veikti.

      Įvykus TLS išankstinio suderinimo klaidai, „<ph name="PRODUCT_NAME" />“ anksčiau iš naujo bandydavo užmegzti ryšį su senesnės versijos TLS, kad išvengtų riktų HTTPS serveriuose. Nustačius šį nustatymą konfigūruojama versija, kurią pasiekus šis surogato procesas bus sustabdytas. Jei serveris tinkamai suderina versiją (t. y. nenutraukdamas ryšio), šis nustatymas netaikomas. Nepaisant to, užmegztas ryšys vis tiek turi atitikti „SSLVersionMin“.

      Jei ši politika nesukonfigūruota arba nustatyta į „tls1.2“, tada „<ph name="PRODUCT_NAME" />“ nebevykdo šio surogato proceso. Atminkite, kad neišjungiamas ankstesnių TLS versijų palaikymas, tik nustatoma, ar „<ph name="PRODUCT_NAME" />“ pašalins serverių, kurie negali tinkamai suderinti versijų, riktus.

      Kitu atveju, jei reikia išlaikyti suderinamumą su serveriu, kuriame yra riktų, šią politiką galima nustatyti į „tls1.1“. Tai laikina priemonė; serverį reikia greitai sutvarkyti.</translation>
<translation id="1864269674877167562">Jei ši politika nustatyta į tuščią eilutę arba yra nesukonfigūruota, „<ph name="PRODUCT_OS_NAME" />“ nerodys automatinio užbaigimo parinkties naudotojų prisijungimo eigoje.
      Jei ši politika nustatyta į eilutę, kuri nurodo domeno pavadinimą, „<ph name="PRODUCT_OS_NAME" />“ rodys automatinio užbaigimo parinktį prisijungiant ir naudotojai galės įvesti tik savo naudotojo vardą be domeno pavadinimo plėtinio. Naudotojas galės nepaisyti šio domeno pavadinimo plėtinio.</translation>
<translation id="1864382791685519617">Įgalinamas tinklo numatymas sistemoje „<ph name="PRODUCT_NAME" />“ ir naudotojams neleidžiama pakeisti šio nustatymo.

      Naudojant šią politiką valdomas išankstinis DNS pateikimas, išankstinis TCP ir SSL ryšys bei tinklalapių pateikimas.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME" />“ naudotojai negalės pakeisti ar nepaisyti šio nustatymo.

      Jei ši politika nebus nustatyta, bus įgalintas tinklo numatymas, bet naudotojas galės jį pakeisti.</translation>
<translation id="1865417998205858223">Raktų leidimai</translation>
<translation id="186719019195685253">Veiksmas, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas, veikiant iš kintamosios srovės šaltinio</translation>
<translation id="187819629719252111">Leidžiama pasiekti įrenginyje saugomus vietinius failus leidžiant „<ph name="PRODUCT_NAME" />“ pateikti failų pasirinkimo dialogo langus.

      Jei įgalinsite šį nustatymą, failų pasirinkimo dialogo langus naudotojai galės atidaryti kaip įprastai.

      Jei šio nustatymo neleisite, kaskart naudotojui atlikus veiksmą, iškviečiantį failų pasirinkimo dialogo langą (pvz., norint importuoti žymes, įkelti failus, išsaugoti nuorodas ir kt.), bus pateiktas pranešimas. Be to, programa veiks lyg naudotojas būtų spustelėjęs „Atšaukti“ failų pasirinkimo dialogo lange.

      Nenustačius šio nustatymo, failų pasirinkimo dialogo langus naudotojai galės atidaryti kaip įprastai.</translation>
<translation id="1879485426724769439">Nurodoma įrenginyje naudojama laiko juosta. Vykstant šiai sesijai naudotojai gali nepaisyti nurodytos laiko juostos. Tačiau jiems atsijungus vėl nustatoma nurodyta laiko juosta. Jei pateikta netinkama vertė, politika vis tiek suaktyvinama naudojant „GMT“. Jei paliekama tuščia eilutė, politikos nepaisoma.

      Jei ši politika nenaudojama, ir toliau bus naudojama dabartinė laiko juosta, bet naudotojai galės ją pakeisti ir šis pakeitimas bus ilgalaikis. Taigi, vieno naudotojo atliktas pakeitimas paveiks prisijungimo ekraną ir visus kitus naudotojus.

      Naujuose įrenginiuose nustatyta laiko juosta „JAV / Ramiojo vandenyno“.

      Vertės formatas atitinka laiko juostų pavadinimus, nurodytus „IANA laiko juostų duomenų bazėje“ (žr. adresu https://en.wikipedia.org/wiki/Tz_database (anglų k.). Konkrečiau kalbant, daugelio laiko juostų pavadinimus galima sukurti naudojant formatą „žemynas / didelis_miestas“ arba „vandenynas / didelis_miestas“.

      Nustačius šią politiką visiškai išjungiama automatinio laiko juostos nustatymo pagal įrenginio vietovę funkcija. Be to, nepaisoma politikos „SystemTimezoneAutomaticDetection“.</translation>
<translation id="1885782360784839335">Įgalinamas reklaminio turinio per visą skirtuką rodymas</translation>
<translation id="1888871729456797026">Debesies politikos registracijos prieigos raktas staliniuose kompiuteriuose</translation>
<translation id="1897365952389968758">Leisti visose svetainėse paleisti „JavaScript“</translation>
<translation id="1906888171268104594">Valdoma, ar naudojimo metrikos ir diagnostikos duomenų ataskaitos, įskaitant strigčių ataskaitas, teikiamos atgal į sistemą „Google“.

      Jei nustatyta kaip „true“, „<ph name="PRODUCT_OS_NAME" />“ teiks naudojimo metrikos ir diagnostikos duomenų ataskaitas.

      Jei nustatyta kaip „false“, metrikos ir diagnostikos duomenų ataskaitų teikimas bus išjungtas.

      Jei nesukonfigūruota, metrikos ir diagnostikos duomenų ataskaitos bus išjungtos netvarkomuose įrenginiuose ir įgalintos tvarkomuose įrenginiuose.</translation>
<translation id="1920046221095339924">Įrenginio valdomų seansų leidimas</translation>
<translation id="1929709556673267855">Nurodoma su įrenginiais susietų įmonės spausdintuvų konfigūracija.

      Pagal šią politiką leidžiama nurodyti „<ph name="PRODUCT_OS_NAME" />“ įrenginių spausdintuvų konfigūraciją. Toks pats formatas nurodytas „NativePrinters“ žodyne su papildomu būtinu kiekvieno spausdintuvo lauku „id“ arba „guid“, kad juos būtų galima įtraukti į baltąjį arba juodąjį sąrašą.

      Failo dydis neturi viršyti 5 MB ir failas turi būti koduotas naudojant JSON. Numatyta, kad failas, kuriame yra maždaug 21 tūkst. spausdintuvų, bus koduojamas kaip 5 MB failas. Atsisiųsto failo vientisumas patikrinamas naudojant kriptografinę maišą.

      Failas atsisiunčiamas ir išsaugomas talpykloje. Jis bus iš naujo atsisiųstas, kai pasikeis URL arba maiša.

      Jei ši politika nustatyta, „<ph name="PRODUCT_OS_NAME" />“ atsisiųs spausdintuvo konfigūracijų failą ir suteiks galimybę naudoti spausdintuvus pagal „<ph name="DEVICE_PRINTERS_ACCESS_MODE" />“, „<ph name="DEVICE_PRINTERS_WHITELIST" />“ ir „<ph name="DEVICE_PRINTERS_BLACKLIST" />“.

      Ši politika nepaveiks naudotojams suteiktos galimybės konfigūruoti spausdintuvus atskiruose įrenginiuose. Politika papildo atskirų naudotojų spausdintuvų konfigūraciją.

      Ši politika yra politikos „<ph name="BULK_PRINTERS_POLICY" />“ priedas.

      Nenustačius šios politikos, nebus įrenginių spausdintuvų ir nebus paisoma kitų „<ph name="DEVICE_PRINTERS_POLICY_PATTERN" />“ politikos nuostatų.
      </translation>
<translation id="193259052151668190">Atjungiamų USB įrenginių baltasis sąrašas</translation>
<translation id="1933378685401357864">Ekrano fono vaizdas</translation>
<translation id="1956493342242507974">Konfigūruokite maitinimo tvarkymą „<ph name="PRODUCT_OS_NAME" />“ prisijungimo ekrane.

      Pagal šią politiką leidžiama konfigūruoti, kaip „<ph name="PRODUCT_OS_NAME" />“ elgiasi, kai tam tikrą laiką naudotojas neatlieka jokių veiksmų, kol rodomas prisijungimo ekranas. Pagal politiką tvarkomi keli nustatymai. Jei norite nustatyti individualią semantiką ir verčių diapazonus, žr. atitinkamą politiką, pagal kurią tvarkomas maitinimas per sesiją. Yra tik du šios politikos nukrypimai:
      * Veiksmai, kurių bus imtasi esant neveikos būsenai arba kai uždaromas dangtis, negali būti sesijos užbaigimas.
      * Numatytasis veiksmas, atliekamas esant neveikos būsenai, kai naudojama kintamoji srovė, yra išjungimas.

      Jei nustatymas nenurodytas, naudojama numatytoji vertė.

      Jei ši politika nenustatyta, naudojami numatytieji nustatymai.</translation>
<translation id="1958138414749279167">Įgalinama „<ph name="PRODUCT_NAME" />“ automatinio pildymo funkcija ir naudotojams leidžiama automatiškai užpildyti žiniatinklio formas, naudojant anksčiau išsaugotą informaciją, pvz., adreso informaciją.

      Jei šis nustatymas išjungtas, Automatinio pildymo funkcija niekada nesiūlys ir automatiškai nepildys adreso informacijos, taip pat neišsaugos papildomos adreso informacijos, kurią naudotojas gali pateikti naršydamas žiniatinklyje.

      Jei šis nustatymas įgalintas arba vertė nenustatyta, naudotojas galės valdyti adreso informacijos Automatinio pildymo funkciją naudotojo sąsajoje.</translation>
<translation id="1960840544413786116">Ar leidžiami sertifikatai, išduoti naudojant vietinius patikimus prieraišus, kuriuose nėra plėtinio „subjectAlternativeName“</translation>
<translation id="1962273523772270623">„WebRTC“ įvykių žurnalų rinkimo iš „Google“ paslaugų leidimas</translation>
<translation id="1964634611280150550">Inkognito režimas neleidžiamas</translation>
<translation id="1964802606569741174">Ši politika neturi įtakos „Android“ skirtai „YouTube“ programai. Jei turėtų būti taikomi „YouTube“ saugos nustatymai, „Android“ skirtos „YouTube“ programos diegimas turėtų būti neleidžiamas.</translation>
<translation id="1969212217917526199">Pakeičiama nuotolinės prieigos prieglobos derinimo versijų politika.

          Vertė analizuojama kaip politikos pavadinimo JSON žodynas, susiejant su politikos verte.</translation>
<translation id="1969808853498848952">Visada paleidžiami papildiniai, kuriuos naudojant reikalinga prieigos teisė (nebenaudojama)</translation>
<translation id="1988371335297483117">Automatinį naudingųjų apkrovų „<ph name="PRODUCT_OS_NAME" />“ naujinį galima atsisiųsti naudojant HTTP, o ne HTTPS. Taip leidžiama skaidriai HTTP talpykloje saugoti HTTP atsisiuntimus.

      Jei ši politika galioja, „<ph name="PRODUCT_OS_NAME" />“ bandys atsisiųsti automatinį naudingųjų apkrovų naujinį naudodama HTTP. Jei ši politika negalioja arba yra nenustatyta, automatinis naudingųjų apkrovų naujinys bus atsisiunčiamas naudojant HTTPS.</translation>
<translation id="199764499252435679">Įgalinti „<ph name="PRODUCT_NAME" />“ komponentų naujinius</translation>
<translation id="2006530844219044261">Maitinimo valdymas</translation>
<translation id="201557587962247231">Įrenginio būsenos ataskaitų įkėlimo dažnis</translation>
<translation id="2017301949684549118">Žiniatinklio programų, kurias reikia automatiškai įdiegti, URL.</translation>
<translation id="2018836497795982119">Milisekundėmis nurodomas laikotarpis, per kurį įrenginio tvarkymo paslaugai pateikiama užklausa dėl naudotojo politikos informacijos.

      Nustačius šią politiką nepaisoma numatytosios 3 valandų vertės. Tinkamos šios politikos vertės svyruoja nuo 1 800 000 (30 minučių) iki 86 400 000 (1 diena). Vertės už šio diapazono ribų bus nustatytos į šio diapazono vertę. Jei platformoje palaikomi politikos pranešimai, atnaujinimo delsa bus nustatyta į 24 val., nes tikimasi, kad politikos pranešimai suaktyvins atnaujinimą kaskart, kai politika bus pakeista.

      Jei ši politika nebus nustatyta, „<ph name="PRODUCT_NAME" />“ naudos numatytąją vertę – 3 val.

      Atminkite, kad jei platformoje palaikomi politikos pranešimai, atnaujinimo delsa bus nustatyta į 24 val. (bus nepaisoma visų numatytųjų nustatymų ir šios politikos vertės), nes tikimasi, kad politikos pranešimai automatiškai suaktyvins atnaujinimą kaskart, kai politika bus pakeista, todėl nereikės dažniau atnaujinti.</translation>
<translation id="2024476116966025075">Būtino nuotolinės prieigos klientų domeno pavadinimo konfigūravimas</translation>
<translation id="2030905906517501646">Numatytojo paieškos teikėjo raktinis žodis</translation>
<translation id="203096360153626918">Ši politika neturi įtakos „Android“ programoms. Jas naudojant bus galima įjungti viso ekrano režimą, net jei ši politika nustatyta į „<ph name="FALSE" />“.</translation>
<translation id="2043770014371753404">Išjungti įmonės spausdintuvai</translation>
<translation id="2057317273526988987">Leisti pasiekti URL sąrašą</translation>
<translation id="206623763829450685">Nurodoma, kurios HTTP autentifikavimo schemos palaikomos „<ph name="PRODUCT_NAME" />“.

          Galimos vertės: „basic“, „digest“, „ntlm“ ir „negotiate“. Kelias vertes atskirkite kableliais.

          Nenustačius šios politikos, bus naudojamos visos keturios schemos.</translation>
<translation id="2067011586099792101">Blokuoti prieigą prie svetainių, nesančių turinio paketuose</translation>
<translation id="2073552873076775140">Leisti prisijungti prie „<ph name="PRODUCT_NAME" />“</translation>
<translation id="2077129598763517140">Kai galima, naudoti aparatinės įrangos paspartinimą</translation>
<translation id="2077273864382355561">Ekrano išjungimo delsa, kai naudojama akumuliatoriaus energija</translation>
<translation id="2082205219176343977">Konfigūruoti mažiausią leistiną įrenginio „Chrome“ versiją.</translation>
<translation id="209586405398070749">Stabilus kanalas</translation>
<translation id="2098658257603918882">Įgalinti naudojimo ir su strigtimis susijusių duomenų ataskaitų kūrimą</translation>
<translation id="2111016292707172233">Įgalinamas Paieškos palietus pasiekiamumas „<ph name="PRODUCT_NAME" />“ turinio rodinyje.

      Jei įgalinsite šį nustatymą, naudotojams bus pasiekiama Paieška palietus ir jie galės įjungti arba išjungti funkciją.

      Jei šį nustatymą išjungsite, Paieška palietus bus visiškai išjungta.

      Jei ši politika nenustatyta, ji bus tarsi įgalinta. Žr. anksčiau pateiktą aprašą.</translation>
<translation id="2113068765175018713">Apriboti įrenginio veiksenos laiką automatiškai įkeliant operacinę sistemą iš naujo</translation>
<translation id="2116790137063002724">Ši politika valdo, ar pranešti informaciją, kurią galima naudoti naudotojams identifikuoti, pvz., OS prisijungimo duomenis, „<ph name="PRODUCT_NAME" />“ profilio prisijungimo duomenis, „<ph name="PRODUCT_NAME" />“ profilio pavadinimą, „<ph name="PRODUCT_NAME" />“ profilio kelią ir „<ph name="PRODUCT_NAME" />“ vykdomąjį kelią.

      Kai ši politika nenustatyta arba nustatyta kaip „Tiesa“, informacija, kurią galima naudoti naudotojams identifikuoti, renkama.
      Kai ši politika nustatyta kaip „Netiesa“, informacija, kurią galima naudoti naudotojams identifikuoti, nerenkama.

      Ši politika galioja, tik kai įgalintas „<ph name="CHROME_REPORTING_EXTENSION_NAME" />“ ir įrenginyje užregistruota „<ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />“.</translation>
<translation id="2127599828444728326">Leisti pranešimus šiose svetainėse</translation>
<translation id="2131902621292742709">Ekrano pritemdymo delsa, kai naudojama akumuliatoriaus energija</translation>
<translation id="2132732175597591362">Valdo į baltąjį sąrašą įtrauktus URL šablonus, kur automatinis paleidimas bus visada įgalintas.

      Jei automatinis paleidimas įgalintas, sistemoje „<ph name="PRODUCT_NAME" />“ vaizdo įrašus galima leisti automatiškai (be naudotojo sutikimo) su garso turiniu.

      URL šablonas turi būti suformatuotas atsižvelgiant į gaires, pateikiamas adresu https://www.chromium.org/administrators/url-blacklist-filter-format.

      Jei politika „AutoplayAllowed“ nustatyta į „True“, ši politika neturės jokio poveikio.

      Jei politika „AutoplayAllowed“ nustatyta į „False“, bus galima leisti turinį, atitinkantį šioje politikoje nustatytus URL šablonus.

      Atminkite, kad pakeitus šią politiką veikiant „<ph name="PRODUCT_NAME" />“, ji bus taikoma tik naujuose atidarytuose skirtukuose. Todėl kai kuriuose skirtukuose gali išlikti ankstesnė elgsena.</translation>
<translation id="2134437727173969994">Leidimas užrakinti ekraną</translation>
<translation id="2137064848866899664">Jei ši politika nustatyta, kiekvienas ekranas pasukamas
      nurodyta kryptimi kiekvieną kartą paleidus įrenginį iš naujo ir pirmą kartą
      jį prijungus po politikos pasikeitimo. Naudotojai gali prisijungti ir keisti ekrano
      sukimo nustatymus nustatymų puslapyje, bet jų nustatymas bus
      pakeistas politikos verte kitą kartą paleidus įrenginį iš naujo.

      Ši politika taikoma ir pagrindiniam, ir visiems antriniams ekranams.

      Jei politika nenustatyta, numatytoji vertė yra 0 laipsnių ir naudotojas
      gali ją keisti. Tokiu atveju numatytoji vertė nėra pritaikoma iš naujo
      paleidus įrenginį iš naujo.</translation>
<translation id="214901426630414675">Spausdinimo dvipusiu režimu ribojimas</translation>
<translation id="2149330464730004005">Įgalinti spalvotą spausdinimą</translation>
<translation id="2156132677421487971">Konfigūruojama „<ph name="PRODUCT_NAME" />“ – funkcijos, kurią naudodami naudotojai gali siųsti skirtukų, svetainių ar darbalaukio turinį iš naršyklės į nuotolinius ekranus ir garso sistemas – politika.</translation>
<translation id="2166472654199325139">Nefiltruoti turinio suaugusiesiems svetainėse</translation>
<translation id="2168397434410358693">Neveikos delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="2170233653554726857">Įgalinti WPAD optimizavimą</translation>
<translation id="2176565653304920879">Kai ši politika nustatyta, automatinio laiko aptikimas bus vykdomas vienu iš toliau nurodytų būdų, atsižvelgiant į nustatymo vertę.

      Jei nustatyta į „TimezoneAutomaticDetectionUsersDecide“, naudotojai galėtų valdyti automatinį laiko juostos aptikimą naudodami įprastus valdiklius apsilankę chrome://settings.

      Jei nustatyta į „TimezoneAutomaticDetectionDisabled“, automatiniai laiko juostos valdikliai, pateikti chrome://settings, bus išjungti. Automatinis laiko juostos aptikimas visada bus išjungtas.

      Jei nustatyta į „TimezoneAutomaticDetectionIPOnly“, laiko juostos valdikliai, pateikti chrome://settings, bus išjungti. Automatinis laiko juostos aptikimas visada bus įjungtas. Laiko juostos aptikimo funkcija nustatydama vietovę naudos tik IP pagrįstą metodą.

      Jei nustatyta į „TimezoneAutomaticDetectionSendWiFiAccessPoints“, laiko juostos valdikliai, pateikti chrome://settings, bus išjungti. Automatinis laiko juostos aptikimas visada bus įjungtas. Matomų „Wi-Fi“ prieigos taškų sąrašas visada bus siunčiamas į geografinės vietovės nustatymo API serverį, kad būtų nustatyta tiksli laiko juosta.

      Jei nustatyta į „TimezoneAutomaticDetectionSendAllLocationInfo“, laiko juostos valdikliai, pateikti chrome://settings, bus išjungti. Automatinis laiko juostos aptikimas visada bus įjungtas. Vietovės informacija (pvz., „Wi-Fi“ prieigos taškai, pasiekiami mobiliojo ryšio bokštai, GPS) bus siunčiami į serverį, kad būtų nustatyta tiksli laiko juosta.

      Jei ši politika nenustatyta, aptikimas veiks taip, tarsi būtų nustatyta „TimezoneAutomaticDetectionUsersDecide“.

      Jei nustatyta politika „SystemTimezone“, ji nepaiso šios politikos. Tokiu atveju automatinis laiko juostos aptikimas visiškai išjungiamas.</translation>
<translation id="2178899310296064282">Vykdyti bent vidutiniškai ribotą režimą sistemoje „YouTube“</translation>
<translation id="2182291258410176649">Ar įgalinti atsarginį kopijavimą ir atkūrimą, nusprendžia naudotojas</translation>
<translation id="2183294522275408937">Šiuo nustatymu valdoma, kaip dažnai užrakinimo ekrane bus prašoma įvesti slaptažodį, norint toliau naudoti spartųjį atrakinimą. Kaskart įjungus užrakinimo ekraną, jei yra praėję daugiau laiko nuo paskutinio slaptažodžio įvedimo, nei nurodyta šiame nustatyme, spartusis atrakinimas nepasiekiamas įjungus užrakinimo ekraną. Jei naudotojas norės pasilikti užrakinimo ekrane praėjus šiam laikotarpiui, kitą kartą naudotojui įvedus netinkamą kodą ar pakartotinai apsilankius užrakinimo ekrane (atsižvelgiant į tai, kas įvyksta anksčiau), bus prašoma įvesti slaptažodį.

      Jei šis nustatymas sukonfigūruotas, spartųjį atrakinimą naudojančių naudotojų bus prašoma įvesti slaptažodžius užrakinimo ekrane, atsižvelgiant į šį nustatymą.

      Jei šis nustatymas nesukonfigūruotas, spartųjį atrakinimą naudojančių naudotojų bus prašoma kasdien įvesti slaptažodį užrakinimo ekrane.</translation>
<translation id="2194470398825717446">Ši politika nebenaudojama M61, vietoje jos naudokite „EcryptfsMigrationStrategy“.

      Nurodo, kaip su „ecryptfs“ pristatytas įrenginys turi elgtis, jei reikia pereiti prie „ext4“ šifruotės.

      Jei šią politiką nustatysite kaip „DisallowArc“, „Android“ programos (įskaitant jau šifruotas naudojant „ext4“) bus išjungtos ir šio įrenginio naudotojai negalės jų naudoti. Naudotojams nebus siūloma perkelti šifruotę iš „ecryptfs“ į „ext4“.

      Jei šią politiką nustatysite kaip „AllowMigration“, „ecryptfs“ pagrindinius katalogus turintiems naudotojams (šiuo metu – kai įrenginyje bus prieinama „Android N“) bus siūloma perkelti katalogus į „ext4“ šifruotę (jei prireiks).

      Ši politika netaikoma viešojo terminalo programoms, nes jos perkeliamos automatiškai. Jei politika liks nenustatyta, įrenginys elgsis taip, lyg būtų pasirinkta „DisallowArc“.</translation>
<translation id="2195032660890227692">Ši politika pašalinta „<ph name="PRODUCT_NAME" />“ 68 ir pakeista „<ph name="ARC_BR_POLICY_NAME" />“.</translation>
<translation id="2201555246697292490">Savosios susirašinėjimo pranešimais programos baltojo sąrašo konfigūravimas</translation>
<translation id="2204753382813641270">Valdyti automatinį lentynos paslėpimą</translation>
<translation id="2208976000652006649">Paieškos URL parametrai, kuriuose naudojama POST</translation>
<translation id="2214880135980649323">Kai ši politika nustatyta kaip įgalinta, pagal įmonės politiką įdiegtiems plėtiniams leidžiama naudoti įmonės aparatinės įrangos platformos API.
      Kai ši politika nustatyta kaip išjungta arba nenustatyta, jokiems plėtiniams neleidžiama naudoti įmonės aparatinės įrangos platformos API.
      Ši politika taip pat taikoma komponentų plėtiniams, pavyzdžiui, „Hangout“ paslaugų plėtiniui.</translation>
<translation id="2223598546285729819">Numatytasis pranešimų nustatymas</translation>
<translation id="2231817271680715693">Importuoti naršymo istoriją iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="2236488539271255289">Neleisti nė vienoje svetainėje nustatyti vietinių duomenų</translation>
<translation id="2240879329269430151">Leidžiama nustatyti, ar svetainėse leidžiama rodyti iššokančiuosius langus. Iššokančiųjų langų rodymas gali būti leidžiamas arba draudžiamas visose svetainėse.

          Nenustačius šios politikos, bus naudojama „Blokuoti iššokančiuosius langus“ ir naudotojas (-a) galės tai pakeisti.</translation>
<translation id="2269319728625047531">Įgalinama sutikimo sinchronizuoti pateiktis prisijungiant</translation>
<translation id="2274864612594831715">Pagal šią politiką sukonfigūruojamas virtualiosios klaviatūros kaip įvesties įrenginio įgalinimas „Chrome“ OS. Naudotojai negali nepaisyti šios politikos.

      Jei politika galioja, ekraninė virtualioji klaviatūra visada bus įgalinta.

      Jei politika negalioja, ekraninė virtualioji klaviatūra visada bus išjungta.

      Jei nustatysite šią politiką, naudotojai negalės jos pakeisti ar nepaisyti. Tačiau naudotojai vis tiek galės įgalinti / išjungti neįgaliesiems pritaikytą ekraninę klaviatūrą, kuri yra svarbesnė už pagal šią politiką kontroliuojamą virtualiąją klaviatūrą. Žr. politiką |VirtualKeyboardEnabled| ir kontroliuokite neįgaliesiems pritaikytą ekraninę klaviatūrą.

      Jei ši politika nenustatyta, iš pradžių ekraninė klaviatūra yra išjungiama, bet naudotojas ją gali bet kada įgalinti. Sprendžiant, kada pateikti klaviatūrą, taip pat gali būti naudojamos euristinės taisyklės.</translation>
<translation id="228659285074633994">Nurodoma, kiek turi praeiti laiko nuo to, kai naudotojas nieko neįveda, kad būtų rodomas įspėjamasis dialogo langas, kai naudojama kintamosios srovės energija.

          Kai ši politika nustatyta, ji nurodo, kiek laiko naudotojas turi neatlikti jokių veiksmų, kol „<ph name="PRODUCT_OS_NAME" />“ parodys įspėjamąjį dialogo langą, pranešantį, kad bus atliekamas neveikos atveju numatytas veiksmas.

          Kai ši politika nenustatyta, nerodomas joks įspėjamasis dialogo langas.

          Politikos vertė turėtų būti nurodyta milisekundėmis. Vertės apdorojamos, kad nebūtų didesnės nei neaktyvumo delsos laiko vertė.</translation>
<translation id="2292084646366244343">„<ph name="PRODUCT_NAME" />“ galima naudoti „Google“ žiniatinklio paslaugą rašybos klaidoms pašalinti. Jei šis nustatymas įgalintas, ši paslauga visada naudojama. Jei šis nustatymas neleidžiamas, ši paslauga niekada nenaudojama.

      Rašybą tikrinti vis tiek galima naudojant atsisiųstą žodyną; taikant šią politiką valdomas tik internetinės paslaugos naudojimas.

      Jei šis nustatymas nesukonfigūruotas, naudotojai gali pasirinkti, ar turėtų būti naudojama rašybos tikrinimo paslauga.</translation>
<translation id="2294382669900758280">Į vaizdo įrašų leidimą „Android“ programose neatsižvelgiama, net jei ši politika nustatyta į „<ph name="TRUE" />“.</translation>
<translation id="2298647742290373702">Konfigūruokite numatytąjį naujo skirtuko puslapį sistemoje „<ph name="PRODUCT_NAME" />“.</translation>
<translation id="2299220924812062390">Nurodyti įgalintų papildinių sąrašą</translation>
<translation id="2303795211377219696">Kredito kortelių automatinio pildymo funkcijos įgalinimas</translation>
<translation id="2309390639296060546">Numatytasis geografinės vietovės nustatymas</translation>
<translation id="2312134445771258233">Leidžiama konfigūruoti paleidžiant įkeliamus puslapius.

      Jei skiltyje „Veiksmai paleidžiant“ nepasirinksite „Atidaryti URL sąrašą“, sąrašo „Paleidžiant atidaromi URL“ turinio bus nepaisoma.</translation>
<translation id="2327252517317514801">Nurodomi domenai, kuriems leidžiama pasiekti „G Suite“</translation>
<translation id="237494535617297575">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose leidžiama pateikti pranešimus, sąrašą.

          Nenustačius šios politikos, visose svetainėse naudojama visuotinė numatytoji vertė iš politikos „Numatytasis pranešimų nustatymas“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="2386362615870139244">Leisti ekrano pažadinimo užraktus</translation>
<translation id="2411817661175306360">Įspėjimas dėl slaptažodžio apsaugos išjungtas</translation>
<translation id="2411919772666155530">Blokuoti pranešimus šiose svetainėse</translation>
<translation id="2418507228189425036">„<ph name="PRODUCT_NAME" />“ neleidžiama išsaugoti naršyklės istorijos ir naudotojams keisti šio nustatymo.

      Jei įgalinsite šį nustatymą, naršymo istorija nebus išsaugoma. Be to, nustačius šį nustatymą išjungiamas skirtukų sinchronizavimas.

     Jei šį nustatymą išjungsite arba jo nenustatysite, naršymo istorija bus išsaugoma.</translation>
<translation id="2426782419955104525">Įgalinama „<ph name="PRODUCT_NAME" />“ Intuityviosios paieškos funkcija ir naudotojams neleidžiama keisti šio nustatymo.

      Jei įgalinsite šį nustatymą, bus įgalinta „<ph name="PRODUCT_NAME" />“ Intuityvioji paieška.

      Jei išjungsite šį nustatymą, „<ph name="PRODUCT_NAME" />“ Intuityvioji paieška išjungiama.

      Jei įgalinsite arba išjungsite šį nustatymą, naudotojai negalės jo pakeisti arba nepaisyti.

      Jei šis nustatymas nenustatomas, naudotojas galės nuspręsti, ar naudoti šią funkciją, ar ne.

      Šis nustatymas pašalintas iš 29 ir naujesnių „<ph name="PRODUCT_NAME" />“ versijų.</translation>
<translation id="2433412232489478893">Ši politika valdo, ar „<ph name="PRODUCT_NAME" />“ tinklo failų bendrinimo įrenginių funkcija leidžiama naudotojui.

      Kai ši politika nesukonfigūruota arba nustatyta kaip „Tiesa“, naudotojai gali naudoti tinklo failų bendrinimo įrenginius.

      Kai ši politika nustatyta kaip „Netiesa“, naudotojai negali naudoti tinklo failų bendrinimo įrenginių.</translation>
<translation id="2438609638493026652">Įgalinamas pagrindinių įvykių ataskaitų teikimas sistemoje „Google“ diegiant „Android“ programą. Užfiksuojami tik programų, kurių diegimas suaktyvintas naudojant šią politiką, įvykiai.

      Nustačius politiką į „true“, įvykiai bus registruojami.
      Nustačius politiką į „false“ arba nenustačius, įvykiai nebus registruojami.</translation>
<translation id="244317009688098048">Įgalinti laisvuosius sparčiuosius klavišus automatiškai prisijungiant.

      Jei ši politika nenustatyta arba nustatyta kaip „Tiesa“ ir įrenginio vietinė paskyra sukonfigūruota automatiškai prisijungti be delsos, „<ph name="PRODUCT_OS_NAME" />“ leidžiami spartieji klavišai „Ctrl“ + „Alt“ + S, skirti apeiti automatinį prisijungimą ir parodyti prisijungimo ekraną.

      Jei ši politika nustatyta kaip „Netiesa“, automatinio prisijungimo be delsos (jei sukonfigūruota) apeiti negalima.</translation>
<translation id="2463365186486772703">Programos lokalė</translation>
<translation id="2466131534462628618">Fiksuotojo portalo autentifikavimas nepaiso tarpinio serverio</translation>
<translation id="2482676533225429905">Savoji susirašinėjimo pranešimais programa</translation>
<translation id="2483146640187052324">Tinklo veiksmų numatymas naudojant bet kurį tinklo ryšį</translation>
<translation id="2484208301968418871">Ši politika valdo, kaip taikomas „SafeSites“ URL filtras.
      Šiam filtrui naudojama „Google“ saugios paieškos API, norint klasifikuoti URL kaip pornografinius ar nepornografinius.

      Kai ši politika nesukonfigūruota arba nustatyta kaip „Nefiltruoti turinio suaugusiesiems svetainėje“, svetainės nefiltruojamos.

      Kai ši politika nustatyta kaip „Filtruoti turinį suaugusiesiems aukščiausio lygio svetainėse“, filtruojamos svetainės, kurios priskiriamos pornografinių svetainių kategorijai.</translation>
<translation id="2486371469462493753">Išjungiamas sertifikato skaidrumo reikalavimų taikymas nurodytiems URL.

      Taikant šią politiką leidžiama neatskleisti prieglobos serverių pavadinimų nurodytuose URL sertifikatų taikant sertifikato skaidrumą. Todėl bus leidžiama toliau naudoti sertifikatus, kurie priešingu atveju būtų nepatikimi, nes nebuvo tinkamai viešai atskleisti, bet bus sudėtingiau aptikti netinkamai naudojamus šių prieglobų sertifikatus.

      URL šablonas formatuojamas pagal https://www.chromium.org/administrators/url-blacklist-filter-format. Tačiau, kadangi sertifikatai galioja nurodytam prieglobos serverio pavadinimui, neatsižvelgiant į schemą, prievadą ar kelią, atsižvelgiama tik į URL prieglobos serverio pavadinimo dalį. Pakaitos simbolių prieglobos nepalaikomos.

      Jei politika nenustatyta, bet koks sertifikatas, kurį reikia atskleisti taikant sertifikato skaidrumą, bus laikomas nepatikimu, jei nebus atskleistas vadovaujantis sertifikato skaidrumo politika.</translation>
<translation id="2488010520405124654">Įgalinti tinklo konfigūracijos raginimą, kai esate neprisijungę.

      Jei ši politika nenustatyta arba nustatyta į „True“ ir įrenginio vietinė paskyra sukonfigūruota automatiškai prisijungti nedelsiant ir įrenginiui nesuteikta prieiga prie interneto, „<ph name="PRODUCT_OS_NAME" />“ rodomas tinklo konfigūracijos raginimas.

      Jei ši politika nustatyta į „False“, pateikiamas klaidos pranešimas vietoje tinklo konfigūracijos raginimo.</translation>
<translation id="2498238926436517902">Visada automatiškai paslėpti lentyną</translation>
<translation id="2514328368635166290">Nurodomas numatytojo paieškos teikėjo mėgstamiausios piktogramos URL.

          Ši politika pasirenkama. Nenustačius jos, jokia piktograma nebus pateikta paieškos teikėjui.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Numatytasis paieškos teikėjas įgalintas“.</translation>
<translation id="2516600974234263142">Įgalinamas spausdinimas „<ph name="PRODUCT_NAME" />“ ir naudotojams neleidžiama keisti šio nustatymo.

      Jei šis parametras įgalintas arba nekonfigūruotas, vartotojai gali spausdinti.

      Jei šis nustatymas neleidžiamas, naudotojai negali spausdinti naudodami „<ph name="PRODUCT_NAME" />“. Spausdinimas neleidžiamas naudojant veržliarakčio meniu, plėtinius, „JavaScript“ programas ir t. t. Tačiau galima spausdinti naudojant papildinius, kurie spausdina apeidami „<ph name="PRODUCT_NAME" />“. Pavyzdžiui, tam tikrų „Flash“ programų kontekstiniame meniu yra spausdinimo parinktis, kuriai netaikoma ši politika.</translation>
<translation id="2518231489509538392">Leisti paleisti garsą</translation>
<translation id="2521581787935130926">Rodyti programų spartųjį klavišą žymių juostoje</translation>
<translation id="2529880111512635313">Konfigūruoti programų ir plėtinių, kuriuos įdiegti privaloma, sąrašą</translation>
<translation id="253135976343875019">Neveikos įspėjimo delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="2536525645274582300">Ar įgalinti „Google“ vietovės paslaugas, nusprendžia naudotojas</translation>
<translation id="2550593661567988768">Tik vienpusis spausdinimas</translation>
<translation id="2552966063069741410">Laiko juosta</translation>
<translation id="2562339630163277285">Nurodomas paieškos variklio, naudoto tiesioginiams rezultatams teikti, URL. URL turi būti eilutė <ph name="SEARCH_TERM_MARKER" />, kuri pateikiant užklausą bus pakeista naudotojo jau įvestu tekstu.

          Ši politika pasirenkama. Jos nenustačius nebus pateikta jokių tiesioginių paieškos rezultatų.

          „Google“ tiesioginių rezultatų URL galima nurodyti kaip: <ph name="GOOGLE_INSTANT_SEARCH_URL" />.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Numatytasis paieškos teikėjas įgalintas“.</translation>
<translation id="2569647487017692047">Jei ši politika bus nustatyta į „False“, „<ph name="PRODUCT_OS_NAME" />“ išjungs „Bluetooth“ ir naudotojas negalės jo vėl įgalinti.

      Jei ši politika bus nustatyta į „True“ arba nenustatyta, naudotojas galės pasirinkti įgalinti arba išjungti „Bluetooth“.

      Jei ši politika nustatyta, naudotojas negali jos pakeisti ar nepaisyti.

      Kai įgalinama „Bluetooth“, naudotojas turi atsijungti ir vėl prisijungti, kad pakeitimai įsigaliotų (išjungiant „Bluetooth“, to atlikti nereikia).</translation>
<translation id="2571066091915960923">Įgalina arba išjungia duomenų glaudinimo tarpinį serverį ir neleidžia naudotojams keisti šio nustatymo.

      Jei įgalinsite arba išjungsite šį nustatymą, naudotojai negalės jo keisti ar nepaisyti.

      Jei ši politika bus nenustatyta, duomenų glaudinimo tarpinio serverio funkcija bus pasiekiama, kad naudotojas pasirinktų, ar ją naudoti.</translation>
<translation id="2587719089023392205">Nustatyti „<ph name="PRODUCT_NAME" />“ kaip numatytąją naršyklę</translation>
<translation id="2592091433672667839">Neveikos iki parodant ekrano užsklandą prisijungimo ekrane, dirbant mažmeninės prekybos režimu, trukmė</translation>
<translation id="2596260130957832043">Valdoma, ar įgalinta NTLMv2.

          Visų naujausių versijų „Samba“ ir „Windows“ serveriai palaiko NTLMv2. Tai turėtų būti išjungta tik atgalinio suderinamumo tikslais, nes suprastėja autentifikavimo sauga.

          Jei ši politika nenustatyta, numatytasis nustatymas yra „true“ ir NTLMv2 yra įgalinta.</translation>
<translation id="2598508021807251719">Konfigūruojamos lokalės, kuriose galima pateikti „<ph name="PRODUCT_OS_NAME" />“.

      Jei ši politika nustatyta, naudotojas gali konfigūruoti, kad „<ph name="PRODUCT_OS_NAME" />“ būtų pateikta tik vienoje iš lokalių, nurodytų pagal šią politiką. Jei ši politika nenustatyta arba nustatyta kaip tuščias sąrašas, „<ph name="PRODUCT_OS_NAME" />“ galima pateikti visose palaikomose NS lokalėse. Jei ši politika nustatyta kaip sąrašas su netinkamomis vertėmis, visų netinkamų verčių nepaisoma. Jei naudotojas anksčiau sukonfigūravo, kad „<ph name="PRODUCT_OS_NAME" />“ būtų pateikta pagal šią politiką neleidžiamoje lokalėje, pateikimo lokalė bus perjungta į leidžiamą NS lokalę kitą kartą naudotojui prisijungus. Jei naudotojas sukonfigūravo pageidaujamas lokales ir viena iš pageidaujamų lokalių leidžiama pagal šią politiką, „<ph name="PRODUCT_OS_NAME" />“ bus perjungta į šią lokalę. Priešingu atveju „<ph name="PRODUCT_OS_NAME" />“ bus taikoma pagal šią politiką nustatyta pirmoji tinkama vertė arba bus perjungta į atsarginę lokalę (šiuo metu „en-US“), jei šioje politikoje yra tik netinkami įrašai.</translation>
<translation id="2604182581880595781">Konfigūruojama su tinklo failų bendrinimo įrenginiu susijusi politika.</translation>
<translation id="2623014935069176671">Laukti pradinės naudotojo veiklos</translation>
<translation id="262740370354162807">Įgalinti dokumentų pateikimą „<ph name="CLOUD_PRINT_NAME" />“</translation>
<translation id="2627554163382448569">Nurodoma įmonės spausdintuvų konfigūracija.

      Pagal šią politiką leidžiama nurodyti „<ph name="PRODUCT_OS_NAME" />“ įrenginių spausdintuvų konfigūraciją. Toks pats formatas nurodytas „NativePrinters“ žodyne su papildomu būtinu kiekvieno spausdintuvo lauku „id“ arba „guid“, kad juos būtų galima įtraukti į baltąjį arba juodąjį sąrašą.

      Failo dydis neturi viršyti 5 MB ir failas turi būti koduotas naudojant JSON. Numatyta, kad failas, kuriame yra maždaug 21 tūkst. spausdintuvų, bus koduojamas kaip 5 MB failas. Atsisiųsto failo vientisumas patikrinamas naudojant kriptografinę maišą.

      Failas atsisiunčiamas ir išsaugomas talpykloje. Jis bus iš naujo atsisiųstas, kai pasikeis URL arba maiša.

      Jei ši politika nustatyta, „<ph name="PRODUCT_OS_NAME" />“ atsisiųs spausdintuvo konfigūracijų failą ir suteiks galimybę naudoti spausdintuvus pagal „<ph name="BULK_PRINTERS_ACCESS_MODE" />“, „<ph name="BULK_PRINTERS_WHITELIST" />“ ir „<ph name="BULK_PRINTERS_BLACKLIST" />“.

      Jei nustatysite šią politiką, naudotojai negalės jos pakeisti arba nepaisyti.

      Ši politika nepaveiks naudotojams suteiktos galimybės konfigūruoti spausdintuvus atskiruose įrenginiuose. Politika papildo atskirų naudotojų spausdintuvų konfigūraciją.
      </translation>
<translation id="2633084400146331575">Įgalinti ekrano skaitymą balsu</translation>
<translation id="2646290749315461919">Leidžiama nustatyti, ar svetainėse galima stebėti naudotojų fizinę vietą. Naudotojų fizinės vietos stebėjimas gali būti leidžiamas, draudžiamas pagal numatytuosius nustatymus arba naudotojo (-os) gali būti klausiama kiekvieną kartą, kai svetainėje pateikiama fizinės vietos užklausa.

          Nenustačius šios politikos bus naudojama „Klausti geografinės vietos“ ir naudotojas (-a) galės tai pakeisti.</translation>
<translation id="2647069081229792812">Įgalinti arba išjungti žymių redagavimą</translation>
<translation id="2650049181907741121">Veiksmas, kuris bus atliktas, kai naudotojas uždarys dangtelį</translation>
<translation id="2655233147335439767">Nurodomas paieškos variklio, naudojamo atliekant numatytąją paiešką, URL. URL turėtų būti eilutė „<ph name="SEARCH_TERM_MARKER" />“, kuri pateikiant užklausą bus pakeista terminais, kurių naudotojas ieško.

          „Google“ paieškos URL galima nurodyti kaip: <ph name="GOOGLE_SEARCH_URL" />.

          Ši parinktis turi būti nustatyta, kai politika „Numatytasis paieškos teikėjas įgalintas“ įgalinta, ir į ją bus atsižvelgta tik šiuo atveju.</translation>
<translation id="2659019163577049044">Įgalinus šį nustatymą, naudotojai galės nustatyti įrenginius, kad SMS pranešimai būtų sinchronizuojami iš telefonų į „Chromebook“ įrenginius. Atminkite, kad leidus šią politiką naudotojai turės aiškiai pasirinkti šią funkciją atlikdami sąrankos veiksmus. Juos atlikę naudotojai galės siųsti ir gauti SMS pranešimus „Chromebook“ įrenginiuose.

      Išjungus nustatymą, naudotojai negalės nustatyti SMS pranešimų sinchronizavimo.

      Jei ši politika nenustatyta, valdomų naudotojų numatytasis nustatymas bus „neleidžiama“, o nevaldomų naudotojų – „leidžiama“.</translation>
<translation id="2660846099862559570">Niekada nenaudoti tarpinio serverio</translation>
<translation id="2672012807430078509">NTLM kaip mažų ir vidutinio dydžio įmonių įrengimo elementų tapatybės nustatymo protokolo įgalinimo valdymas</translation>
<translation id="267596348720209223">Nurodomos paieškos teikėjo palaikomos simbolių koduotės. Koduotės – tai kodų puslapių pavadinimai, pvz., UTF-8, GB2312 ir ISO-8859-1. Jie išbandomi nurodyta tvarka.

          Ši politika pasirenkama. Jos nenustačius numatytasis nustatymas bus UTF-8.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Numatytasis paieškos teikėjas įgalintas“.</translation>
<translation id="268577405881275241">Įgalinti duomenų glaudinimo tarpinio serverio funkciją</translation>
<translation id="2693108589792503178">Slaptažodžio keitimo URL konfigūravimas.</translation>
<translation id="2731627323327011390">Neleisti naudoti „<ph name="PRODUCT_OS_NAME" />“ sertifikatų ARC programose</translation>
<translation id="2742843273354638707">Slėpti „Chrome“ internetinės parduotuvės programą ir poraštės nuorodą Naujo skirtuko puslapyje ir „<ph name="PRODUCT_OS_NAME" />“ programų paleidimo priemonėje.

      Kai ši politika yra galiojanti, piktogramos yra slepiamos.

      Kai ši politika negalioja arba nesukonfigūruota, piktogramos yra matomos.</translation>
<translation id="2744751866269053547">Registro protokolo doroklės</translation>
<translation id="2746016768603629042">Ši politika nebenaudojama, vietoj jos naudokite „DefaultJavaScriptSetting“.

      Galima naudoti norint „<ph name="PRODUCT_NAME" />“ išjungti „JavaScript“.

      Jei šis nustatymas išjungtas, tinklalapiuose nebus galima naudoti „JavaScript“ ir naudotojas negalės pakeisti to nustatymo.

      Jei šis nustatymas įgalintas ar nenustatytas, tinklalapiuose bus galima naudoti „JavaScript“, bet naudotojas galės pakeisti tą nustatymą.</translation>
<translation id="2753637905605932878">„WebRTC“ naudojamų vietinių UDP prievadų diapazono apribojimas</translation>
<translation id="2755385841634849932">Pagal šią politiką valdomas „Android“ atsarginio kopijavimo ir atkūrimo pasiekiamumas.

      Kai ši politika nesukonfigūruota arba nustatyta kaip „<ph name="BR_DISABLED" />“, „Android“ atsarginis kopijavimas ir atkūrimas išjungtas ir naudotojas jo įgalinti negali.

      Kai ši politika nustatyta kaip „<ph name="BR_UNDER_USER_CONTROL" />“, naudotojo prašoma pasirinkti, ar naudoti „Android“ atsarginį kopijavimą ir atkūrimą. Naudotojui juos įgalinus, „Android“ programos duomenys įkeliami į „Android“ atsarginių kopijų serverius ir pakartotinai diegiant suderinamas programas yra atkuriami iš šių serverių.</translation>
<translation id="2757054304033424106">Leidžiami įdiegti plėtinių / programų tipai</translation>
<translation id="2759224876420453487">Tvarkyti naudotojo elgseną kelių profilių seanse</translation>
<translation id="2761483219396643566">Neveikos įspėjimo delsa, kai naudojama akumuliatoriaus energija</translation>
<translation id="2762164719979766599">Nurodomas vietinių įrenginio paskyrų sąrašas, kuris bus rodomas prisijungimo ekrane.

      Kiekvienas sąrašo įrašas nurodo identifikatorių, naudojamą vidiniais tikslais siekiant atskirti skirtingas vietines įrenginio paskyras.</translation>
<translation id="2769952903507981510">Konfigūruoti reikiamą nuotolinės prieigos prieglobų domeno pavadinimą</translation>
<translation id="2787173078141616821">Informacijos apie „Android“ būseną ataskaita</translation>
<translation id="2799297758492717491">Leisti automatinį medijos, atitinkančios į baltąjį sąrašą įtrauktus URL šablonus, paleidimą</translation>
<translation id="2801230735743888564">Leidžiama naudotojams žaisti dinozaurų Velykų kiaušinių žaidimą, kai įrenginys neprijungtas prie interneto.

      Jei ši politika nustatyta į „False“, naudotojai negali žaisti dinozaurų Velykų kiaušinių žaidimo, kai įrenginys neprijungtas prie interneto. Jei šis nustatymas nustatytas į „True“, naudotojams leidžiama žaisti dinozaurų žaidimą. Jei ši politika nenustatyta, naudotojams neleidžiama žaisti dinozaurų Velykų kiaušinių žaidimo užregistruotoje „Chrome“ OS, bet leidžiama žaisti kitomis aplinkybėmis.</translation>
<translation id="2802085784857530815">Leidžiama valdyti, ar naudotojai gali pasiekti ne įmonės spausdintuvus

      Jei politika nustatyta į „True“ arba visai nenustatyta, naudotojai galės pridėti ir konfigūruoti savuosius spausdintuvus bei jais spausdinti.

      Jei politika nustatyta į „False“, naudotojai negalės pridėti ir konfigūruoti savųjų spausdintuvų. Jie taip pat negalės spausdinti anksčiau sukonfigūruotais savaisiais spausdintuvais.
      </translation>
<translation id="2805707493867224476">Leisti visose svetainėse rodyti iššokančiuosius langus</translation>
<translation id="2808013382476173118">Įgalinamas STUN serverių naudojimas, kai nuotolinės programos bando užmegzti ryšį su šiuo įrenginiu.

          Jei šis nustatymas įgalintas, nuotolinės programos gali rasti šį įrenginį ir prie jo prisijungti, net jei jos atskirtos taikant užkardą.

          Jei šis nustatymas neleidžiamas ir išeinantys UDP ryšiai filtruojami taikant užkardą, šiame įrenginyje leidžiami tik ryšiai iš klientų įrenginių vietiniame tinkle.

          Nenustačius šios politikos nustatymas bus įgalintas.</translation>
<translation id="2823870601012066791">„<ph name="PRODUCT_OS_NAME" />“ klientų „Windows“ registro vieta:</translation>
<translation id="2824715612115726353">Įgalinti inkognito režimą</translation>
<translation id="2838830882081735096">Neleisti perkelti duomenų ir ARC</translation>
<translation id="2839294585867804686">Tinklo failų bendrinimo įrenginių nustatymai</translation>
<translation id="2840269525054388612">Nurodomi spausdintuvai, kuriuos gali naudoti naudotojas.

      Ši politika naudojama, tik jei pasirinktas politikos „<ph name="DEVICE_PRINTERS_ACCESS_MODE" />“ nustatymas „<ph name="PRINTERS_WHITELIST" />“

      Jei ši politika naudojama, naudotojui pasiekiami tik spausdintuvai, kurių ID atitinka šioje politikoje nurodytas vertes. ID turi atitikti laukus „id“ arba „guid“ faile, kuris nurodytas „<ph name="DEVICE_PRINTERS_POLICY" />“.
      </translation>
<translation id="285480231336205327">Įgalinti didelio kontrasto būseną</translation>
<translation id="2854919890879212089">Kaip numatytoji funkcijos „Spaudinio peržiūra“ parinktis „<ph name="PRODUCT_NAME" />“ naudojamas sistemos numatytasis spausdintuvas, o ne pastarasis naudotas spausdintuvas.

      Išjungus šį nustatymą arba nenustačius vertės, funkcija „Spaudinio peržiūra“ naudos pastarąjį naudotą spausdintuvą kaip numatytąją paskirties vietos parinktį.

      Įjungus šį nustatymą funkcija „Spaudinio peržiūra“ naudos OS sistemos numatytąjį spausdintuvą kaip numatytąją paskirties vietos parinktį.</translation>
<translation id="2856674246949497058">Grąžinti ir palikti tikslinę versiją, jei OS versija naujesnė nei tikslinė. Atlikti „Powerwash“ vykdant procesą.</translation>
<translation id="2872961005593481000">Stabdyti</translation>
<translation id="2873651257716068683">Nepaisoma numatytojo spausdinamo puslapio dydžio. Jei puslapio dydis nepasiekiamas, šios politikos nepaisoma.</translation>
<translation id="2874209944580848064">„<ph name="PRODUCT_OS_NAME" />“ įrenginiams, kuriuose palaikomos „Android“ programos, skirta pastaba:</translation>
<translation id="2877225735001246144">Neleisti CNAME paieškos vykdant „Kerberos“ tapatumo nustatymą</translation>
<translation id="2890645751406497668">Šioms svetainėms automatiškai suteikiamas leidimas prisijungti prie nurodyto gamintojo USB įrenginių, turinčių nurodytus produkto ID.</translation>
<translation id="2892414556511568464">Apribojamas spausdinimas dvipusiu režimu. Jei politika nenustatyta ar nenurodyta vertė, netaikomas joks apribojimas.</translation>
<translation id="2893546967669465276">Sistemos žurnalų siuntimas valdymo serveriui</translation>
<translation id="2899002520262095963">„Android“ programos gali naudoti šioje politikoje nustatytas tinklo konfigūracijas ir CA sertifikatus, bet negali pasiekti kai kurių konfigūravimo parinkčių.</translation>
<translation id="290002216614278247">Galima užrakinti naudotojo sesiją atsižvelgiant į kliento laiką arba išnaudotą dienos kvotą.

          |time_window_limit| nurodo laikotarpį, per kurį naudotojo sesija turi būti užrakinta. Palaikoma tik viena kiekvienos savaitės dienos taisyklė, todėl masyvo |entries| dydis gali būti nuo 0 iki 7. |starts_at| ir |ends_at| yra laikotarpio pradžios ir pabaigos apribojimai. Kai |ends_at| vertė yra mažesnė nei |starts_at|, tai reiškia, kad |time_limit_window| baigsis kitą dieną. |last_updated_millis| yra UTC laiko žymė, nurodanti, kada šis įrašas buvo paskutinį kartą atnaujintas; ji siunčiama kaip eilutė, nes laiko žymei nepakanka sveikųjų skaičių.

          |time_usage_limit| nurodo dienos įrenginio naudojimo kvotą. Ją pasiekus, naudotojo sesija užrakinama. Kiekvienai savaitės dienai priskirta savybė, kuri turi būti nustatyta tik jei tą dieną kvota yra aktyvi. |usage_quota_mins| – tai laikotarpis, kuriuo tvarkomas įrenginys gali būti naudojamas per dieną, o |reset_at| – laikas, kada atnaujinami naudojimo kvotos duomenys. Numatytoji |reset_at| vertė yra vidurnaktis ({'hour': 0, 'minute': 0}). |last_updated_millis| yra UTC laiko žymė, nurodanti, kada šis įrašas buvo paskutinį kartą atnaujintas; ji siunčiama kaip eilutė, nes laiko žymei nepakanka sveikųjų skaičių.

          |overrides| teikiama siekiant laikinai nustatyti, kad viena ar daugiau ankstesnių taisyklių negaliotų.
          * Jei nei „time_window_limit“, nei „time_usage_limit“ nėra aktyvūs, |LOCK| galima naudoti įrenginiui užrakinti.
          * |LOCK| laikinai užrakina naudotojo sesiją, kol prasideda kitas „time_window_limit“ arba „time_usage_limit“ laikotarpis.
          * |UNLOCK| atrakina naudotojo sesiją atėjus „time_window_limit“ arba „time_usage_limit“ laikotarpiui.
          |created_time_millis| – tai UTC laiko žymė, skirta nepaisymams kurti, siunčiama kaip eilutė, nes laiko žymei nepakanka sveikųjų skaičių. Ji naudojama siekiant nustatyti, ar šis nepaisymas vis dar turi būti taikomas. Jei dabartinio aktyvaus laiko apribojimo funkcija (naudojimo laiko arba laikotarpio apribojimas) pradėta taikyti sukūrus nepaisymą, ši žymė negalioja. Be to, jei nepaisymas sukurtas prieš paskutinį aktyvaus „time_window_limit“ arba „time_usage_window“ laikotarpio pakeitimą, laiko žymė nebus taikoma.</translation>
<translation id="2906874737073861391">„Programų paketo“ plėtinių sąrašas</translation>
<translation id="2907992746861405243">Valdoma, kurie spausdintuvai iš „<ph name="BULK_PRINTERS_POLICY" />“ pasiekiami naudotojams.

      Nustatoma, kuri pasiekiamumo politika naudojama masinei spausdintuvų konfigūracijai. Jei pasirinkta „<ph name="PRINTERS_ALLOW_ALL" />“, rodomi visi spausdintuvai. Jei pasirinkta „<ph name="PRINTERS_BLACKLIST" />“, „<ph name="BULK_PRINTERS_BLACKLIST" />“ naudojama pasiekiamumui prie nurodytų spausdintuvų apriboti. Jei pasirinkta „<ph name="PRINTERS_WHITELIST" />“, „<ph name="BULK_PRINTERS_WHITELIST" />“ nustato tik tuos spausdintuvus, kuriuos galima pasirinkti.

      Jei ši politika nenustatyta, taikoma „<ph name="PRINTERS_ALLOW_ALL" />“.
      </translation>
<translation id="2908277604670530363">Didžiausias jungčių prie tarpinio serverio vienu metu skaičius</translation>
<translation id="2956777931324644324">Ši politika nebenaudojama nuo 36 versijos „<ph name="PRODUCT_NAME" />“.

      Nurodoma, ar TLS domeno sertifikatų plėtinys turėtų būti įgalintas.

      Šis nustatymas naudojamas TLS domeno sertifikatų plėtiniui įgalinti bandymo tikslais. Ateityje šis eksperimentinis nustatymas bus pašalintas.</translation>
<translation id="2957506574938329824">Neleisti jokiai svetainei pateikti užklausos pasiekti „Bluetooth“ įrenginių naudojant „Web Bluetooth“ API</translation>
<translation id="2957513448235202597"><ph name="HTTP_NEGOTIATE" /> autentifikavimo paskyros tipas</translation>
<translation id="2959898425599642200">Tarpinio serverio apėjimo taisyklės</translation>
<translation id="2960128438010718932">Naujinio etapinio pritaikymo tvarkaraštis</translation>
<translation id="2960691910306063964">Nuotolinės prieigos prieglobų autentifikavimo be PIN kodo įjungimas arba išjungimas</translation>
<translation id="2976002782221275500">Nurodoma laiko trukmė be naudotojo įvesties, po kurios ekranas pritemdomas, kai naudojama akumuliatoriaus energija.

          Kai šios politikos vertė yra didesnė už nulį, ji nurodo laiko trukmę, kurią naudotojas turi neatlikti jokių veiksmų, kol „<ph name="PRODUCT_OS_NAME" />“ pritemdys ekraną.

          Kai politika nustatyta į nulį, „<ph name="PRODUCT_OS_NAME" />“ nepritemdo ekrano, jei naudotojas neatlieka jokių veiksmų.

          Kai ši politika nenustatyta, naudojama numatytoji laiko trukmė.

          Politikos vertė turėtų būti nurodyta milisekundėmis. Vertės sumažinamos, kad neviršytų ekrano išjungimo delsos laiko (jei jis nustatytas) ar neveikos delsos laiko arba būtų jam lygios.</translation>
<translation id="2987155890997901449">ARC įgalinimas</translation>
<translation id="2987227569419001736">Valdyti „Web Bluetooth“ API naudojimą</translation>
<translation id="3016255526521614822">Įtraukti į baltąjį sąrašą užrašų programas, kurios leidžiamos „<ph name="PRODUCT_OS_NAME" />“ užrakinimo ekrane</translation>
<translation id="3021562480854470924">Ankstesnių versijų, kurias leidžiama grąžinti, skaičius</translation>
<translation id="3030000825273123558">Įgalinti metrikos ataskaitų teikimą</translation>
<translation id="3034580675120919256">Leidžiama nustatyti, ar svetainėse leidžiama paleisti „JavaScript“. Gali būti leidžiama arba draudžiama paleisti „JavaScript“ visose svetainėse.

          Nenustačius šios politikos, bus naudojama „Leisti „JavaScript“ ir naudotojas (-a) galės tai pakeisti.</translation>
<translation id="3038323923255997294">Uždarius „<ph name="PRODUCT_NAME" />“ toliau leisti fonines programas</translation>
<translation id="3046192273793919231">Tinklo paketų siuntimas į valdymo serverį, siekiant stebėti prisijungimo būseną</translation>
<translation id="3047732214002457234">„Chrome“ valymo įrankio duomenų ataskaitų teikimo „Google“ valdymas</translation>
<translation id="3048744057455266684">Jei ši politika yra nustatyta ir paieškos URL, pasiūlyto „Omnibox“, užklausos eilutėje ar fragmento identifikatoriuje yra šis parametras, pasiūlyme bus rodomi paieškos terminai ir paieškos teikėjas, o ne tiesiog paieškos URL.

          Ši politika yra pasirenkama. Jei ji nebus nustatyta, paieškos terminas nebus pakeistas.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Įgalintas numatytasis paieškos teikėjas“.</translation>
<translation id="306887062252197004">Pagal šią politiką „WebDriver“ funkcijos naudotojai gali perrašyti
      politikos nuostatas, kurios gali trikdyti vykdomą operaciją.

      Šiuo metu ši politika išjungia politikos nuostatas „SitePerProcess“ ir „IsolateOrigins“.

      Jei politika bus įgalinta, „WebDriver“ galės perrašyti nesuderinamas
      politikos nuostatas.
      Jei politika bus išjungta arba nesukonfigūruota, „WebDriver“ nebus leidžiama
      perrašyti nesuderinamų politikos nuostatų.</translation>
<translation id="3069958900488014740">Leidžiama išjungti WPAD (žiniatinklio tarpinio serverio automatinį aptikimą, angl. „Web Proxy Auto-Discovery“) optimizavimą sistemoje „<ph name="PRODUCT_NAME" />“.

      Nustačius šią politiką į „false“, WPAD optimizavimas išjungiamas, todėl „<ph name="PRODUCT_NAME" />“ reikia ilgiau laukti DNS pagrindu veikiančių WPAD serverių. Jei politika nenustatoma arba įgalinama, WPAD optimizavimas įgalinamas.

      Neatsižvelgiant į tai, ar ši politika nustatyta ir kaip ji nustatyta, WPAD optimizavimo nustatymo negali keisti naudotojai.</translation>
<translation id="3072045631333522102">Naudotina prisijungimo ekrano užsklanda dirbant mažmeninės prekybos režimu</translation>
<translation id="3072847235228302527">Nustatyti vietinės įrenginio paskyros paslaugų teikimo sąlygas</translation>
<translation id="3077183141551274418">Įgalinama arba išjungiama skirtukų naudojimo trukmė</translation>
<translation id="3086995894968271156">Konfigūruokite „Cast Receiver“ politiką „<ph name="PRODUCT_NAME" />“.</translation>
<translation id="3088796212846734853">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose leidžiama pateikti vaizdus, sąrašą.

          Nenustačius šios politikos, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultImagesSetting“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.

          Atkreipkite dėmesį, kad anksčiau ši politika per klaidą buvo įgalinta „Android“, bet ši funkcija šioje platformoje niekada nebuvo visiškai palaikoma.</translation>
<translation id="3096595567015595053">Įgalintų papildinių sąrašas</translation>
<translation id="3101501961102569744">Pasirinkti, kaip nurodyti tarpinio serverio nustatymus</translation>
<translation id="3117676313396757089">Įspėjimas: DHE bus visiškai pašalinta iš „<ph name="PRODUCT_NAME" />“ įdiegus 57 versiją (maždaug 2017 m. kovo mėn.) ir ši politika nebegalios.

      Jei politika nenustatyta arba nustatyta į „false“, TLS DHE šifruotieji programų komplektai nebus įgalinti. Priešingu atveju ją galima nustatyti į „true“, kad būtų įgalinti DHE šifruotieji programų komplektai ir išsaugotas suderinamumas su pasenusiu serveriu. Tai laikina priemonė; serverį reikia iš naujo sukonfigūruoti.

      Serverius raginama perkelti į ECDHE šifruotuosius programų komplektus. Jei jie nepasiekiami, įsitikinkite, kad įgalintas šifruotasis programų komplektas, kuriam naudojami RSA rakto mainai.</translation>
<translation id="316778957754360075">Šis nustatymas nebenaudojamas 29 ir naujesnėse „<ph name="PRODUCT_NAME" />“ versijose. Rekomenduojamas būdas nustatyti organizacijos valdomą plėtinių / programų rinkinius yra įtraukti svetaines priglobiančius CRX paketus į politiką „ExtensionInstallSources“ ir nuorodas įdėti tiesiogiai į tinklalapio paketus. Tam tinklalapiui skirtą paleidimo priemonę galima sukurti naudojant politiką „ExtensionInstallForcelist“.</translation>
<translation id="3171369832001535378">Įrenginio tinklo prieglobos serverio pavadinimo šablonas</translation>
<translation id="3185009703220253572">nuo <ph name="SINCE_VERSION" /> versijos</translation>
<translation id="3187220842205194486">„Android“ negali pasiekti įmonės raktų. Ši politika jiems neturi įtakos.</translation>
<translation id="3201273385265130876">Leidžiama nurodyti „<ph name="PRODUCT_NAME" />“ naudojamą tarpinį serverį ir naudotojams neleidžiama pakeisti tarpinio serverio nustatymų.

          Jei pasirinksite niekada nenaudoti tarpinio serverio ir visada prisijungti tiesiogiai, visų kitų parinkčių bus nepaisoma.

          Jei pasirinksite naudoti sistemos tarpinio serverio nustatymus, visų kitų nustatymų bus nepaisoma.

          Jei pasirinksite automatiškai aptikti tarpinį serverį, visų kitų parinkčių bus nepaisoma.

          Jei pasirinksite fiksuoto tarpinio serverio režimą, galėsite nurodyti kitus nustatymus pasirinkę „Tarpinio serverio adresą ir URL“ ir „Kableliais atskirtų tarpinio serverio nepaisymo taisyklių sąrašą“. Tik aukščiausio prioriteto HTTP tarpinis serveris pasiekiamas ARC programose.

          Jei pasirinksite naudoti .pac tarpinio serverio scenarijų, turėsite nurodyti URL pasirinkę „Tarpinio serverio .pac failo URL“.

          Išsamių pavyzdžių galite rasti apsilankę adresu
          <ph name="PROXY_HELP_URL" />.

          Jei įgalinsite šį nustatymą, „<ph name="PRODUCT_NAME" />“ ir ARC programos nepaisys visų komandinėje eilutėje nurodytų tarpinio serverio parinkčių.

          Jie šią politiką paliksite nenustatytą, naudotojai galės patys pasirinkti tarpinio serverio nustatymus.</translation>
<translation id="3205825995289802549">Pirmo naršyklės lango padidinimas pirmą kartą paleidus programą</translation>
<translation id="3211426942294667684">Prisijungimo prie naršyklės nustatymai</translation>
<translation id="3213821784736959823">Valdoma, ar integruota DNS kliento programa naudojama „<ph name="PRODUCT_NAME" />“.

      Jei ši politika aktyvinta, esant galimybei integruota DNS kliento programa bus naudojama.

      Jei ši politika deaktyvinta, integruota DNS kliento programa niekada nebus naudojama.

      Jei ši politika nenustatyta, naudotojai galės pakeisti, ar integruota DNS kliento programa naudojama, redaguodami chrome://flags arba nurodydami komandų eilutės žymą.</translation>
<translation id="3214164532079860003">Pagal šią politiką pagrindinis puslapis priverstinai importuojamas iš esamos numatytosios naršyklės (jei įgalinta).

      Jei neleidžiama, pagrindinis puslapis neimportuojamas.

      Jei jis nenustatytas, naudotojo gali būti paklausta, ar importuoti, arba gali būti automatiškai pradėta importuoti.</translation>
<translation id="3219421230122020860">Inkognito režimas pasiekiamas</translation>
<translation id="3220624000494482595">Jei viešojo terminalo programa yra „Android“ programa, ji negalės valdyti „<ph name="PRODUCT_OS_NAME" />“ versijos, net jei ši politika nustatyta į „<ph name="TRUE" />“.</translation>
<translation id="3236046242843493070">URL šablonai, kuriuos naudojant galima įdiegti plėtinį, programą ir naudotojo scenarijų iš</translation>
<translation id="3240609035816615922">Spausdintuvų konfigūracijos pasiekiamumo politika.</translation>
<translation id="3243309373265599239">Nurodoma laiko trukmė be naudotojo įvesties, po kurios ekranas pritemdomas, kai naudojama kintamosios srovės energija.

          Kai šios politikos vertė yra didesnė už nulį, ji nurodo laiko trukmę, kurią naudotojas turi neatlikti jokių veiksmų, kol „<ph name="PRODUCT_OS_NAME" />“ pritemdys ekraną.

          Kai politika nustatyta į nulį, „<ph name="PRODUCT_OS_NAME" />“ nepritemdo ekrano, kai naudotojas neatlieka jokių veiksmų.

          Kai ši politika nenustatyta, naudojama numatytoji laiko trukmė.

          Politikos vertė turėtų būti nurodyta milisekundėmis. Vertės sumažinamos, kad neviršytų ekrano išjungimo delsos laiko (jei jis nustatytas) ar neveikos delsos laiko arba būtų jam lygios.</translation>
<translation id="3264793472749429012">Numatytojo paieškos teikėjo koduotės</translation>
<translation id="3273221114520206906">Numatytasis „JavaScript“ nustatymas</translation>
<translation id="3284094172359247914">„WebUSB“ API naudojimo valdymas</translation>
<translation id="3288595667065905535">Išleidimo kanalas</translation>
<translation id="3292147213643666827">„<ph name="PRODUCT_NAME" />“ įgalinamas veikti kaip įgaliotasis serveris, siejantis „<ph name="CLOUD_PRINT_NAME" />“ ir senesnius prie kompiuterio prijungtus spausdintuvus.

      Jei įgalinsite šį nustatymą arba jo nekonfigūruosite, naudotojai galės įgalinti spausdinimo iš debesies įgaliotąjį serverį, tapatumą nustatydami pagal savo „Google“ paskyrą.

      Jei šio nustatymo neleisite, naudotojai negalės įgalinti tarpinio serverio, o kompiuteriui bus neleidžiama bendrinti prijungtų spausdintuvų su „<ph name="CLOUD_PRINT_NAME" />“.</translation>
<translation id="3307746730474515290">Valdoma, kokių tipų programas / plėtinius leidžiama įdiegti, ir apribojama vykdymo laiko prieiga.

          Šis nustatymas į baltąjį sąrašą įtraukia programų / plėtinių, kuriuos galima įdiegti „<ph name="PRODUCT_NAME" />“ tipus, ir prieglobas, su kuriomis jie gali sąveikauti. Vertė yra šių eilučių sąrašas: „plėtinys“, „tema“, „naudotojo_scenarijus“, „priglobta_programa“, „sena_supakuota_programa“, „platformos_programa“. Jei reikia daugiau informacijos apie šiuos tipus, žr. „<ph name="PRODUCT_NAME" />“ plėtinių dokumentaciją.

          Atminkite, kad ši politika taip pat turi įtakos programoms ir plėtiniams, kurie bus priverstinai įdiegti naudojant „ExtensionInstallForcelist“.

          Jei šis nustatymas nesukonfigūruotas, programos / plėtiniai, kurių tipas nėra įtrauktas į sąrašą, nebus įdiegti.

          Jei šis nustatymas nesukonfigūruotas, nebus priverstinai vykdomi jokie priimtinų plėtinių / programų tipų apribojimai.</translation>
<translation id="3322771899429619102">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose leidžiama naudoti rakto generavimą, sąrašą. Jei URL šablonas yra politikoje „KeygenBlockedForUrls“, šių išimčių nepaisoma.

          Nenustačius šios politikos visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultKeygenSetting“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="332771718998993005">Pavadinimo, reklamuojamo kaip „<ph name="PRODUCT_NAME" />“ paskirties vieta, nustatymas.

          Jei ši politika nustatyta kaip ne tuščia eilutė, ta eilutė bus naudojama kaip „<ph name="PRODUCT_NAME" />“ paskirties vietos pavadinimas. Kitu atveju paskirties vietos pavadinimas bus įrenginio pavadinimas. Jei ši politika nenustatyta, paskirties vietos pavadinimas bus įrenginio pavadinimas, o įrenginio savininkas (arba naudotojas iš domeno, kuriame tvarkomas įrenginys) galės jį pakeisti. Pavadinimas ribojamas iki 24 simbolių.</translation>
<translation id="3335468714959531450">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose leidžiama nustatyti slapukus, sąrašą.

          Nenustačius šios politikos, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultCookiesSetting“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.

          Taip pat žiūrėkite politikas „CookiesBlockedForUrls“ ir „CookiesSessionOnlyForUrls“. Atminkite, kad negali būti nesuderinamų šių trijų politikų URL šablonų, nes nenurodyta, kuriai politikai teikiama pirmenybė.</translation>
<translation id="3373364525435227558">Nustatoma mažiausiai viena rekomenduojama valdomų sesijų lokalė, leidžiant naudotojams lengvai pasirinkti vieną iš šių lokalių.

      Naudotojas gali pasirinkti lokalę ir klaviatūros išdėstymą prieš pradėdamas valdomą sesiją. Pagal numatytuosius nustatymus visos „<ph name="PRODUCT_OS_NAME" />“ palaikomos lokalės išdėstytos abėcėlės tvarka. Galite naudoti šią politiką, kad perkeltumėte rekomenduojamų lokalių rinkinį į sąrašo viršų.

      Nenustačius šios politikos bus iš anksto pasirinkta dabartinė NS lokalė.

      Nustačius šią politiką rekomenduojamos lokalės bus perkeltos į sąrašo viršų ir vizualiai atskirtos nuo visų kitų lokalių. Rekomenduojamos lokalės bus pateiktos ta tvarka, kuria rodomos politikoje. Pirmoji rekomenduojama lokalė bus iš anksto pasirinkta.

      Jei yra kelios rekomenduojamos lokalės, daroma prielaida, kad naudotojai norės pasirinkti iš šių lokalių. Pradedant valdomą sesiją bus aiškiai siūloma pasirinkti lokalę ir klaviatūros išdėstymą. Priešingu atveju manoma, kad dauguma naudotojų norės naudoti iš anksto pasirinktą lokalę. Pradedant valdomą sesiją nebus taip aiškiai siūloma pasirinkti lokalės ir klaviatūros išdėstymo.

      Nustačius šią politiką ir įgalinus automatinį prisijungimą (žr. politiką |DeviceLocalAccountAutoLoginId| ir |DeviceLocalAccountAutoLoginDelay|), automatiškai pradėtoje valdomoje sesijoje bus naudojama pirmoji rekomenduojama lokalė ir populiariausias šią lokalę atitinkantis klaviatūros išdėstymas.

      Visada iš anksto bus pasirenkamas iš anksto pasirinktą lokalę atitinkantis populiariausias klaviatūros išdėstymas.

      Šią politiką galima nustatyti tik kaip rekomenduojamą. Galite naudoti šią politiką, kad perkeltumėte rekomenduojamų lokalių rinkinį į viršų, bet naudotojams visada leidžiama sesijai pasirinkti bet kurią „<ph name="PRODUCT_OS_NAME" />“ palaikomą lokalę.
      </translation>
<translation id="3381968327636295719">Pagal numatytuosius nustatymus naudoti prieglobos naršyklę</translation>
<translation id="3414260318408232239">Jei ši politika nesukonfigūruota, „<ph name="PRODUCT_NAME" />“ naudos numatytosios minimalios 1.0 versijos TLS.

      Kitaip gali būti nustatyta viena iš šių verčių: „tls1“, „tls1.1“ arba „tls1.2“. Nustačius šią politiką „<ph name="PRODUCT_NAME" />“ nenaudos senesnės nei nurodytos versijos SSL / TLS. Neatpažįstamos vertės bus nepaisoma.</translation>
<translation id="3417418267404583991">Jei ši politika nustatyta į „true“ (tiesa) arba nesukonfigūruota, „<ph name="PRODUCT_OS_NAME" />“ įgalinami svečių prisijungimai. Svečių prisijungimai – tai anoniminės naudotojų sesijos ir nereikalaujama slaptažodžio.

      Jei ši politika nustatyta į „false“ (netiesa), „<ph name="PRODUCT_OS_NAME" />“ neleidžiama pradėti svečio sesijų.</translation>
<translation id="3418871497193485241">Vykdomas minimalus ribotas režimas sistemoje „YouTube“ ir neleidžiama naudotojams
      pasirinkti mažiau riboto režimo.

      Nustačius šį nustatymą į „Griežtas“, sistemoje „YouTube“ visada aktyvus griežtai ribotas režimas.

      Nustačius šį nustatymą į „Vidutiniškas“, naudotojas gali pasirinkti tik vidutiniškai ribotą
      ir griežtai ribotą režimus sistemoje „YouTube“, bet negali išjungti riboto režimo.

      Nustačius šį nustatymą į „Išjungta“ arba nenustačius jokios vertės, „<ph name="PRODUCT_NAME" />“ nevykdo riboto režimo sistemoje „YouTube“. Taikant išorinę politiką, pvz., „YouTube“ politiką, ribotą režimą vis tiek gali reikėti vykdyti.</translation>
<translation id="3428247105888806363">Įgalinti tinklo prognozę</translation>
<translation id="3437924696598384725">Leidimas naudotojams tvarkyti VPN ryšius</translation>
<translation id="3449886121729668969">Sukonfigūruojami „<ph name="PRODUCT_NAME" />“ tarpinio serverio nustatymai. Šie tarpinio serverio nustatymai bus pasiekiami ir ARC programoms.

      Ši politika dar neparengta naudoti, nenaudokite jos.</translation>
<translation id="3460784402832014830">Nurodomas URL, kurį paieškos variklis naudoja, kad pateiktų naujo skirtuko puslapį.

          Ši politika pasirenkama. Jei ji nenustatyta, nebus pateikiamas jos naujo skirtuko puslapis.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „DefaultSearchProviderEnabled“.</translation>
<translation id="346731943813722404">Nurodo, ar energijos valdymo delsa ir seanso ilgio apribojimas turėtų būti suaktyvinti tik naudotojui pradėjus seanso veiklą.

          Jei ši politika nustatyta į „True“, energijos valdymo delsa ir seanso ilgio apribojimas nesuaktyvinami, kol naudotojas nepradeda seanso veiklos.

          Jei ši politika nustatyta į „False“, energijos valdymo delsa ir seanso ilgio apribojimas suaktyvinami iškart pradėjus seansą.</translation>
<translation id="3478024346823118645">Ištrinti naudotojo duomenis atsijungiant</translation>
<translation id="348495353354674884">Įgalinti virtualiąją klaviatūrą</translation>
<translation id="3487623755010328395">
        Nustačius šią politiką, „<ph name="PRODUCT_NAME" />“ bandys užsiregistruoti ir taikyti susijusią debesies politiką visiems profiliams.

        Šios politikos vertė yra registracijos prieigos raktas, kurį galima gauti iš „Google“ administratoriaus pulto.</translation>
<translation id="3496296378755072552">Slaptažodžių tvarkytuvė</translation>
<translation id="3502555714327823858">Leisti visus dvipusius režimus</translation>
<translation id="350443680860256679">ARC konfigūravimas</translation>
<translation id="3504791027627803580">Nurodomas paieškos variklio URL, naudojamas vaizdų paieškai teikti. Paieškos užklausos bus siunčiamos naudojant GET metodą. Jei nustatyta politika „DefaultSearchProviderImageURLPostParams“, vaizdų paieškos užklausoms naudojamas POST metodas.

          Ši politika pasirenkama. Jei nenustatyta, nenaudojama jokia vaizdų paieška.

          Šios politikos laikomasi, tik jei įgalinta politika „DefaultSearchProviderEnabled“.</translation>
<translation id="350797926066071931">Įgalinti vertimą</translation>
<translation id="3512226956150568738">Jei kliento turimo modelio įrenginyje jau buvo palaikomas failų formatas ARC, kol dar perėjimas prie „ext4“ šifruotės nebuvo būtinas, kad būtų galima vykdyti ARC failus, ir jei politika „ArcEnabled“ nustatyta į „true“, ši parinktis veiks kaip „AskUser“ (3 vertė). Visais kitais atvejais (jei įrenginio modelyje nebuvo nepalaikomas failų formatas ARC arba jei politika „ArcEnabled“ nustatyta į „false“) ši vertė bus lygi „DisallowArc“ (0 vertė).</translation>
<translation id="3524204464536655762">Neleisti jokiai svetainei pateikti užklausos pasiekti USB įrenginių naudojant „WebUSB“ API</translation>
<translation id="3526752951628474302">Tik vienspalvis spausdinimas</translation>
<translation id="3528000905991875314">Įgalinti kitus klaidų puslapius</translation>
<translation id="3545457887306538845">Leidžiama valdyti, kur galima naudoti kūrėjo įrankius.

      Jei ši politika nustatyta kaip „DeveloperToolsDisallowedForForceInstalledExtensions“ (0 vertė, kuri yra įmonės naudotojams taikoma numatytoji vertė), kūrėjo įrankius ir „JavaScript“ pultą galima pasiekti įprastai, bet jų negalima pasiekti naudojant pagal įmonės politiką įdiegtus plėtinius.
      Jei ši politika nustatyta kaip „DeveloperToolsAllowed“ (1 vertė), kūrėjo įrankius ir „JavaScript“ pultą galima pasiekti ir naudoti esant bet kokiam kontekstui, įskaitant tuos atvejus, kai naudojami pagal įmonės politiką įdiegti plėtiniai.
      Jei ši politika nustatyta kaip „DeveloperToolsDisallowed“ (2 vertė), kūrėjo įrankių negalima pasiekti ir nebegalima tikrinti svetainės elementų. Bus išjungti visi spartieji klavišai ir meniu ar kontekstinių meniu įrašai, skirti kūrėjo įrankiams ar „JavaScript“ pultui atidaryti.</translation>
<translation id="3547954654003013442">Įgaliotojo serverio nustatymai</translation>
<translation id="3556806727696701427">Įgalinama „<ph name="PRODUCT_NAME" />“ saugaus naršymo funkcija. Naudotojams šio nustatymo keisti neleidžiama.

      Jei įgalinsite šį nustatymą, Saugus naršymas bus visada aktyvus.

      Jei šį nustatymą išjungsite, Saugus naršymas niekada nebus aktyvus.

      Jei šį nustatymą įgalinsite arba išjungsite, naudotojai negalės pakeisti ar nepaisyti „<ph name="PRODUCT_NAME" />“ nustatymo „Įgalinti apsaugą nuo sukčiavimo ir kenkėjiškų programų“.

      Jei ši politika nenustatyta, ši funkcija bus įgalinta, bet naudotojas galės tai pakeisti.

      Daugiau informacijos apie Saugų naršymą pateikiama adresu https://developers.google.com/safe-browsing.

      Ši politika nepasiekiama „Windows“ objektuose, kurie nesusieti su „<ph name="MS_AD_NAME" />“ domenu.</translation>
<translation id="3577251398714997599">Skelbimų nustatymai svetainėms su nepageidaujamais skelbimais</translation>
<translation id="3591584750136265240">Konfigūruoti prisijungimo autentifikavimo elgseną</translation>
<translation id="3627678165642179114">Įgalinti rašybos tikrinimo žiniatinklio paslaugą arba jos neleisti</translation>
<translation id="3628480121685794414">Įgalinti vienpusį spausdinimą</translation>
<translation id="3646859102161347133">Nustatyti ekrano didinimo tipą</translation>
<translation id="3653237928288822292">Numatytojo paieškos teikėjo piktograma</translation>
<translation id="3660562134618097814">„SAML IdP“ slapukų perkėlimas prisijungiant</translation>
<translation id="3702647575225525306">„<ph name="POLICY_NAME" />“ (Vienos eilutės laukelis nebenaudojamas ir ateityje bus pašalintas. Pradėkite naudoti toliau pateiktą kelių eilučių teksto laukelį.)</translation>
<translation id="3709266154059827597">Konfigūruoti plėtinių diegimo juodąjį sąrašą</translation>
<translation id="3711895659073496551">Laikinai sustabdyti</translation>
<translation id="3715569262675717862">Autentifikavimas atsižvelgiant į klientų sertifikatus</translation>
<translation id="3736879847913515635">Asmens pridėjimo naudotojų tvarkytuvėje įgalinimas</translation>
<translation id="3746590506846867985">
      Ši politika taikoma prisijungimo ekranui. Taip pat žr. politiką „<ph name="ISOLATE_ORIGINS_POLICY_NAME" />“, kuri taikoma naudotojo sesijai. Rekomenduojama abiems politikoms nustatyti tą pačią vertę. Jei vertės neatitiks, pradedant naudotojo sesiją gali būti uždelsta, kol taikoma naudotojo politikos nurodyta vertė.
      Įgalinus politiką kiekvienas pavadinimą turintis šaltinis, įtrauktas į kableliais atskirtų verčių sąrašą, vykdys atskirą procesą. Taip pat bus atskiriami šaltiniai, pavadinti pagal padomenius, pvz., nurodžius https://example.com/ taip pat bus atskiriamas https://foo.example.com/ kaip svetainės https://example.com/ dalis.
      Išjungus politiką nebus taikomas svetainių atskyrimas, o „IsolateOrigins“ ir „SitePerProcess“ bandomosios versijos bus išjungtos. Naudotojai vis tiek galės neautomatiškai įgalinti „IsolateOrigins“.
      Nesukonfigūravus politikos prisijungimo ekrane bus naudojami numatytieji platformos svetainių atskyrimo nustatymai.
      </translation>
<translation id="3748900290998155147">Nurodoma, ar leidžiami pažadinimo užraktai. Pažadinimo užraktų užklausas gali teikti plėtiniai, naudodami energijos tvarkymo plėtinio API, ir ARC programos.

          Jei ši politika nustatyta kaip „Tiesa“ arba nenustatyta, pažadinimo užraktams leidžiama tvarkyti energiją.

          Jei ši politika nustatyta kaip „Netiesa“, pažadinimo užraktų užklausų nepaisoma.</translation>
<translation id="3750220015372671395">Blokuoti rakto generavimą šiose svetainėse</translation>
<translation id="3756011779061588474">Blokuoti kūrėjo režimą</translation>
<translation id="3758089716224084329">Leidžiama nurodyti „<ph name="PRODUCT_NAME" />“ naudojamą tarpinį serverį ir neleidžiama naudotojams keisti tarpinio serverio nustatymų.

      Jei pasirinksite niekada nenaudoti tarpinio serverio ir visada prisijungti tiesiogiai, visų kitų parinkčių bus nepaisoma.

      Jei pasirinksite automatiškai aptikti tarpinį serverį, visų kitų parinkčių bus nepaisoma.

      Jei reikia išsamių pavyzdžių, apsilankykite adresu
      <ph name="PROXY_HELP_URL" />

      Jei įgalinsite šį nustatymą, „<ph name="PRODUCT_NAME" />“ ir ARC programos nepaisys visų komandų eilutėje nurodytų su tarpiniu serveriu susijusių parinkčių.

      Jei paliksite šią politiką nenustatytą, naudotojai galės patys pasirinkti tarpinio serverio nustatymus.</translation>
<translation id="3758249152301468420">Neleisti kūrėjo įrankių</translation>
<translation id="3764248359515129699">Išjungiamas sąraše nurodytų pasenusių sertifikavimo institucijų sertifikato skaidrumo reikalavimų įgyvendinimas.

      Naudojant šią politiką galima išjungti sertifikato skaidrumo atskleidimo reikalavimus, skirtus sertifikatų grandinėms, kuriose yra sertifikatų su viena iš nurodytų „subjectPublicKeyInfo“ maišų. Taip leidžiama naudoti sertifikatus, kurie kitaip būtų nepatikimi, nes nėra tinkamai viešai atskleisti, kad būtų galima toliau naudoti įmonės prieglobos serveriuose.

      Kad sertifikato skaidrumo įgyvendinimas būtu išjungtas, kai nustatyta ši politika, maiša turi būti sudaryta iš „subjectPublicKeyInfo“ vertės, pateiktos CA sertifikate, kuris atpažįstamas kaip pasenusi sertifikavimo institucija (CA). Pasenusi CA yra CA, kuria pagal numatytuosius nustatymus pasitiki viena ar daugiau „<ph name="PRODUCT_NAME" />“ palaikomų operacinių sistemų, bet nepasitiki „Android“ atvirojo šaltinio projektas arba „<ph name="PRODUCT_OS_NAME" />“.

      „subjectPublicKeyInfo“ maiša nurodoma sujungus maišos algoritmo pavadinimą, simbolį „/“ ir to maišos algoritmo „Base64“ koduotę, pritaikytą nurodyto sertifikato DER užkoduotai „subjectPublicKeyInfo“ vertei. Ši „Base64“ koduotė nurodoma tuo pačiu formatu, kaip ir SPKI piršto antspaudas (apibrėžta RFC 7469, 2.4 skiltyje). Neatpažintų maišos algoritmų nepaisoma. Šiuo metu palaikomas tik „sha256“ maišos algoritmas.

      Jei ši politika nenustatyta, bet koks sertifikatas, kurį reikia atskleisti taikant sertifikato skaidrumą, bus laikomas nepatikimu, jei nebus atskleistas atsižvelgiant į sertifikato skaidrumo politikos nuostatas.</translation>
<translation id="3765260570442823273">Neveikos būsenos atjungimo įspėjimo pranešimo trukmė</translation>
<translation id="377044054160169374">Įsikišimo dėl piktnaudžiavimo atvejų įgalinimas</translation>
<translation id="3780152581321609624">Įtraukti nestandartinį prievadą į „Kerberos“ SPN</translation>
<translation id="3780319008680229708">Jei ši politika bus nustatyta į „true“, „Cast“ įrankių juostos piktograma visada bus rodoma įrankių juostoje arba perpildymo meniu ir naudotojai negalės jos pašalinti.

          Jei ši politika bus nustatyta į „false“ arba nebus nustatyta, naudotojai galės prisegti arba pašalinti piktogramą kontekstiniame meniu.

          Jei politika „EnableMediaRouter“ bus nustatyta į „false“, šios politikos vertė neturės jokio poveikio ir įrankių juostos piktograma nebus rodoma.</translation>
<translation id="3788662722837364290">Maitinimo valdymo nustatymai, kai naudotojas tampa neaktyvus</translation>
<translation id="3790085888761753785">Įgalinus šį nustatymą, naudotojai galės prisijungti prie paskyrų naudodami „Smart Lock“. Tai labiau leidžiama nei įprasta „Smart Lock“ elgsena, leidžianti naudotojams tik atrakinti ekraną.

      Jei šis nustatymas išjungtas, naudotojams neleidžiama naudoti „Smart Lock“ prisijungimo funkcijos.

      Jei ši politika nenustatyta, įmonių valdomų naudotojų numatytasis nustatymas bus „neleidžiama“, o nevaldomų naudotojų – „leidžiama“.</translation>
<translation id="379602782757302612">Leidžiama nurodyti, kurių plėtinių naudotojai NEGALI įdiegti. Jei jau įdiegti plėtiniai bus įtraukti į juodąjį sąrašą, jie bus išjungiami, ir naudotojai negalės vėl jų įgalinti. Kai išjungtas plėtinys, kuris buvo įtrauktas į juodąjį sąrašą, iš sąrašo bus pašalintas, jis vėl bus automatiškai įgalintas.

          Juodojo sąrašo vertė * nurodo, kad visi plėtiniai yra įtraukti į juodąjį sąrašą, nebent jie yra aiškiai nurodyti baltajame sąraše.

          Jei ši politika lieka nenustatyta, naudotojas gali įdiegti bet kurį „<ph name="PRODUCT_NAME" />“ plėtinį.</translation>
<translation id="3800626789999016379">Konfigūruojamas katalogas, kurį „<ph name="PRODUCT_NAME" />“ naudos failams atsisiųsti.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME" />“ naudos nurodytą katalogą, nesvarbu, ar naudotojas jį nurodė, ar įgalino žymą kiekvieną kartą raginti nurodyti atsisiuntimo vietą.

      Apsilankykite adresu https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables. Čia rasite kintamųjų, kuriuos galima naudoti, sąrašą.

      Jei ši politika nenustatyta, bus naudojamas numatytasis atsisiuntimo katalogas ir naudotojas galės jį pakeisti.</translation>
<translation id="3805659594028420438">Įgalinti TLS domenų sertifikatų plėtinį (nebenaudojamas)</translation>
<translation id="3808945828600697669">Nurodyti neleidžiamų papildinių sąrašą</translation>
<translation id="3811562426301733860">Leisti skelbimus visose svetainėse</translation>
<translation id="3816312845600780067">Įgalinti laisvuosius sparčiuosius klavišus automatiškai prisijungiant</translation>
<translation id="3820526221169548563">Įgalinti ekrano klaviatūros pasiekiamumo funkciją.

          Jei ši politika galioja, ekrano klaviatūra visada bus įgalinta.

          Jei ši politika negalioja, ekrano klaviatūra visada bus išjungta.

          Jei nustatysite šią politiką, naudotojai negalės jos pakeisti ar nepaisyti.

          Jei ši politika paliekama nenustatyta, ekrano klaviatūra yra išjungta, bet naudotojas ją gali bet kada įgalinti.</translation>
<translation id="382476126209906314">Konfigūruoti nuotolinės prieigos prieglobų „TalkGadget“ (Pokalbių programėlės) kodą</translation>
<translation id="3831376478177535007">Įgalinus šį nustatymą, „<ph name="PRODUCT_NAME" />“ leidžia „Symantec Corporation“ išduotus pasenusių PKI operacijų sertifikatus nustatyti kaip patikimus, jei jie sėkmingai patvirtinami ir susiejami su atpažįstamu CA sertifikatu.

      Atminkite, kad ši politika nustatoma atsižvelgiant į operacinę sistemą, kuri vis dar atpažįsta sertifikatus iš „Symantec“ pasenusios infrastruktūros. Jei atnaujinus OS pakeičiama, kaip OS apdoroja tokius sertifikatus, ši politika nebegalioja. Be to, ši politika teikiama kaip laikina sprendimo priemonė, norint suteikti įmonėms daugiau laiko pereiti nuo pasenusių „Symantec“ sertifikatų. Ši politika bus pašalinta 2019 m. sausio 1 d. arba šiek tiek vėliau / anksčiau.

      Jei ši politika nenustatyta arba nustatyta į „false“, „<ph name="PRODUCT_NAME" />“ vykdys viešai paskelbtą naudojimo nutraukimo tvarkaraštį.

      Daugiau informacijos apie šį naudojimo nutraukimą žr. https://g.co/chrome/symantecpkicerts.</translation>
<translation id="383466854578875212">Leidžiama nurodyti, kurios savųjų susirašinėjimo pranešimais programų prieglobos neturėtų būti įtrauktos į juodąjį sąrašą.

          Juodojo sąrašo vertė * reiškia, kad visos savosios susirašinėjimo pranešimais programos prieglobos yra įtrauktos į juodąjį sąrašą ir bus įkeltos tik savųjų susirašinėjimo pranešimais programų prieglobos, esančios baltajame sąraše.

          Pagal numatytuosius nustatymus visos savosios susirašinėjimo pranešimais programų prieglobos pagal politiką įtraukiamos į baltąjį sąrašą, bet jei visos savųjų susirašinėjimo pranešimais programų prieglobos pagal politiką įtraukiamos į juodąjį sąrašą, galima nepaisyti šios politikos naudojant baltąjį sąrašą.</translation>
<translation id="384743459174066962">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose neleidžiama atidaryti iššokančiųjų langų, sąrašą.

          Nenustačius šios politikos, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „Numatytasis iššokančiųjų langų nustatymas“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="3851039766298741586">Pranešama informacija apie aktyvią viešojo terminalo sesiją, pvz.,
      programos ID ir versija.

      Nustačius politiką kaip „False“, viešojo terminalo sesijos informacija
      nepranešama. Nustačius kaip „True“ arba nenustačius, viešojo terminalo sesijos informacija
      pranešama.</translation>
<translation id="3858658082795336534">Numatytasis spausdinimas dvipusiu režimu</translation>
<translation id="3859780406608282662">Pridėti parametrą prie atsitiktinio varianto gavimo „<ph name="PRODUCT_OS_NAME" />“.

      Jei nurodyta, prie URL, naudojamo gaunant atsitiktinį variantą, pridedamas užklausos parametras, vadinamas „apriboti“. Parametro vertė bus vertė, nurodyta šioje politikoje.

      Jei nenurodyta, atsitiktinio varianto URL nekeičiamas.</translation>
<translation id="3863409707075047163">Minimalios versijos SSL įgalinimas</translation>
<translation id="3864020628639910082">Nurodomas paieškos variklio, naudojamo paieškos pasiūlymams teikti, URL. URL turėtų būti eilutė „<ph name="SEARCH_TERM_MARKER" />“, kuri teikiant užklausą bus pakeista naudotojo jau įvestu tekstu.

          Ši politika pasirenkama. Nenustačius jos, joks siūlomas URL nebus naudojamas.

          „Google“ siūlomą URL galima nurodyti kaip: <ph name="GOOGLE_SUGGEST_SEARCH_URL" />.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Numatytasis paieškos teikėjas įgalintas“.</translation>
<translation id="3866249974567520381">Aprašas</translation>
<translation id="3868347814555911633">Ši politika taikoma tik mažmeninės prekybos režimu.

      Nurodomi plėtiniai, kurie automatiškai įdiegiami demonstracinės versijos naudotojui (-ai) įrenginiuose mažmeninės prekybos režimu. Šie plėtiniai išsaugomi įrenginyje ir juos galima įdiegti neprisijungus, baigus diegimą.

      Kiekviename sąrašo įraše yra žodynas, į kurį turi būti įtrauktas plėtinio ID lauke „extension-id“ (plėtinio ID) ir naujinio URL lauke „update-url“ (naujinio URL).</translation>
<translation id="3874773863217952418">Įgalinti Paiešką palietus</translation>
<translation id="3877517141460819966">Integruotas tapatybės nustatymo dviem veiksniais režimas</translation>
<translation id="3879208481373875102">Konfigūruoti žiniatinklio programų, kurias įdiegti buvo privaloma, sąrašą</translation>
<translation id="388237772682176890">Ši politika nebenaudojama M53 ir pašalinta iš M54, nes nebeteikiamas SPDY/3.1 palaikymas.

      Neleidžiama naudoti SPDY protokolo „<ph name="PRODUCT_NAME" />“.

      Jei ši politika bus įgalinta, SPDY protokolas nebus pasiekiamas „<ph name="PRODUCT_NAME" />“.

      Neleidus šios politikos, bus leidžiama naudoti SPDY.

      Nenustačius šios politikos, SPDY bus pasiekiamas.</translation>
<translation id="3890999316834333174">Sparčiojo atrakinimo politika</translation>
<translation id="3891357445869647828">Įgalinti „JavaScript“</translation>
<translation id="3895557476567727016">Konfigūruojamas numatytasis katalogas, kurį „<ph name="PRODUCT_NAME" />“ naudos failams atsisiųsti.

      Nustačius šią politiką, bus pakeistas numatytasis katalogas, į kurį „<ph name="PRODUCT_NAME" />“ atsisiunčia failus. Ši politika nėra būtina, todėl naudotojas galės pakeisti katalogą.

      Nenustačius šios politikos, „<ph name="PRODUCT_NAME" />“ naudos įprastą numatytąjį katalogą (konkrečios platformos).

      Jei reikia kintamųjų, kuriuos galima naudoti, sąrašo, žr. https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.</translation>
<translation id="3904459740090265495">Ši politika valdo naršyklės prisijungimo elgseną. Ji leidžia nurodyti, ar naudotojas gali prisijungti prie „<ph name="PRODUCT_NAME" />“ naudodamas savo paskyrą ir naudoti su paskyra susijusias paslaugas, pvz., „Chrome“ sinchronizavimą.

      Jei politika nustatyta kaip „Išjungti naršyklės prisijungimą“, naudotojas negali prisijungti prie naršyklės ir naudoti su paskyra susijusių paslaugų. Šiuo atveju negalima naudoti naršyklės lygio funkcijų, pvz., „Chrome“ sinchronizavimo, ir jos bus nepasiekiamos. Jei naudotojas buvo prisijungęs ir politika nustatoma kaip „Išjungta“, kitą kartą paleidęs „Chrome“ naudotojas nebus prisijungęs, bet jo vietiniai profilio duomenys, pvz., žymės, slaptažodžiai ir kt., bus saugomi. Naudotojas vis tiek galės prisijungti ir naudoti „Google“ žiniatinklio paslaugas, pvz., „Gmail“.

      Jei politika nustatyta kaip „Įgalinti naršyklės prisijungimą“, naudotojui leidžiama prisijungti prie naršyklės ir automatiškai prisijungiama prie naršyklės, prisijungus prie „Google“ žiniatinklio paslaugų, pvz., „Gmail“. Prisijungus prie naršyklės naudotojo paskyros informacija saugoma naršyklėje. Tačiau tai nereiškia, kad „Chrome“ sinchronizavimas bus įjungtas pagal numatytuosius nustatymus. Naudotojas turi atskirai pasirinkti naudoti šią funkciją. Įgalinus šią funkciją nebus leidžiama naudotojui išjungti nustatymo, leidžiančio prisijungti prie naršyklės. Jei norite valdyti „Chrome“ sinchronizavimo pasiekiamumą, naudokite politiką „SyncDisabled“.

      Jei politika nustatyta kaip „Priverstinis naršyklės prisijungimas“, naudotojui pateikiamas paskyros pasirinkimo dialogo langas ir jis turi pasirinkti ir prisijungti prie paskyros, kad galėtų naudoti naršyklę. Tai reiškia, kad valdomoms paskyroms taikoma ir vykdoma su paskyra susijusi politika. Pagal numatytuosius nustatymus įjungiamas „Chrome“ sinchronizavimas paskyroje, išskyrus tuo atveju, jei sinchronizavimą išjungė domeno administratorius arba jis buvo išjungtas taikant politiką „SyncDisabled“. Numatytoji politikos „BrowserGuestModeEnabled“ vertė bus nustatyta kaip „netiesa“. Atminkite, kad įgalinus šią politiką esami neprijungti profiliai bus užrakinti ir nepasiekiami. Jei reikia daugiau informacijos, žr. pagalbos centro straipsnį adresu https://support.google.com/chrome/a/answer/7572556.

      Jei ši politika nenustatyta, naudotojas gali nuspręsti, ar nori įgalinti naršyklės prisijungimo parinktį ir naudoti ją, kai tinkama.</translation>
<translation id="3911737181201537215">Ši politika neturi įtakos „Android“ vykdomam registravimo procesui.</translation>
<translation id="391531815696899618">Kai nustatyta kaip „true“, neleidžiamas „Google“ disko sinchronizavimas „<ph name="PRODUCT_OS_NAME" />“ programoje „Failai“. Tokiu atveju duomenys į „Google“ diską neįkeliami.

          Jei nenustatyta arba nustatyta kaip „false“, naudotojai galės perkelti failus į „Google“ diską.</translation>
<translation id="3915395663995367577">URL, siejantis su tarpinio serverio .pac failu</translation>
<translation id="3925020515212192040">Nurodomas iš anksto sukonfigūruotų tinklo failų bendrinimo įrenginių sąrašas.

      Kiekvienas politikos sąrašo elementas yra objektas iš dviejų narių: „share_url“ ir „mode“. „share_url“ turėtų būti bendrinimo įrenginio URL, o „mode“ turėtų būti „drop_down“, nurodantis, kad „share_url“ bus pridėtas prie bendrinamo įrenginio aptikimo išskleidžiamojo meniu.</translation>
<translation id="3939893074578116847">Siunčiami tinklo paketai į valdymo serverį, siekiant stebėti prisijungimo būseną, kad
      serveryje būtų aptikta, ar įrenginys prijungtas prie interneto.

      Jei ši politika nustatyta į „true“, bus siunčiami stebėjimo tinklo paketai (<ph name="HEARTBEATS_TERM" />).
      Jei ji nustatyta į „false“ arba yra nenustatyta, paketai siunčiami nebus.</translation>
<translation id="3950239119790560549">Laiko apribojimų atnaujinimas</translation>
<translation id="3958586912393694012">Leisti naudoti „Smart Lock“</translation>
<translation id="3963602271515417124">Jei ši politika galioja, leidžiama nuotoliniu būdu patvirtinti įrenginį, o sertifikatas bus automatiškai sugeneruotas ir įkeltas į įrenginių tvarkymo serverį.

          Jei ši politika negalioja arba yra nenustatyta, sertifikatas nebus sugeneruotas ir nepavyks iškviesti „enterprise.platformKeysPrivate“ plėtinio API.</translation>
<translation id="3965339130942650562">Skirtasis laikas, kol vykdomas neveikos būsenos naudotojo atjungimas</translation>
<translation id="3973371701361892765">Niekada automatiškai neslėpti lentynos</translation>
<translation id="3984028218719007910">Nustatoma, ar „<ph name="PRODUCT_OS_NAME" />“ paliekami vietiniai paskyros duomenys atsijungus. Jei nustatyta į „true“ (tiesa), jokios nuolatinės paskyros nelaikomos „<ph name="PRODUCT_OS_NAME" />“ ir visi duomenys iš naudotojo sesijos atmetami atsijungus. Jei ši politika nustatyta į „false“ (netiesa) arba nesukonfigūruota, įrenginyje gali būti laikomi (šifruoti) vietiniai naudotojo duomenys.</translation>
<translation id="3997519162482760140">URL, kuriems bus suteikta prieiga prie vaizdo įrašus fiksuojančių įrenginių SAML prisijungimo puslapiuose</translation>
<translation id="4001275826058808087">Įmonės įrenginių IT administratoriai gali naudoti šią žymą, kad valdytų, ar leisti naudotojams išpirkti pasiūlymus vykdant „Chrome“ OS registraciją.

      Jei ši politika galioja arba nėra nustatyta, naudotojai galės išpirkti pasiūlymus vykdydami „Chrome“ OS registraciją.

      Jei ši politika negalioja, naudotojas negalės išpirkti pasiūlymų.</translation>
<translation id="4008507541867797979">Jei ši politika nustatyta kaip „Tiesa“ arba nesukonfigūruota, „<ph name="PRODUCT_OS_NAME" />“ rodomi esami naudotojai prisijungimo ekrane ir leidžiama juos pasirinkti.

      Jei ši politika nustatyta kaip „Netiesa“, „<ph name="PRODUCT_OS_NAME" />“ nerodomi esami naudotojais prisijungimo ekrane. Bus rodomas įprastas prisijungimo ekranas (kuriame bus raginama įvesti naudotojo el. pašto adresą ir slaptažodį arba telefono numerį) arba SAML tarpinio puslapio ekranas (jei įgalinta taikant „<ph name="LOGIN_AUTHENTICATION_BEHAVIOR_POLICY_NAME" />“ politiką), nebent sukonfigūruota valdoma sesija. Kai sukonfigūruota valdoma sesija, rodomos tik valdomos sesijos paskyros, leidžiant pasirinkti vieną iš jų.

      Atminkite, kad ši politika neturi įtakos, ar įrenginyje paliekami ar atmetami vietiniai naudotojo duomenys.</translation>
<translation id="4010738624545340900">Leisti iškviesti failų pasirinkimo dialogo langus</translation>
<translation id="4012737788880122133">Neleidžiami automatiniai naujiniai, kai nustatyta į „true“.

      „<ph name="PRODUCT_OS_NAME" />“ įrenginiai automatiškai tikrina, ar yra naujinių, kai šis nustatymas nesukonfigūruotas ar nustatytas į „false“.

      Įspėjimas: rekomenduojama įgalinti automatinius naujinius, kad naudotojai gautų programinės įrangos naujinius ir svarbias saugos pataisas. Išjungus automatinius naujinius gali kilti grėsmė naudotojų saugai.</translation>
<translation id="4020682745012723568">Į naudotojo profilį perkeltų slapukų „Android“ programos pasiekti negali.</translation>
<translation id="402759845255257575">Neleisti jokioje svetainėje paleisti „JavaScript“</translation>
<translation id="4027608872760987929">Įgalinti numatytąjį paieškos teikėją</translation>
<translation id="4039085364173654945">Valdoma, ar trečiosios šalies papildomas turinys puslapyje gali būti pateiktas iššokančiajame HTTP pagrindinės prieigos teisės dialogo lange.

          Įprastai tai neleidžiama siekiant apsisaugoti nuo sukčiavimo. Nenustačius šios politikos, tai neleidžiama ir trečiosios šalies papildomo turinio neleidžiama pateikti iššokančiajame HTTP pagrindinės prieigos teisės dialogo lange.</translation>
<translation id="4056910949759281379">Neleisti SPDY protokolo</translation>
<translation id="4059515172917655545">Pagal šią politiką valdomas „Google“ vietovės paslaugų pasiekiamumas.

      Kai ši politika nesukonfigūruota arba nustatyta kaip „<ph name="GLS_DISABLED" />“, „Google“ vietovės paslaugos išjungtos ir naudotojas jų įgalinti negali.

      Kai ši politika nustatyta kaip „<ph name="GLS_UNDER_USER_CONTROL" />“, naudotojo prašoma pasirinkti, ar naudoti „Google“ vietovės paslaugas. Taip „Android“ programoms leidžiama naudoti paslaugas teikiant užklausas dėl įrenginio vietovės, taip pat įgalinamas anoniminių vietovės duomenų teikimas „Google“.

      Atminkite, kad politiką „<ph name="DEFAULT_GEOLOCATION_SETTING_POLICY_NAME" />“ nustačius kaip „<ph name="BLOCK_GEOLOCATION_SETTING" />“, šios politikos nepaisoma, o „Google“ vietovės paslaugos visada išjungtos.</translation>
<translation id="408029843066770167">Leisti užklausas į „Google“ laiko paslaugą</translation>
<translation id="408076456549153854">Naršyklės prisijungimo įgalinimas</translation>
<translation id="4088589230932595924">Įjungtas inkognito režimas</translation>
<translation id="4088983553732356374">Leidžiama nustatyti, ar svetainėms galima nustatyti vietinius duomenis. Nustatyti vietinius duomenis galima leisti arba uždrausti visoms svetainėms.

          Jei ši politika nustatyta į „Palikti slapukus, kol sesija aktyvi“, tada slapukai bus išvalyti uždarius sesiją. Atminkite, kad jei „<ph name="PRODUCT_NAME" />“ veikia foninio atkūrimo režimu, sesijos negalima uždaryti, kai uždaromas paskutinis langas. Daugiau informacijos apie šio veikimo konfigūravimą galite gauti peržiūrėję politiką „BackgroundModeEnabled“.

          Jei ši politika nenustatyta, bus naudojama parinktis „AllowCookies“ ir naudotojas galės ją pakeisti.</translation>
<translation id="4103289232974211388">Patvirtinus naudotoją peradresuoti į „SAML IdP“</translation>
<translation id="410478022164847452">Nurodoma laiko trukmė be naudotojo įvesties, po kurios neveikos veiksmai atliekami, kai naudojama kintamosios srovės energija.

          Kai ši politika nustatyta, ji nurodo laiko trukmę, kurią naudotojas turi neatlikti jokių veiksmų, kad „<ph name="PRODUCT_OS_NAME" />“ imtųsi veiksmų dėl neveikos. Šiuos veiksmus galite sukonfigūruoti atskirai.

          Kai ši politika nenustatyta, naudojama numatytoji laiko trukmė.

          Politikos vertė turėtų būti nurodyta milisekundėmis.</translation>
<translation id="4105989332710272578">Sertifikato skaidrumo taikymo URL sąrašui išjungimas</translation>
<translation id="4121350739760194865">Neleisti rodyti programų reklamų naujo skirtuko puslapyje</translation>
<translation id="412697421478384751">Leisti naudotojams nustatyti nesudėtingus užrakinimo ekrano PIN kodus</translation>
<translation id="4138655880188755661">Laiko apribojimas</translation>
<translation id="4157003184375321727">Pranešti OS ir programinės aparatinės įrangos versiją</translation>
<translation id="4157594634940419685">Leisti pasiekti savuosius CUPS spausdintuvus</translation>
<translation id="4183229833636799228">Numatytasis „<ph name="FLASH_PLUGIN_NAME" />“ nustatymas</translation>
<translation id="4192388905594723944">URL, skirtas nuotolinio prisijungimo kliento autentifikavimo prieigos raktui patvirtinti</translation>
<translation id="4203389617541558220">Apriboti įrenginio veikimo laiką suplanuojant automatinį operacinės sistemos įkėlimą.

      Kai ši politika nustatyta, ji nurodo įrenginio veikimo laiką, kuriam praėjus suplanuotas automatinis operacinės sistemos įkėlimas iš naujo.

      Kai ši politika nenustatyta, įrenginio veikimo laikas neribojamas.

      Jei nustatysite šią politiką, naudotojai negalės jos pakeisti arba nepaisyti.

      Automatinis operacinės sistemos įkėlimas suplanuotas pasirinktu laiku, bet įrenginyje jis gali būti atidėtas iki 24 val., jei naudotojas šiuo metu naudoja įrenginį.

      Pastaba: šiuo metu automatinis operacinės sistemos įkėlimas iš naujo įgalinamas, tik kai rodomas prisijungimo ekranas arba vyksta viešojo terminalo programos seansas. Tai bus pakeista ateityje ir politika bus taikoma neatsižvelgiant į tai, ar vyksta bet kokio tipo seansas.

      Politikos vertė turėtų būti nurodyta sekundėmis. Vertės sumažinamos, kad būtų bent 3 600 sek. (viena valanda).</translation>
<translation id="4203879074082863035">Naudotojams rodomi tik į baltąjį sąrašą įtraukti spausdintuvai</translation>
<translation id="420512303455129789">Žodynų susiejimo URL, skirti loginiam bandymui, nurodantys, ar prieiga prie prieglobos turėtų būti leidžiama („true“) arba blokuojama („false“).

Ši politika skirta naudoti tik „<ph name="PRODUCT_NAME" />“ viduje.</translation>
<translation id="4224610387358583899">Ekrano užrakto delsos laikotarpiai</translation>
<translation id="423797045246308574">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose neleidžiama naudoti rakto generavimo, sąrašą. Jei URL šablonas yra politikoje „KeygenAllowedForUrls“, šioje politikoje nepaisoma šių išimčių.

          Nenustačius šios politikos visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultKeygenSetting“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="4239720644496144453">Talpykla nenaudojama „Android“ programose. Jei keli naudotojai įdiegs tą pačią „Android“ programą, kiekvienam naudotojui bus atsisiųsta nauja programa.</translation>
<translation id="4243336580717651045">Sistemoje „<ph name="PRODUCT_NAME" />“ įgalinamas URL pagrįstas anonimizuotų duomenų rinkimas ir naudotojams neleidžiama keisti šio nustatymo.

      Renkant URL pagrįstus anonimizuoti duomenis, puslapių, kuriuose apsilanko naudotojai, URL siunčiami į sistemą „Google“ siekiant pagerinti paieškas ir naršymą.

      Jei įgalinsite šią politiką, URL pagrįsto anonimizuotų duomenų rinkimo funkcija visada bus aktyvi.

      Jei išjungsite šią politiką, URL pagrįsto anonimizuotų duomenų rinkimo funkcija niekada nebus aktyvi.

      Jei ši politika bus palikta nenustatyta, URL pagrįsto anonimizuotų duomenų rinkimo funkcija bus įgalinta, bet naudotojas galės ją pakeisti.</translation>
<translation id="4250680216510889253">Ne</translation>
<translation id="4261820385751181068">Įrenginio prisijungimo ekrano lokalė</translation>
<translation id="427220754384423013">Nurodomi spausdintuvai, kuriuos gali naudoti naudotojas.

      Ši politika naudojama, tik jei pasirinktas politikos „<ph name="BULK_PRINTERS_ACCESS_MODE" />“ nustatymas „<ph name="PRINTERS_WHITELIST" />“.

      Jei ši politika naudojama, naudotojui pasiekiami tik spausdintuvai, kurių ID atitinka šioje politikoje nurodytas vertes. ID turi atitikti laukus „id“ arba „guid“ faile, kuris nurodytas „<ph name="BULK_PRINTERS_POLICY" />“.
      </translation>
<translation id="427632463972968153">Nurodomi parametrai, naudojami atliekant vaizdų paiešką naudojant POST. Jie sudaryti iš kableliais atskirtų pavadinimų / verčių porų. Jei vertė yra šablono parametras, pvz., {imageThumbnail} anksčiau pateiktame pavyzdyje, ji pakeičiama realiais vaizdo miniatiūros duomenimis.

          Ši politika pasirenkama. Jei nenustatyta, vaizdų paieškos užklausa siunčiama naudojant GET metodą.

          Šios politikos laikomasi, tik jei įgalinta politika „DefaultSearchProviderEnabled“.</translation>
<translation id="4285674129118156176">Leidžiama nesusietiems naudotojams naudoti ARC</translation>
<translation id="4298509794364745131">Nurodomas programų, kurias galite įgalinti kaip užrašų programas „<ph name="PRODUCT_OS_NAME" />“ užrakinimo ekrane, sąrašas.

      Jei pageidaujama užrašų programa įgalinta užrakinimo ekrane, jame bus NS elementas pageidaujamai užrašų programai paleisti.
      Kai programa paleista, ji gali atidaryti programos langą užrakinimo ekrane ir kurti jame duomenų elementus (užrašus). Programa galės importuoti sukurtus užrašus į pagrindinę naudotojo sesiją, kai sesija bus atrakinta. Šiuo metu tik „Chrome“ užrašų programos palaikomos užrakinimo ekrane.

      Jei politika nustatyta, naudotojui bus leidžiama įgalinti programą užrakinimo ekrane, tik jei programos plėtinio ID bus pateiktas politikos sąrašo vertėje.
      Todėl šią politiką nustačius kaip tuščią sąrašą užrašai bus visiškai išjungti užrakinimo ekrane.
      Atminkite, kad politika su programos ID nebūtinai reiškia, kad naudotojas galės įgalinti programą kaip užrašų programą užrakinimo ekrane (pvz., 61 versijos „Chrome“ platforma papildomai apriboja pasiekiamų programų rinkinį).

      Jei politika nenustatyta, nebus taikoma jokių programų, kurias naudotojas gali įgalinti užrakinimo ekrane, rinkinio apribojimų.</translation>
<translation id="4309640770189628899">Ar įgalinti DHE šifruotieji programų komplektai TLS</translation>
<translation id="4322842393287974810">Leisti automatiškai be delsos paleistai viešojo terminalo programai valdyti „<ph name="PRODUCT_OS_NAME" />“ versiją</translation>
<translation id="4325690621216251241">Pridėti atsijungimo mygtuką prie sistemos dėklo</translation>
<translation id="4332177773549877617">Registruoti „Android“ programų diegimo įvykius</translation>
<translation id="4346674324214534449">Leidžiama nustatyti, ar skelbimai turėtų būti blokuojami svetainėse su nepageidaujamais skelbimais.

      Jei bus nustatyta šios politikos parinktis 2, skelbimai bus blokuojami svetainėse su nepageidaujamais skelbimais.
      Tačiau ši elgsena negalios, jei bus nustatyta politikos „SafeBrowsingEnabled“ parinktis „False“.
      Jei bus nustatyta šios politikos parinktis 1, skelbimai nebus blokuojami svetainėse su nepageidaujamais skelbimais.
      Jei ši politika bus palikta nenustatyta, bus naudojama parinktis 2.</translation>
<translation id="4347908978527632940">Jei nustatyta „true“ ir naudotojas yra prižiūrimas naudotojas, tada kitos „Android“ programos gali teikti naudotojo žiniatinklio apribojimų užklausas per turinio teikėją.

          Jei nustatyta „false“ arba nenustatyta, turinio teikėjas nepateikia jokios informacijos.</translation>
<translation id="435461861920493948">Apima šablonų, kurie naudojami paskyrų matomumui naršyklėje „<ph name="PRODUCT_NAME" />“ valdyti, sąrašą.

      Kiekviena „Google“ paskyra įrenginyje bus lyginama su šioje politikoje saugomais šablonais, siekiant nustatyti paskyros matomumą naršyklėje „<ph name="PRODUCT_NAME" />“. Paskyra matoma, jei jos pavadinimas atitinka bet kurį šabloną sąraše. Jei neatitinka, paskyra paslepiama.

      Naudokite pakaitos simbolį * nuliui ar daugiau abejotinų simbolių taikyti. Kaitos simbolis yra \, taigi, kad simboliai atitiktų faktinius * arba \ simbolius, prieš juos įveskite \.

      Jei ši politika nenustatyta, visos „Google“ paskyros įrenginyje matomos naršyklėje „<ph name="PRODUCT_NAME" />“.</translation>
<translation id="436581050240847513">Pateikti įrenginio tinklo sąsajų ataskaitą</translation>
<translation id="4372704773119750918">Neleisti įmonės naudotojui būti kelių profilių dalimi (pirminiu ar antriniu naudotoju)</translation>
<translation id="4377599627073874279">Leisti visose svetainėse rodyti visus vaizdus</translation>
<translation id="437791893267799639">Politika nenustatyta, neleisti perkelti duomenų ir ARC</translation>
<translation id="4389091865841123886">Konfigūruojamas nuotolinis patvirtinimas naudojant TPM mechanizmą.</translation>
<translation id="4408428864159735559">Iš anksto sukonfigūruotų tinklo failų bendrinimo įrenginių sąrašas.</translation>
<translation id="4410236409016356088">Įgalinti tinklo siuntimo spartos reguliavimą</translation>
<translation id="441217499641439905">Išjungti „Google“ disko naudojimą korinio ryšio tinkle „<ph name="PRODUCT_OS_NAME" />“ programoje „Failai“</translation>
<translation id="4418726081189202489">Nustačius šią politiką į „False“, „<ph name="PRODUCT_NAME" />“ nebesiunčia retkarčiais teikiamų užklausų į „Google“ serverį, kad gautų tikslią laiko žymę. Šios užklausos bus įgalintos, jei ši politika bus nustatyta į „True“ arba nenustatyta.</translation>
<translation id="4423597592074154136">Pačiam nurodyti tarpinio serverio nustatymus</translation>
<translation id="4429220551923452215">Įgalinamas arba išjungiamas programų spartusis klavišas žymių juostoje.

      Jei ši politika nenustatyta, naudotojas gali pasirinkti rodyti arba slėpti programų spartųjį klavišą žymių juostos kontekstiniame meniu.

      Jei ši politika sukonfigūruota, naudotojas negali jos pakeisti, o programų spartusis klavišas visada rodomas arba niekada nerodomas.</translation>
<translation id="4432762137771104529">Saugaus naršymo išplėstinių ataskaitų teikimo įgalinimas</translation>
<translation id="443454694385851356">Pasenę (nesaugūs)</translation>
<translation id="443665821428652897">Išvalyti svetainės duomenis uždarant naršyklę (nebenaudojama)</translation>
<translation id="4439336120285389675">Nurodomas nebenaudojamų žiniatinklio platformos funkcijų, kurios bus laikinai įgalintos, sąrašas.

      Naudodami šią politiką administratoriai gali iš naujo laikinai įgalinti nebenaudojamas žiniatinklio platformos funkcijas. Funkcijos nurodomos pateikus eilutės žymą, o funkcijos, atitinkančios žymas šios politikos nurodytame sąraše, bus įgalintos iš naujo.

      Jei ši politika nenustatyta arba sąrašas yra tuščias ar neatitinka vienos iš palaikomų eilutės žymų, visos nebenaudojamos žiniatinklio platformos funkcijos liks išjungtos.

      Politika palaikoma anksčiau nurodytose platformose, tačiau įgalinama funkcija gali būti pasiekiama mažiau platformų. Ne visas nebenaudojamas žiniatinklio platformos funkcijas galima įgalinti. Tik šiame sąraše pateiktas funkcijas galima laikinai (atsižvelgiant į funkciją) įgalinti. Bendra eilutės žymos forma [NebeteikiamosFunkcijosPavadinimas]_GaliojaIki[yyyymmdd]. Informacijos apie žiniatinklio platformos funkcijos pakeitimus galite gauti apsilankę adresu https://bit.ly/blinkintents.
      </translation>
<translation id="4442582539341804154">Įgalinti užraktą, kai įrenginys nenaudojamas arba laikinai sustabdytas</translation>
<translation id="4449545651113180484">Sukti ekraną pagal laikrodžio rodyklę 270 laipsnių kampu</translation>
<translation id="4454820008017317557">Rodyti „<ph name="PRODUCT_NAME" />“ įrankių juostos piktogramą</translation>
<translation id="4467952432486360968">Blokuoti trečiosios šalies slapukus</translation>
<translation id="4474167089968829729">Įgalinti slaptažodžių saugojimą slaptažodžių tvarkytuvėje</translation>
<translation id="4476769083125004742">Jei ši politika nustatyta į „<ph name="BLOCK_GEOLOCATION_SETTING" />“, „Android“ programos negalės pasiekti vietos informacijos. Jei šią politiką nustatysite į bet kokią kitą vertę arba jos nenustatysite, naudotojo bus paprašyta sutikti, kai „Android“ programa norės pasiekti vietovės informaciją.</translation>
<translation id="4480694116501920047">Priverstinai vykdyti saugią paiešką</translation>
<translation id="4482640907922304445">Rodomas pagrindinio puslapio mygtukas „<ph name="PRODUCT_NAME" />“ įrankių juostoje.

      Jei įgalinate šį nustatymą, pagrindinio puslapio mygtukas visada rodomas.

      Jei neleidžiate šio nustatymo, pagrindinio puslapio mygtukas niekada nerodomas.

      Jei įgalinate šį nustatymą ar jo neleidžiate, naudotojai negali jo pakeisti ar panaikinti „<ph name="PRODUCT_NAME" />“.

      Nenustačius šios politikos, naudotojas (-a) galės pasirinkti, ar rodyti pagrindinio puslapio mygtuką.</translation>
<translation id="4483649828988077221">Išjungti automatinį naujinimą</translation>
<translation id="4485425108474077672">Naujo skirtuko puslapio URL konfigūravimas</translation>
<translation id="4492287494009043413">Neleisti kurti ekrano kopijų</translation>
<translation id="450537894712826981">Konfigūruojamas talpyklos, kurią „<ph name="PRODUCT_NAME" />“ naudos talpyklos medijos failams diske saugoti, dydį.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME" />“ naudos nurodyto dydžio talpyklą nepaisydama to, ar naudotojas nurodė, ar nenurodė parametro „--media-cache-size“. Šioje politikoje nurodyta vertė nėra griežta riba, bet tiesiog pasiūlymas talpyklos sistemai. Mažesnė nei kelių megabaitų vertė yra per maža ir bus suapvalinta iki įprastos minimalios vertės.

      Jei politikos vertė nustatoma į 0, bus naudojama numatytojo dydžio talpykla, bet naudotojas negalės jos pakeisti.

      Jei ši politika nenustatyta, bus naudojamas numatytasis dydis, o naudotojas galės jį perrašyti naudodamas parametrą „--media-cache-size“.</translation>
<translation id="4508686775017063528">Jei ši politika bus nustatyta kaip „True“ arba nenustatyta, „<ph name="PRODUCT_NAME" />“ bus įgalinta ir naudotojai galės paleisti ją per programos meniu, puslapio konteksto meniu, medijos valdiklius su „Cast“ suderinamose svetainėse ir (jei rodoma) „Cast“ įrankių juostos piktogramą.

          Jei ši politika bus nustatyta kaip „False“, „<ph name="PRODUCT_NAME" />“ bus išjungta.</translation>
<translation id="4515404363392014383">Patikimų šaltinių Saugaus naršymo įgalinimas</translation>
<translation id="4518251772179446575">Paklausti kaskart, kai svetainėje bus norima stebėti naudotojo buvimo vietą</translation>
<translation id="4519046672992331730">Įgalinami paieškos pasiūlymai „<ph name="PRODUCT_NAME" />“ „Omnibox“ ir neleidžiama naudotojams keisti šio nustatymo.

      Jei įgalinate šį nustatymą, naudojami paieškos pasiūlymai.

      Jei neleidžiate šio nustatymo, paieškos pasiūlymai niekada nenaudojami.

      Jei įgalinate šį nustatymą arba jo neleidžiate, naudotojai negali jo pakeisti ar panaikinti „<ph name="PRODUCT_NAME" />“.

      Nenustačius šios politikos, tai bus įgalinta, bet naudotojas galės tai pakeisti.</translation>
<translation id="4531706050939927436">„Android“ programas galima priverstinai įdiegti iš „Google Admin Console“ naudojant „Google Play“. Jose ši politika nenaudojama.</translation>
<translation id="4534500438517478692">„Android“ ribojimo pavadinimas:</translation>
<translation id="4541530620466526913">Vietinės įrenginio paskyros</translation>
<translation id="4544079461524242527">Konfigūruojami „<ph name="PRODUCT_NAME" />“ plėtinių valdymo nustatymai.

          Pagal šią politiką valdomi keli nustatymai, įskaitant nustatymus, valdomus pagal bet kokią esamą su plėtiniais susijusią politiką. Ši politika pakeis bet kokią pasenusią politiką, jei abi yra nustatytos.

          Ši politika susieja plėtinio ID ar naujinio URL su konfigūracija. Naudojant plėtinio ID, konfigūracija bus taikoma tik nurodytam plėtiniui. Galima nustatyti specialaus ID <ph name="DEFAULT_SCOPE" /> numatytąją konfigūraciją, taikomą visiems plėtiniams, kurių tinkinta konfigūracija nenustatyta šioje politikoje. Naudojant naujinio URL, konfigūracija bus taikoma visiems plėtiniams su tiksliu naujinio URL, pateiktu šio plėtinio apraše, kaip nurodyta <ph name="LINK_TO_EXTENSION_DOC1" />.

          Jei norite peržiūrėti visą galimų šios politikos nustatymų ir struktūros aprašą, apsilankykite adresu https://www.chromium.org/administrators/policy-list-3/extension-settings-full
          </translation>
<translation id="4554651132977135445">Naudotojo politikos atgalinio ciklo apdorojimo režimas</translation>
<translation id="4554841826517980623">Ši politika valdo, ar „<ph name="PRODUCT_NAME" />“ tinklo failų bendrinimo įrenginių funkcija turėtų naudoti „<ph name="NETBIOS_PROTOCOL" />“, kad atrastų bendrinimus tinkle.
      Kai ši politika nustatyta kaip „Tiesa“, bendrinimo įrenginys naudos protokolą „<ph name="NETBIOS_PROTOCOL" />“, kad atrastų bendrinimus tinkle.
      Kai ši politika nustatyta kaip „Netiesa“, bendrinimo įrenginys nenaudos protokolo „<ph name="NETBIOS_PROTOCOL" />“, kad atrastų bendrinimus.
      Nenustačius politikos numatytoji vertė yra išjungta įmonių valdomiems naudotojams ir įgalinta nevaldomiems naudotojams.</translation>
<translation id="4555850956567117258">Įgalinti nuotolinį naudotojo patvirtinimą</translation>
<translation id="4557134566541205630">Numatytojo paieškos teikėjo naujo skirtuko puslapio URL</translation>
<translation id="4567137030726189378">Leidimas naudoti kūrėjo įrankius</translation>
<translation id="4600786265870346112">Įgalinti didelį žymeklį</translation>
<translation id="4604931264910482931">Savosios susirašinėjimo pranešimais programos juodojo sąrašo konfigūravimas</translation>
<translation id="4613508646038788144">Jei politika nustatyta į „false“, trečiosios šalies programinei įrangai bus leidžiama įdėti vykdomąjį kodą į „Chrome“ procesus. Jei politika nenustatyta arba nustatyta į „true“, trečiosios šalies programinei įrangai nebus leidžiama įdėti vykdomojo kodo į „Chrome“ procesus.</translation>
<translation id="4617338332148204752">Praleisti metažymų tikrinimą „<ph name="PRODUCT_FRAME_NAME" />“</translation>
<translation id="4625915093043961294">Konfigūruoti plėtinių diegimo baltąjį sąrašą</translation>
<translation id="4632343302005518762">Leisti „<ph name="PRODUCT_FRAME_NAME" />“ naudoti nurodytų tipų turinį</translation>
<translation id="4632566332417930481">Draudimas naudoti kūrėjo įrankius pagal įmonės politiką įdiegtuose plėtiniuose ir leidimas juos naudoti esant kitam kontekstui</translation>
<translation id="4633786464238689684">Numatytasis viršutinės eilutės klavišų veikimas pakeičiamas į funkcijų klavišus.

          Nustačius šią politiką į „true“, pagal numatytuosius nustatymus klaviatūros viršutinės eilutės klavišai vykdys funkcijų klavišų komandas. Norint, kad jie vėl veiktų kaip medijos klavišai, reikia paspausti paieškos klavišą.

          Nustačius šią politiką į „false“ arba jos nenustačius, pagal numatytuosius nustatymus klaviatūra bus vykdomos medijos klavišų komandos ir funkcijų klavišų komandos, laikant nuspaudus paieškos klavišą.</translation>
<translation id="4639407427807680016">Savųjų susirašinėjimo pranešimais programų prieglobų, kurios bus išskirtos iš juodojo sąrašo, pavadinimai</translation>
<translation id="4650759511838826572">Neleisti URL protokolų schemų</translation>
<translation id="465099050592230505">Įmonės internetinės parduotuvės URL (nebenaudojama)</translation>
<translation id="4665897631924472251">Plėtinių valdymo nustatymai</translation>
<translation id="4668325077104657568">Numatytasis vaizdų nustatymas</translation>
<translation id="4671708336564240458">Leidžia nustatyti, ar draudžiama svetainėms, kuriose užfiksuota piktnaudžiavimo atvejų, atidaryti naujus langus ar skirtukus.

      Jei šiai politikai priskirta vertė „True“, svetainėms, kuriose užfiksuota piktnaudžiavimo atvejų, nebus leidžiama atidaryti naujų langų ar skirtukų.
      Tačiau ši elgsena negalios, jei politikai „SafeBrowsingEnabled“ priskirta vertė „False“.
      Jei šiai politikai priskirta vertė „False“, svetainėms, kuriose užfiksuota piktnaudžiavimo atvejų, bus leidžiama atidaryti naujus langus ar skirtukus.
      Jei ši politika paliekama nenustatyta, taikoma vertė „True“.</translation>
<translation id="467236746355332046">Palaikomos funkcijos:</translation>
<translation id="4674167212832291997">Tinkinkite URL šablonų, kurie visada turėtų būti pateikti naudojant „<ph name="PRODUCT_FRAME_NAME" />“, sąrašą.

          Nenustačius šios politikos visose svetainėse bus naudojamas numatytasis pateikėjas, kaip nurodyta politikoje „ChromeFrameRendererSettings“.

          Šablonų pavyzdžių pateikiama apsilankius adresu https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="467449052039111439">Atidaryti URL sąrašą</translation>
<translation id="4680936297850947973">Nebenaudojama M68. Naudokite numatytąjį iššokančiųjų langų nustatymą.

      Visas paaiškinimas pateiktas adresu https://www.chromestatus.com/features/5675755719622656.
      Jei ši politika įgalinta, svetainėms bus leidžiama vienu metu naršyti ir atidaryti naujus langus / skirtukus.
      Jei ši politika išjungta arba nenustatyta, svetainėms nebus leidžiama vienu metu naršyti ir atidaryti naujų langų / skirtukų.</translation>
<translation id="4680961954980851756">Įgalinti automatinį pildymą</translation>
<translation id="4703402283970867140">Įgalinti išmanųjį pritemdymo modelį, kad būtų pratęstas laikas iki ekrano pritemdymo</translation>
<translation id="4722122254122249791">Įgalinti konkrečių šaltinių svetainių atskyrimą</translation>
<translation id="4722399051042571387">Jei ši politika nustatyta į „false“, naudotojai negalės nustatyti PIN kodų, kurie yra nesaugūs ir lengvai atspėjami.

          Nesaugių PIN kodų pavyzdžiai: tik iš vieno skaitmens sudaryti PIN kodai (1111), PIN kodai, kurių skaitmenys didėja 1 (1234), PIN kodai, kurių skaitmenys mažėja 1 (4321), ir dažnai naudojami PIN kodai.

          Pagal numatytuosius nustatymus naudotojai matys įspėjimą, o ne klaidą, jei PIN kodas bus laikomas nesaugiu.</translation>
<translation id="4723829699367336876">Įgalinti užkardos apėjimą iš nuotolinės prieigos kliento programos</translation>
<translation id="4725528134735324213">„Android“ atsarginio kopijavimo paslaugos įgalinimas</translation>
<translation id="4725801978265372736">Reikalauti, kad atitiktų vietinio naudotojo ir nuotolinės prieigos prieglobos serverio savininko vardai</translation>
<translation id="4733471537137819387">Politika, susijusi su integruotuoju HTTP tapatumo nustatymu.</translation>
<translation id="4744190513568488164">Serveriai, į kuriuos „<ph name="PRODUCT_NAME" />“ gali pervesti.

          Kelis serverių pavadinimus atskirkite kableliais. Leidžiama naudoti pakaitos simbolius (*).

          Jei nenustatysite šios politikos, „<ph name="PRODUCT_NAME" />“ neperduos naudotojo prisijungimo duomenų, net jei aptinkama, kad serveris yra intranete.</translation>
<translation id="4752880493649142945">Kliento sertifikatas, skirtas prisijungti prie „RemoteAccessHostTokenValidationUrl“</translation>
<translation id="4757671984625088193">Jei šis nustatymas nustatytas kaip „true“ arba nenustatytas, „<ph name="PRODUCT_NAME" />“ siūlys puslapius, susijusius su dabartiniu.
      Šie siūlymai gaunami nuotoliniu būdu iš „Google“ serverių.

      Jei šis nustatymas nustatytas kaip „false“, siūlymai nebus gaunami ar pateikiami.</translation>
<translation id="4788252609789586009">Įgalinama „<ph name="PRODUCT_NAME" />“ automatinio pildymo funkcija ir naudotojams leidžiama automatiškai užpildyti žiniatinklio formas, naudojant anksčiau išsaugotą informaciją, pvz., kredito kortelės informaciją.

      Jei šis nustatymas išjungtas, Automatinio pildymo funkcija niekada nesiūlys ir automatiškai nepildys kredito kortelės informacijos, taip pat neišsaugos papildomos kredito kortelės informacijos, kurią naudotojas gali pateikti naršydamas žiniatinklyje.

      Jei šis nustatymas įgalintas arba vertė nenustatyta, naudotojas galės valdyti kredito kortelių informacijos Automatinio pildymo funkciją naudotojo sąsajoje.</translation>
<translation id="4791031774429044540">Įgalinti didelio žymeklio pasiekiamumo funkciją.

          Jei ši politika galioja, didelis žymeklis bus visada įgalintas.

          Jei ši politika negalioja, didelis žymeklis bus visada išjungtas.

          Jei nustatysite šią politiką, naudotojai negalės jos keisti arba nepaisyti.
          Jei ši politika nenustatyta, didelis žymeklis bus išjungtas, bet naudotojas galės jį bet kuriuo metu įgalinti.</translation>
<translation id="4802905909524200151"><ph name="TPM_FIRMWARE_UPDATE_TPM" /> programinės aparatinės įrangos atnaujinimo elgsenos konfigūravimas</translation>
<translation id="4807950475297505572">Naudotojai, kurie jungėsi seniausiai, šalinami, kol atsiras pakankamai laisvos vietos</translation>
<translation id="4815725774537609998">Ši politika nebenaudojama, vietoj jos naudokite „ProxyMode“.

          Leidžiama nurodyti „<ph name="PRODUCT_NAME" />“ naudojamą tarpinį serverį ir neleidžiama naudotojams keisti tarpinio serverio nustatymų.

          Jei pasirinksite niekada nenaudoti tarpinio serverio ir visada prisijungti tiesiogiai, visų kitų parinkčių bus nepaisoma.

          Jei pasirinksite naudoti sistemos tarpinio serverio nustatymus arba automatiškai aptikti tarpinį serverį, visų kitų parinkčių bus nepaisoma.

          Jei pasirinksite neautomatinius tarpinio serverio nustatymus, galėsite nurodyti kitus nustatymus pasirinkę „Tarpinio serverio adresą ir URL“, „Tarpinio serverio .pac failo URL“ ir „Kableliais atskirtų tarpinio serverio nepaisymo taisyklių sąrašą“. Tik aukščiausio prioriteto HTTP tarpinis serveris pasiekiamas ARC programose.

          Išsamių pavyzdžių galite rasti apsilankę adresu
          <ph name="PROXY_HELP_URL" />.

          Jei įgalinsite šį nustatymą, „<ph name="PRODUCT_NAME" />“ nepaisys visų komandų eilutėje nurodytų su tarpiniu serveriu susijusių parinkčių.

          Jei paliksite šią politiką nenustatytą, naudotojai galės patys pasirinkti tarpinio serverio nustatymus.</translation>
<translation id="4816674326202173458">Leisti įmonės naudotojui būti pirminiu ir antriniu (numatytoji elgsena nevaldomiems naudotojams)</translation>
<translation id="4826326557828204741">Veiksmas, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas, veikiant iš akumuliatoriaus energijos</translation>
<translation id="4834526953114077364">Naudotojai, kurie jungėsi seniausiai ir kurie nebuvo prisijungę per paskutinius 3 mėnesius, šalinami, kol atsiras pakankamai laisvos vietos</translation>
<translation id="4858735034935305895">Leisti viso ekrano režimą</translation>
<translation id="4861767323695239729">Naudotojo sesijoje leidžiamų įvesties metodų konfigūravimas</translation>
<translation id="487460824085252184">Perkeliama automatiškai, neprašant naudotojo sutikimo.</translation>
<translation id="4874982543810021567">„WebUSB“ blokavimas šiose svetainėse</translation>
<translation id="4876805738539874299">Maksimali SSL versija įgalinta</translation>
<translation id="4897928009230106190">Nurodomi parametrai, naudojami atliekant pasiūlymų paiešką naudojant POST. Jie sudaryti iš kableliais atskirtų pavadinimų / verčių porų. Jei vertė yra šablono parametras, pvz., {searchTerms} anksčiau pateiktame pavyzdyje, ji pakeičiama realiais paieškos terminų duomenimis.

          Ši politika pasirenkama. Jei nenustatyta, siūlomos paieškos užklausa siunčiama naudojant GET metodą.

          Šios politikos laikomasi, tik jei įgalinta politika „DefaultSearchProviderEnabled“.</translation>
<translation id="489803897780524242">Parametras, valdantis numatytojo paieškos teikėjo paieškos termino paskirties vietą</translation>
<translation id="4899708173828500852">Įgalinti saugų naršymą</translation>
<translation id="4899802251198446659">Leidžiama valdyti, ar sistemoje „<ph name="PRODUCT_NAME" />“ vaizdo įrašus galima leisti automatiškai (be naudotojo sutikimo) su garso įrašo turiniu.

      Jei politika nustatyta į „True“, „<ph name="PRODUCT_NAME" />“ leidžiama automatiškai leisti mediją.
      Jei politika nustatyta į „False“, „<ph name="PRODUCT_NAME" />“ neleidžiama automatiškai leisti medijos. Naudojant politiką „AutoplayWhitelist“ galima nurodyti nepaisyti šio nustatymo tam tikrus URL šablonus atitinkančiuose puslapiuose.
      Pagal numatytuosius nustatymus „<ph name="PRODUCT_NAME" />“ neleidžiama automatiškai leisti medijos.

      Atminkite, kad pakeitus šią politiką veikiant „<ph name="PRODUCT_NAME" />“, ji bus taikoma tik naujuose atidarytuose skirtukuose. Todėl kai kuriuose skirtukuose gali išlikti ankstesnė elgsena.
      </translation>
<translation id="4906194810004762807">Atnaujinti įrenginio politikos dažnį</translation>
<translation id="4917385247580444890">Stiprus</translation>
<translation id="4923806312383904642">Leisti „WebDriver“ perrašyti nesuderinamas politikos nuostatas</translation>
<translation id="494613465159630803">Cast Receiver</translation>
<translation id="4962262530309732070">Jei ši politika nustatyta į „true“ arba yra nesukonfigūruota, „<ph name="PRODUCT_NAME" />“ leis „Pridėti asmenį“ naudojant naudotojų tvarkytuvę.

      Jei ši politika nustatyta į „false“, „<ph name="PRODUCT_NAME" />“ neleis kurti naujų profilių naudojant naudotojų tvarkytuvę.</translation>
<translation id="4970855112942626932">Naršyklės prisijungimo išjungimas</translation>
<translation id="4971529314808359013">Jums leidžiama nurodyti URL šablonų sąrašą, nurodantį, kurioms svetainėms „<ph name="PRODUCT_NAME" />“ turi automatiškai pasirinkti kliento sertifikatą (jei svetainėje jo reikalaujama).

          Vertė turi būti eilutėmis suskirstytų JSON žodynų masyvas. Kiekvienas žodynas turi būti tokios formos: { "pattern": "$URL_PATTERN", "filter" : $FILTER }, kur $URL_PATTERN yra turinio nustatymo šablonas. $FILTER apriboja, iš kurių klientų sertifikatų naršyklė automatiškai pasirinks. Neatsižvelgiant į filtrą, bus pasirinkti tik tie sertifikatai, kurie atitinka serverio sertifikato užklausą. Jei $FILTER yra tokios formos: { "ISSUER": { "CN": "$ISSUER_CN" } }, papildomai pasirenkami tik klientų sertifikatai, kurie išduoti pagal sertifikatą, kurio „CommonName“ $ISSUER_CN. Jei $FILTER yra tuščias žodynas {}, klientų sertifikatų pasirinkimas nėra papildomai ribojamas.

          Nenustačius šios politikos, jokioje svetainėje nėra atliekamas joks automatinis pasirinkimas.</translation>
<translation id="4978405676361550165">Nustačius politiką „OffHours“ nustatytais laiko intervalais nepaisoma nurodytos įrenginio politikos (naudojami numatytieji šios politikos nustatymai). Įrenginio politiką „Chrome“ pakartotinai pritaiko per kiekvieną įvykį, kai „OffHours“ laikotarpis prasideda ir baigiasi. Naudotojams bus pranešta ir jie bus priverstinai atjungti, kai „OffHours“ laikas pasibaigs ir įrenginio politikos nustatymai bus pakeisti (pvz., kai naudotojas bus prisijungęs su neleidžiama paskyra).</translation>
<translation id="4980635395568992380">Duomenų tipas:</translation>
<translation id="4983201894483989687">Leisti paleisti pasenusius papildinius</translation>
<translation id="4988291787868618635">Veiksmas, kuris bus atliktas, kai bus pasiektas neveikos delsos laikas</translation>
<translation id="4995548127349206948">Ar įgalintas „NTLMv2“ autentifikavimas.</translation>
<translation id="5047604665028708335">Leisti pasiekti svetaines, nesančias turinio paketuose</translation>
<translation id="5052081091120171147">Pagal šią politiką naršymo istorija priverstinai importuojama iš esamos numatytosios naršyklės (jei įgalinta). Be to, jei įgalinta, ši politika turi įtakos importavimo dialogo langui.

      Jei neleidžiama, neimportuojama jokia naršymo istorija.

      Jei nenustatyta, naudotojo gali būti klausiama, ar importuoti, arba gali būti automatiškai importuojama.</translation>
<translation id="5056708224511062314">Ekrano didinimas išjungtas</translation>
<translation id="5058573563327660283">Pasirinkti strategiją, naudojamą vietai diske atlaisvinti, kai atliekamas automatinis valymas (nebenaudojama)</translation>
<translation id="5067143124345820993">Prisijungusių naudotojų baltasis sąrašas</translation>
<translation id="5068140065960598044">Taikant „<ph name="PRODUCT_NAME" />“ debesies politiką įrenginio politikos nebepaisoma.</translation>
<translation id="5085647276663819155">Neleisti spaudinio peržiūros</translation>
<translation id="5090209345759901501">Pritaikyti „Flash“ turinio nustatymą visam turiniui</translation>
<translation id="5093540029655764852">Nurodomas dažnis (dienomis), kuriuo klientas keičia savo įrenginio paskyros slaptažodį. Slaptažodį atsitiktinai sugeneruoja klientas ir jis nerodomas naudotojui.

      Įrenginių slaptažodžius reikia reguliariai keisti, kaip ir naudotojų slaptažodžius. Išjungus šią politiką ar nustatymą, didelis dienų skaičius gali neigiamai paveikti saugą, nes potencialiems užpuolėjams suteikiama daugiau laiko surasti įrenginio paskyros slaptažodį ir jį naudoti.

      Nenustačius šios politikos, įrenginio paskyros slaptažodis keičiamas kas 30 dienų.

      Nustačius politikos vertę į 0, įrenginio slaptažodžio keitimas išjungiamas.

      Atminkite, kad slaptažodžiai gali būti senesni nei nurodytas dienų skaičius, jei klientas neprisijungia ilgesnį laikotarpį.</translation>
<translation id="5105313908130842249">Ekrano užrakto delsa, kai naudojama akumuliatoriaus energija</translation>
<translation id="5108031557082757679">Išjungti įmonės įrenginių spausdintuvai</translation>
<translation id="5130288486815037971">Ar įgalinti RC4 šifruotieji programų komplektai TLS</translation>
<translation id="5141670636904227950">Nustatyti numatytąjį ekrano didinimo tipą, kuris įgalintas prisijungimo ekrane</translation>
<translation id="5142301680741828703">„<ph name="PRODUCT_FRAME_NAME" />“ visada pateikti šiuos URL šablonus</translation>
<translation id="5148753489738115745">Leidžia nurodyti papildomus parametrus, naudojamus, kai „<ph name="PRODUCT_FRAME_NAME" />“ paleidžia „<ph name="PRODUCT_NAME" />“.

          Nenustačius šios politikos bus naudojama numatytoji komandinė eilutė.</translation>
<translation id="5159469559091666409">Stebėjimo tinklo paketų siuntimo dažnis milisekundėmis.

      Jei ši politika nenustatyta, numatytasis intervalas bus 3 minutės. Minimalus
      intervalas yra 30 sekundžių, maksimalus – 24 valandos. Už šio diapazono
      esančios vertės bus nustatytos į šio diapazono vertę.</translation>
<translation id="5163002264923337812">Įgalinti seną žiniatinkliu pagrįstą prisijungimo eigą</translation>
<translation id="5182055907976889880">Konfigūruokite „Google“ diską „<ph name="PRODUCT_OS_NAME" />“.</translation>
<translation id="5183383917553127163">Leidžiama nurodyti, kurie plėtiniai neturi būti įtraukti į juodąjį sąrašą.

          Juodojo sąrašo vertė „*“ nurodo, kad visi plėtiniai yra įtraukti į juodąjį sąrašą, o naudotojai gali diegti tik į baltąjį sąrašą įtrauktus plėtinius.

          Pagal numatytuosius nustatymus visi plėtiniai yra įtraukti į baltąjį sąrašą, bet jei visi plėtiniai į juodąjį sąrašą buvo įtraukti todėl, kad to reikalavo politika, naudojant baltąjį sąrašą politikos galima nepaisyti.</translation>
<translation id="519247340330463721">Su Saugaus naršymo funkcija susijusių politikos nuostatų konfigūravimas.</translation>
<translation id="5192837635164433517">Įgalinamas alternatyvių klaidų puslapių, integruotų „<ph name="PRODUCT_NAME" />“ (pvz., „puslapis nerastas“), naudojimas ir neleidžiama naudotojams keisti šio nustatymo.

      Jei įgalinate šį nustatymą, naudojami alternatyvūs klaidų puslapiai.

      Jei neleidžiate šio nustatymo, alternatyvūs klaidų puslapiai niekada nenaudojami.

      Jei įgalinate šį nustatymą arba jo neleidžiate, naudotojai negali jo pakeisti ar panaikinti „<ph name="PRODUCT_NAME" />“.

      Nenustačius šios politikos, tai bus įgalinta, bet naudotojas (-a) galės tai pakeisti.</translation>
<translation id="5196805177499964601">Blokuoti kūrėjo režimą.

      Jei šios politikos nuostata nustatyta į „Taip“, „<ph name="PRODUCT_OS_NAME" />“ neleis paleisti įrenginio kūrėjo režimu. Sistema nebus paleista ir bus rodomas klaidos ekranas, įjungus kūrėjo jungiklį.

      Jei ši politika nenustatyta ar nustatyta „Ne“, kūrėjo režimas liks pasiekiamas įrenginiui.</translation>
<translation id="520403427390290017">Skirtukų naudojimo trukmės funkcija atlaisvina centrinį procesorių ir atmintį, susietą su veikiančiais skirtukais, kurie buvo nenaudojami ilgą laiką. Pirma, reguliuojamas skirtukų veikimas, tada jie sustabdomi ir galiausiai atmetami.

      Jei politika nustatyta į „false“, skirtukų naudojimo trukmės funkcija bus išjungta, o visi skirtukai veiks įprastai.

      Jei politika nustatyta į „true“ arba nenurodyta, skirtukų naudojimo trukmės funkcija bus įgalinta.</translation>
<translation id="5208240613060747912">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose neleidžiama pateikti pranešimų, sąrašą.

          Nenustačius šios politikos, visose svetainėse naudojama visuotinė numatytoji vertė iš politikos „Numatytasis pranešimų nustatymas“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="5219844027738217407">„Android“ programose ši politika turi įtakos tik mikrofonui. Kai ši politika nustatyta į „Tiesa“, mikrofonas be išimčių nutildomas visose „Android“ programose.</translation>
<translation id="5228316810085661003">Vietinės įrenginio paskyros automatinio prisijungimo delsa.

      Jei nenustatyta politika |DeviceLocalAccountAutoLoginId|, ji negalioja. Toliau nurodyti kiti atvejai.

      Jei ši politika nustatyta, ji nurodo laiką be naudotojo veiksmų, kuriam praėjus bus automatiškai prijungiama prie vietinės įrenginio paskyros, kuri apibrėžiama pagal politiką |DeviceLocalAccountAutoLoginId|.

      Jei ši politika nenustatyta, skirtajam laikui bus naudojama 0 milisekundžių.

      Ši politika nurodoma milisekundėmis.</translation>
<translation id="523505283826916779">Pasiekiamumo nustatymai</translation>
<translation id="5247006254130721952">Blokuoti pavojingus atsisiuntimus</translation>
<translation id="5248863213023520115">Nustatomi šifruotės tipai, kurie leidžiami teikiant „Kerberos“ bilietų užklausas iš „<ph name="MS_AD_NAME" />“ serverio.

      Jei politika nustatyta kaip „Visi“, leidžiami abu AES šifruotės tipai „aes256-cts-hmac-sha1-96“ ir „aes128-cts-hmac-sha1-96“ bei RC4 šifruotės tipas „rc4-hmac“. Jei serveris palaiko abu tipus, pirmenybė teikiama AES šifruotei. Atminkite, kad RC4 yra nesaugi, todėl, jei įmanoma, serverį reikėtų sukonfigūruoti iš naujo, kad palaikytų AES šifruotę.

      Jei politika nustatyta kaip „Stipri“ arba jei nenustatyta, leidžiami tik AES šifruotės tipai.

      Jei politika nustatyta kaip „Pasenusi“, leidžiamas tik RC4 šifruotės tipas. Ši parinktis nesaugi ir turėtų būti naudojama tik labai konkrečiomis aplinkybėmis.

      Taip pat žr. https://wiki.samba.org/index.php/Samba_4.6_Features_added/changed#Kerberos_client_encryption_types.</translation>
<translation id="5255162913209987122">Gali būti rekomenduojama</translation>
<translation id="527237119693897329">Leidžiama nurodyti, kurios savųjų susirašinėjimo pranešimais programų prieglobos neturėtų būti įkeliamos.

          Juodojo sąrašo vertė „*“ reiškia, kad visos savųjų susirašinėjimo pranešimais programų prieglobos yra įtrauktos į juodąjį sąrašą, išskyrus tuos atvejus, kai jos įtrauktos į baltąjį sąrašą.

          Jei politika nenustatyta, „<ph name="PRODUCT_NAME" />“ įkels visas įdiegtas savųjų susirašinėjimo pranešimais programų prieglobas.</translation>
<translation id="5272684451155669299">Jei ši politika galioja, naudotojas gali naudoti aparatinę įrangą „Chrome“ įrenginiuose, kad nuotoliniu būdu patvirtintų tapatybę pagal privatumo CA per „<ph name="ENTERPRISE_PLATFORM_KEYS_API" />“ naudodamas <ph name="CHALLENGE_USER_KEY_FUNCTION" />.

          Jei ši politika negalioja arba nenustatyta, iškviečiant API įvyks klaida ir bus pateiktas jos kodas.</translation>
<translation id="5277806246014825877">Leidžiama šiam naudotojui paleisti „Crostini“.

      Jei politika nustatyta kaip „Netiesa“, „Crostini“ neįgalinta naudotojui.
      Jei nustatyta kaip „Tiesa“ arba palikta nenustatyta, „Crostini“ įgalinta naudotojui, jei tai taip pat leidžiama pagal į kitus nustatymus.
      Visų trijų tipų politika („VirtualMachinesAllowed“, „CrostiniAllowed“ ir „DeviceUnaffiliatedCrostiniAllowed“) turi būti nustatyta kaip „Tiesa“, kai taikoma „Crostini“, kad būtų leidžiama vykdyti.
      Kai ši politika pakeičiama į „Netiesa“, ji taikoma paleidžiant naujus „Crostini“ sudėtinius rodinius, bet nesustabdo jau vykdomų sudėtinių rodinių.</translation>
<translation id="5283457834853986457">Papildinių paieškos priemonės išjungimas (nebenaudojama)</translation>
<translation id="5288772341821359899">Jei ši politika nustatyta, „WebRTC“ naudojamas UDP prievado diapazonas apribojamas iki nurodyto prievado intervalo (įskaitant baigties taškus).

      Jei politika nenustatyta arba nustatyta į tuščią eilutę arba negaliojantį prievado diapazoną, „WebRTC“ leidžiama naudoti bet kokį pasiekiamą vietinį UDP prievadą.</translation>
<translation id="5290940294294002042">Nurodyti papildinių, kuriuos naudotojas gali įgalinti arba kurių gali neleisti, sąrašą</translation>
<translation id="5304269353650269372">Nurodoma, kiek turi praeiti laiko nuo to, kai naudotojas nieko neįveda, kad būtų rodomas įspėjamasis dialogo langas, kai naudojama akumuliatoriaus energija.

          Kai ši politika nustatyta, ji nurodo, kiek laiko naudotojas turi neatlikti jokių veiksmų, kol „<ph name="PRODUCT_OS_NAME" />“ parodys įspėjamąjį dialogo langą, pranešantį, kad bus atliekamas neveikos atveju numatytas veiksmas.

          Kai ši politika nenustatyta, nerodomas joks įspėjamasis dialogo langas.

          Politikos vertė turėtų būti nurodyta milisekundėmis. Vertės apdorojamos, kad nebūtų didesnės nei neaktyvumo delsos laiko vertės.</translation>
<translation id="5307432759655324440">Inkognito režimo pasiekiamumas</translation>
<translation id="5318185076587284965">Įgalinti perdavimo serverių naudojimą per nuotolinės prieigos prieglobą</translation>
<translation id="5323128137188992869">Leidimas perduoti turinį į įrenginį naudojant „<ph name="PRODUCT_NAME" />“.

          Jei ši politika nustatyta kaip „False“ (netiesa), naudotojai negalės perduoti turinio į įrenginį. Jei ši politika nustatyta kaip „True“ (tiesa), naudotojai perduoti turinį galės. Jei ši politika nenustatyta, naudotojai negalės perduoti turinio į užregistruotus „Chrome“ OS įrenginius, bet galės perduoti į neužregistruotus įrenginius.</translation>
<translation id="5329007337159326804">Įspėjimas: maks. TLS versijos politika bus visiškai pašalinta iš „<ph name="PRODUCT_NAME" />“ maždaug tada, kai bus pristatyta 75 versija (maždaug 2019 m. birželio mėn.).

      Jei ši politika nesukonfigūruota, „<ph name="PRODUCT_NAME" />“ naudoja numatytąją didžiausią versiją.

      Priešingu atveju gali būti nustatyta viena iš nurodytų verčių: „tls1.2“ arba „tls1.3“. Nustačius „<ph name="PRODUCT_NAME" />“ nenaudos naujesnių nei nurodyta SSL / TLS versijų. Neatpažįstamos vertės nebus paisoma.</translation>
<translation id="5330684698007383292">Leisti „<ph name="PRODUCT_FRAME_NAME" />“ naudoti šių tipų turinį</translation>
<translation id="5365946944967967336">Rodyti įrankių juostoje pagrindinio puslapio mygtuką</translation>
<translation id="5366745336748853475">Galima sudaryti URL šablonų sąrašą, nurodantį, kurioms svetainėms prisijungimo ekrane, kur rėmelyje priglobiama SAML eiga, automatiškai pasirenkamas kliento sertifikatas (jei svetainėje jo reikalaujama). Naudojimo pavyzdys – sukonfigūruoti įrenginio sertifikatą, kad jis būtų pateiktas „SAML IdP“ eigoje.

      Vertė turi būti eilutėmis suskirstytų JSON žodynų masyvas. Kiekvienas žodynas turi būti tokios formos: { "pattern": "$URL_PATTERN", "filter" : $FILTER }, kur $URL_PATTERN yra turinio nustatymo šablonas. $FILTER apriboja, iš kurių klientų sertifikatų naršyklė automatiškai pasirinks reikiamą sertifikatą. Neatsižvelgiant į filtrą, bus pasirinkti tik tie sertifikatai, kurie atitinka serverio sertifikato užklausą. Jei $FILTER yra tokios formos: { "ISSUER": { "CN": "$ISSUER_CN" } }, papildomai pasirenkami tik klientų sertifikatai, kurie išduoti pagal sertifikatą, kurio „CommonName“ yra $ISSUER_CN. Jei $FILTER yra tuščias žodynas {}, klientų sertifikatų pasirinkimas nėra papildomai ribojamas.

      Nenustačius šios politikos, svetainėse nėra atliekamas automatinis pasirinkimas.</translation>
<translation id="5366977351895725771">Jei ši politika negalioja, šis naudotojas negalės kurti prižiūrimų naudotojų. Visi esami naudotojai bus vis tiek pasiekiami.

          Jei ši politika galioja arba yra nesukonfigūruota, šis naudotojas gali kurti ir valdyti prižiūrimus naudotojus.</translation>
<translation id="5369937289900051171">Tik spalvotas spausdinimas</translation>
<translation id="5370279767682621504">Įgalinti HTTP/0.9 protokolo palaikymą nenumatytuose prievaduose</translation>
<translation id="5378985487213287085">Leidžiama nustatyti, ar svetainėse leidžiama pateikti darbalaukio pranešimus. Pagal numatytuosius nustatymus gali būti leidžiama, draudžiama pateikti darbalaukio pranešimus arba naudotojo (-os) gali būti klausiama kaskart svetainėje norint rodyti darbalaukio pranešimus.

          Nenustačius šios politikos, bus naudojama „Paklausti dėl pranešimų“ ir naudotojas (-a) galės tai pakeisti.</translation>
<translation id="538108065117008131">Leisti „<ph name="PRODUCT_FRAME_NAME" />“ naudoti šio tipo turinį.</translation>
<translation id="5391388690191341203">Automatiškai prisijungiant naudojama vietinė įrenginio paskyra</translation>
<translation id="5392172595902933844">Informacija apie „Android“ būseną siunčiama atgal į 
      serverį.

      Jei politika nustatyta į „False“ arba nenustatyta, būsenos informacija nepranešama.
      Jei nustatyta į „True“, būsenos informacija pranešama.

      Ši politika taikoma tik įgalinus „Android“ programas.</translation>
<translation id="5395271912574071439">Įgalina nuotolinės prieigos prieglobų slėpimą, kai bandoma užmegzti ryšį.

          Jei įgalintas šis nustatymas, fiziniai prieglobos įvesties ir išvesties įrenginiai išjungiami, kai bandoma prisijungti prie nuotolinio ryšio.

          Jei šis nustatymas išjungtas arba nenustatytas, vietiniai ir nuotoliniai naudotojai gali sąveikauti su priegloba, kai ji bendrinama.</translation>
<translation id="5396049152026347991">Naudotojui leidžiama tvarkyti VPN ryšius.

      Jei ši politika nustatyta kaip „false“, visos „<ph name="PRODUCT_NAME" />“ naudotojo sąsajos, leidžiančios naudotojui atjungti arba keisti VPN ryšius, yra išjungtos.

      Jei ši politika nenustatyta arba nustatyta kaip „true“, naudotojai gali atjungti arba keisti VPN ryšius kaip įprastai.

      Jei VPN ryšys sukurtas naudojant VPN programą, ši politika neturi įtakos programos NS. Todėl gali būti, kad naudotojas vis tiek galės keisti VPN ryšį naudodamas programą.

      Ši politika skirta naudoti kartu su funkcija „Visada įjungtas VPN“, leidžiančia administratoriui užmegzti VPN ryšį paleidžiant sistemą.</translation>
<translation id="5405289061476885481">Konfigūruojama, kokie klaviatūros išdėstymai leidžiami „<ph name="PRODUCT_OS_NAME" />“ prisijungimo ekrane.

      Jei ši politika nustatyta į įvesties metodo identifikatorių sąrašą, pateikti įvesties metodai bus pasiekiami prisijungimo ekrane. Pirmas pateiktas įvesties metodas bus pasirinktas iš anksto. Kai naudotojas yra prisijungimo ekrane, be pagal šią politiką pasiekiamų metodų, bus pasiekiamas ir paskutinis naudotas įvesties metodas. Jei ši politika nenustatyta, įvesties metodai prisijungimo ekrane bus nustatyti atsižvelgiant į lokalę, kuria pateikiamas prisijungimo ekranas. Bus nepaisoma verčių, kurios nėra galiojantys įvesties metodo identifikatoriai.</translation>
<translation id="5423001109873148185">Pagal šią politiką paieškos varikliai priverstinai importuojami iš esamos numatytosios naršyklės (jei įgalinta). Be to, jei įgalinta, ši politika turi įtakos importavimo dialogo langui.

      Jei neleidžiama, numatytasis paieškos variklis neimportuojamas.

      Jei nenustatyta, naudotojo gali būti paklausta, ar importuoti, arba gali būti automatiškai importuojama.</translation>
<translation id="5423197884968724595">„Android WebView“ apribojimo pavadinimas:</translation>
<translation id="5424147596523390018">Leisti visus spalvų režimus</translation>
<translation id="5442026853063570579">Ši politika taip pat valdo galimybę pasiekti „Android“ kūrėjo parinktis. Jei šią politiką nustatysite kaip „DeveloperToolsDisallowed“ (2 vertė), naudotojai negalės pasiekti kūrėjo parinkčių. Jei nustatysite kitą šios politikos vertę arba jos nenustatysite, naudotojai galės pasiekti kūrėjo parinktis palietę versijos numerį septynis kartus „Android“ nustatymų programoje.</translation>
<translation id="5447306928176905178">Įgalinti ataskaitų teikimo atminties informaciją (JS masyvo dydžio) puslapyje (nepatvirtinta)</translation>
<translation id="5457065417344056871">Svečio režimo įgalinimas naršyklėje</translation>
<translation id="5457924070961220141">Leidžiama konfigūruoti numatytąją HTML pateikimo programą, kai įdiegta „<ph name="PRODUCT_FRAME_NAME" />“.
          Numatytasis nustatymas, kuris naudojamas, kai ši politika nenustatyta, – leisti prieglobos naršyklei atlikti pateikimo veiksmus. Bet galite tai pakeisti ir nustatyti „<ph name="PRODUCT_FRAME_NAME" />“ pagal numatytuosius nustatymus pateikti HTML puslapius.</translation>
<translation id="5464816904705580310">Konfigūruojami tvarkomų naudotojų paskyrų nustatymai.</translation>
<translation id="546726650689747237">Ekrano pritemdymo delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="5469143988693423708">Naudotojui leidžiama paleisti „Crostini“</translation>
<translation id="5469825884154817306">Blokuoti vaizdus šiose svetainėse</translation>
<translation id="5475361623548884387">Įgalinti spausdinimą</translation>
<translation id="547601067149622666">Neleisti skelbimų svetainėje su nepageidaujamais skelbimais</translation>
<translation id="5499375345075963939">Ši politika taikoma tik mažmeninės prekybos režimu.

      Kai šios politikos vertė nustatyta ir nėra 0, dabartinis prisijungęs demonstracinės versijos naudotojas (-a) automatiškai atjungiamas (-a) pasibaigus nurodytos trukmės neveiklos laikotarpiui.

      Politikos vertę reikia nurodyti milisekundėmis.</translation>
<translation id="5511702823008968136">Įgalinti žymių juostą</translation>
<translation id="5512418063782665071">Pagrindinio puslapio URL</translation>
<translation id="551639594034811656">Ši politika apibrėžia procentinių verčių sąrašą, kur nurodoma OV įrenginių dalis („<ph name="PRODUCT_OS_NAME" />“), kurie bus atnaujinti per savaitę nuo pirmos naujinio aptikimo dienos. Aptikimo laikas yra vėlesnis nei naujinio paskelbimo laikas, nes paskelbus naujinį įrenginys gali tikrinti, ar yra naujinių, tik po tam tikro laiko

      Kiekviena pora (diena, procentinė vertė) nurodo, kokia srauto procentinė dalis turi būti atnaujinta praėjus nurodytam skaičiui dienų nuo naujinio aptikimo dienos. Pvz., jei turime poras [(4, 40), (10, 70), (15, 100)], reiškia, 40 proc. srauto turi būti atnaujinta praėjus 4 dienoms nuo naujinio peržiūros dienos, 70 proc. turėtų būti atnaujinta praėjus 10 dienų ir t. t.

      Jei šios politikos vertė nustatyta, naujiniai nepaisys politikos „<ph name="DEVICE_UPDATE_SCATTER_FACTOR_POLICY_NAME" />“ ir vietoje to atsižvelgs į šią politiką.

      Jei šis sąrašas tuščias, etapinis diegimas nebus naudojamas, o naujiniai bus pritaikyti atsižvelgiant į kitas įrenginių politikos nuostatas.

      Ši politika netaikoma keičiant kanalus.</translation>
<translation id="5526701598901867718">Visi (nesaugūs)</translation>
<translation id="5529037166721644841">Milisekundėmis nurodomas laikotarpis, per kurį įrenginio tvarkymo paslaugai pateikiama užklausa dėl įrenginio politikos informacijos.

      Nustačius šią politiką nepaisoma numatytosios 3 valandų vertės. Tinkamos šios politikos vertės svyruoja nuo 1 800 000 (30 minučių) iki 86 400 000 (1 diena). Vertės už šio diapazono ribų bus nustatytos į šio diapazono vertę.

      Jei ši politika nebus nustatyta, „<ph name="PRODUCT_OS_NAME" />“ naudos numatytąją vertę – 3 val.

      Atminkite, kad jei platformoje palaikomi politikos pranešimai, atnaujinimo delsa bus nustatyta į 24 val. (bus nepaisoma visų numatytųjų nustatymų ir šios politikos vertės), nes tikimasi, kad politikos pranešimai automatiškai suaktyvins atnaujinimą kaskart, kai politika bus pakeista, todėl nereikės dažniau atnaujinti.</translation>
<translation id="5530347722229944744">Blokuoti potencialiai pavojingus atsisiuntimus</translation>
<translation id="5535973522252703021">„Kerberos“ nukreipimo serverio baltasis sąrašas</translation>
<translation id="555077880566103058">Leisti visoms svetainėms automatiškai paleisti papildinį „<ph name="FLASH_PLUGIN_NAME" />“</translation>
<translation id="5559079916187891399">Ši politika neturi įtakos „Android“ programoms.</translation>
<translation id="5560039246134246593">Pridėkite variantų pirminės reikšmės pateikimo apribojimą „<ph name="PRODUCT_NAME" />“.

      Jei jis nurodytas, prie pateikiant variantų pirminę reikšmę naudojamo URL bus pridėtas URL parametras „restrict“. Parametro vertė bus šioje politikoje nustatyta vertė.

      Jei ši politika nenustatyta, variantų pirminės reikšmės URL keičiamas nebus.</translation>
<translation id="5561811616825571914">Automatiškai pasirenkami šių svetainių klientų sertifikatai prisijungimo ekrane</translation>
<translation id="556941986578702361">Valdomas automatinis „<ph name="PRODUCT_OS_NAME" />“ lentynos paslėpimas.

      Jei ši politika nustatyta kaip „Visada automatiškai paslėpti lentyną“, lentyna visada automatiškai paslepiama.

      Jei ši politika nustatyta kaip „Niekada automatiškai neslėpti lentynos“, lentyna niekada automatiškai neslepiama.

      Jei nustatysite šią politiką, naudotojai negalės jos pakeisti arba nepaisyti.

      Jei ši politika nenustatyta, naudotojai gali pasirinkti, ar lentyną automatiškai paslėpti.</translation>
<translation id="557360560705413259">Kai šis nustatymas įgalintas, „<ph name="PRODUCT_NAME" />“ naudos serverio sertifikato parametrą „commonName“ prieglobos serverio pavadinimui nustatyti, jei sertifikate trūksta plėtinio „subjectAlternativeName“ ir jis sėkmingai patvirtinamas bei atitinka vietiniu mastu įdiegtų CA sertifikatų grandinę.

      Atminkite, kad tai nerekomenduojama, nes taip gali būti apeinamas plėtinys „nameConstraints“, apribojantis prieglobos serverių pavadinimus, kuriems gali būti skirtas atitinkamas sertifikatas.

      Jei ši politika nenustatyta arba nustatyta į „False“, serverio sertifikatai be plėtinio „subjectAlternativeName“, kuriuose yra DNS pavadinimas arba IP adresas, nebus laikomi patikimais.</translation>
<translation id="5581292529942108810">Konfigūruojama su „Chrome“ ataskaitų teikimo plėtiniu susijusi politika.

      Ši politika galioja, tik kai įgalintas „<ph name="CHROME_REPORTING_EXTENSION_NAME" />“ ir įrenginyje užregistruota „<ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />“.</translation>
<translation id="5584132346604748282">Valdomos „Android“ skirtos „Google“ vietovių paslaugos</translation>
<translation id="5586942249556966598">Nieko nedaryti</translation>
<translation id="5630352020869108293">Atkurti paskutinę sesiją</translation>
<translation id="5645779841392247734">Leisti slapukus šiose svetainėse</translation>
<translation id="5689430183304951538">Numatytasis spausdinamo puslapio dydis</translation>
<translation id="5693469654327063861">Leisti perkelti duomenis</translation>
<translation id="5694594914843889579">Kai ši politika nustatyta į „true“, išorinė saugykla nepasiekiama failų naršyklėje.

      Ši politika turi įtakos visų tipų saugyklos medijai. Pvz., USB atmintinėms, išoriniams standiesiems diskams, SD ir kitoms atminties kortelėms, optinei saugyklai ir kt. Vidinė saugykla nepaveikiama, todėl atsisiuntimų aplanke išsaugotus failus vis tiek galima pasiekti. Be to, ši politika neturi įtakos „Google“ diskui.

      Jei šis nustatymas išjungtas arba nesukonfigūruotas, naudotojai įrenginyje gali naudoti visų palaikomų tipų išorinę saugyklą.</translation>
<translation id="5697306356229823047">Pateikti įrenginio naudotojų ataskaitą</translation>
<translation id="570062449808736508">Kai bus nustatyta ne tuščia šios politikos eilutė, „WebView“ perskaitys URL apribojimus iš turinio teikėjo su nurodytu įstaigos pavadinimu.</translation>
<translation id="5701714006401683963">Jei ši politika nustatyta kaip „false“, tvarkoma svečių sesija bus dokumentuojama adresu https://support.google.com/chrome/a/answer/3017014 kaip įprasta vieša sesija.

      Jei ši politika nustatyta kaip „true“ arba nenustatyta, tvarkoma svečių sesija vyks kaip tvarkoma sesija; tai panaikins daugelį apribojimų, taikomų įprastoms viešoms sesijoms.

      Jei ši politika nustatyta, naudotojas negali jos keisti ar nepaisyti.</translation>
<translation id="5722934961007828462">Kai šis nustatymas bus įgalintas, „<ph name="PRODUCT_NAME" />“ visada atliks serverio sertifikatų, kurie galioja ir yra pasirašyti vietoje įdiegtų CA sertifikatų, panaikinimo tikrinimą.

      Jei „<ph name="PRODUCT_NAME" />“ nepavyksta gauti panaikinimo būsenos informacijos, tokie sertifikatai laikomi atšauktais („įrangos triktis“).

      Jei ši politika nenustatyta arba nustatyta kaip „false“, „<ph name="PRODUCT_NAME" />“ naudoja esamus panaikinimo tikrinimo prisijungus nustatymus.</translation>
<translation id="5728154254076636808">Įgalinti „<ph name="PRODUCT_NAME" />“ profilio duomenų tarptinklinio ryšio kopijų kūrimą</translation>
<translation id="5732972008943405952">Automatinio pildymo formų duomenų importavimas iš numatytosios naršyklės paleidus pirmą kartą</translation>
<translation id="5765780083710877561">Aprašas:</translation>
<translation id="5770738360657678870">Kuriamas kanalas (gali būti nestabilus)</translation>
<translation id="5774856474228476867">Numatytojo paieškos teikėjo paieškos URL</translation>
<translation id="5776485039795852974">Paklausti kaskart, kai svetainėje norima rodyti darbalaukio pranešimus</translation>
<translation id="5781412041848781654">Nurodoma, kurią GSSAPI biblioteką reikia naudoti, nustatant HTTP autentifikavimą. Galima nustatyti vien tik bibliotekos pavadinimą arba visą kelią.

          Jei nepateikiamas joks nustatymas, „<ph name="PRODUCT_NAME" />“ naudoja atsarginį numatytąjį bibliotekos pavadinimą.</translation>
<translation id="5781806558783210276">Nurodoma laiko trukmė be naudotojo įvesties, po kurios neveikos veiksmai atliekami, kai naudojama akumuliatoriaus energija.

          Kai ši politika yra nustatyta, ji nurodo laiko trukmę, kurią naudotojas turi neatlikti jokių veiksmų, kad „<ph name="PRODUCT_OS_NAME" />“ imtųsi veiksmų dėl neveikos. Šiuos veiksmus galite sukonfigūruoti atskirai.

          Kai ši politika nenustatyta, naudojama numatytoji laiko trukmė.

          Politikos vertė turėtų būti nurodyta milisekundėmis.</translation>
<translation id="5783009211970309878">Antraščių ir poraščių spausdinimas</translation>
<translation id="5809728392451418079">Nustatyti įrenginio vietinių paskyrų pateikiamą pavadinimą</translation>
<translation id="5814301096961727113">Nustatyti numatytąją ekrano skaitymo balsu prisijungimo ekrane būklę</translation>
<translation id="5815129011704381141">Po atnaujinimo automatiškai įkelti operacinę sistemą iš naujo</translation>
<translation id="5815353477778354428">Konfigūruojamas katalogas, kurį „<ph name="PRODUCT_FRAME_NAME" />“ naudos naudotojo duomenims saugoti.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_FRAME_NAME" />“ naudos nurodytą katalogą.

      Apsilankykite adresu https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables. Čia rasite kintamųjų, kuriuos galima naudoti, sąrašą.

      Jei šis nustatymas paliekamas nenustatytas, naudojamas numatytasis profilio katalogas.</translation>
<translation id="5826047473100157858">Nurodoma, ar naudotojas (-a) gali atidaryti puslapius inkognito režimu „<ph name="PRODUCT_NAME" />“.

      Jei pasirinkta „Įgalinta“ arba politika nenustatyta, puslapius galima atidaryti inkognito režimu.

      Jei pasirinkta „Neleidžiama“, puslapių negalima atidaryti inkognito režimu.

      Jei pasirinkta „Priverstinai“, puslapius galima atidaryti TIK inkognito režimu.</translation>
<translation id="582857022372205358">Įgalinti trumpojo krašto dvipusį spausdinimą</translation>
<translation id="583091600226586337">
      Įgalinus politiką naudotojo bus klausiama, kur išsaugoti kiekvieną failą prieš juos atsisiunčiant.
      Išjungus politiką atsisiuntimas bus pradėtas iš karto ir naudotojo nebus klausiama, kur išsaugoti failą.
      Nesukonfigūravus politikos naudotojas galės pakeisti šį nustatymą.
      </translation>
<translation id="5835124959204887277">Nurodomi URL ir domenai, kuriuose nebus rodomas raginimas, kai bus pateikiamos saugos raktų atestacijos sertifikatų užklausos. Be to, saugos raktui bus išsiunčiamas signalas, nurodantis, kad galima naudoti individualią atestaciją. Nenustačius šios politikos, naudotojams bus pateikiami raginimai 65 ir naujesnių versijų „Chrome“, kai svetainėse bus reikalaujama saugos raktų atestacijos.

      URL (pvz., https://example.com/some/path) atitiks tik kaip U2F „appID“. Domenai (pvz., example.com) atitiks tik kaip „webauthn“ RP ID. Todėl, kad būtų įtrauktos ir tam tikros svetainės U2F, ir „webauthn“ API, sąraše turi būti ir „appID“ URL, ir domenas.</translation>
<translation id="5835412847081687053">Naudotojo sesijoje leidžiamų UI lokalių konfigūravimas</translation>
<translation id="5836064773277134605">Apriboti UDP prievado diapazoną, naudojamą nuotolinės prieigos prieglobos</translation>
<translation id="5862253018042179045">Nustatyti numatytąją ekrano skaitymo balsu būklę prisijungimo ekrane.

          Jei ši politika nustatyta, ekrano skaitymas balsu bus įgalintas, kai bus rodomas prisijungimo ekranas.

          Jei ši politika nenustatyta, ekrano skaitymas balsu bus išjungtas, kai bus rodomas prisijungimo ekranas.

          Jei nustatysite šią politiką, naudotojai galės laikinai nepaisyti jos įgalinę arba išjungę ekrano skaitymą balsu. Tačiau naudotojo pasirinkimas nėra ilgalaikis ir numatytasis nustatymas atkuriamas, kai prisijungimo ekranas rodomas iš naujo arba naudotojas vieną minutę neatlieka jokių veiksmų prisijungimo ekrane.

          Jei ši politika nenustatyta, ekrano skaitymas balsu bus išjungtas, kai pirmą kartą bus rodomas prisijungimo ekranas. Naudotojai galės bet kada įgalinti arba išjungti ekrano skaitymą balsu, o jų būsena prisijungimo ekrane bus vienoda skirtingiems naudotojams.</translation>
<translation id="5868414965372171132">Naudotojo lygio tinklo konfigūracija</translation>
<translation id="5879014913445067283">Valdo tinklo failų bendrinimo įrenginio atradimus per „<ph name="NETBIOS_NAME" />“</translation>
<translation id="5883015257301027298">Numatytasis slapukų nustatymas</translation>
<translation id="5887414688706570295">Konfigūruojamas „TalkGadget“ (Pokalbių programėlės) kodas, kuris bus naudojamas nuotolinės prieigos prieglobų, ir neleidžiama naudotojams jo keisti.

          Jei nurodytas, šis kodas iš anksto pridedamas prie pagrindinio „TalkGadget“ (Pokalbių programėlės) pavadinimo ir sukuriamas visas „TalkGadget“ (Pokalbių programėlės) domeno pavadinimas. Pagrindinis „TalkGadget“ (Pokalbių programėlės) pavadinimas yra „.talkgadget.google.com“.

          Jei šis nustatymas įgalintas, prieglobos naudoja tinkintą domeno pavadinimą, kai pasiekiama „TalkGadget“ (Pokalbių programėlė), vietoje numatytojo domeno pavadinimo.

          Jei šis nustatymas neleidžiamas arba nenustatytas, tada numatytasis „TalkGadget“ (Pokalbių programėlės) domeno pavadinimas („chromoting-host.talkgadget.google.com“) naudojamas visoms priegloboms.

          Nuotolinės prieigos programoms šis politikos nustatymas įtakos neturi. Joms visada naudojama „chromoting-client.talkgadget.google.com“ „TalkGadget“ (Pokalbių programėlei) pasiekti.</translation>
<translation id="5893553533827140852">Jei šis nustatymas įgalintas, „Gnubby“ autentifikavimo užklausos bus perduotos įgaliotajam serveriui nuotolinės prieglobos ryšiu.

          Jei šis nustatymas išjungtas arba nesukonfigūruotas, „Gnubby“ autentifikavimo užklausos nebus perduotos įgaliotajam serveriui.</translation>
<translation id="5898486742390981550">Kai keli naudotojai yra prisijungę, tik pagrindinis naudotojas gali naudoti „Android“ programas.</translation>
<translation id="5901427587865226597">Tik dvipusis spausdinimas</translation>
<translation id="5906199912611534122">Leidžiama įgalinti arba išjungti tinklo reguliavimą.
      Tai taikoma visiems naudotojams ir visoms sąsajoms įrenginyje. Nustačius
      reguliavimas taikomas, kol politika pakeičiama, kad jis būtų išjungtas.

      Nustačius į „False“, nereguliuojama.
      Nustačius į „True“, sistema reguliuojama, kad pasiektų pateiktą įkėlimo ir atsisiuntimo spartą (kilobitais per sek.).</translation>
<translation id="5921713479449475707">Leisti automatinio naujinio atsisiuntimus naudojant HTTP</translation>
<translation id="5921888683953999946">Nustatyti numatytąją didelio žymeklio pasiekiamumo funkciją prisijungimo ekrane.

          Jei ši politika galioja, didelis žymeklis bus įgalintas, kai bus rodomas prisijungimo ekranas.
          Jei ši politika negalioja, didelis žymeklis bus išjungtas, kai bus rodomas prisijungimo ekranas.

          Jei nustatysite šią politiką, naudotojai galės laikinai jos nepaisyti įjungę arba išjungę didelį žymeklį. Tačiau naudotojo pasirinkimas nėra ilgalaikis ir numatytasis nustatymas atkuriamas, kai prisijungimo ekranas rodomas iš naujo arba naudotojas vieną minutę neatlieka veiksmų prisijungimo ekrane.

          Jei ši politika nenustatyta, didelis žymeklis išjungiamas, kai pirmą kartą rodomas prisijungimo ekranas. Naudotojai gali bet kada įjungti arba išjungti didelį žymeklį, o skirtingiems naudotojams prisijungimo ekrane bus rodoma ta pati žymeklio būsena.</translation>
<translation id="5929855945144989709">Leidimas įrenginiams paleisti virtualiuosius įrenginius „Chrome“ OS</translation>
<translation id="5932767795525445337">Šią politiką taip pat galima naudoti „Android“ programoms prisegti.</translation>
<translation id="5936622343001856595">„Google“ žiniatinklio paieškos užklausos priverstinai vykdomos naudojant aktyvintą saugią paiešką. Neleidžiama naudotojams keisti šio nustatymo.

      Jei įgalinsite šį nustatymą, saugi paieška „Google“ paieškoje bus visada aktyvi.

      Jei šio nustatymo neleisite arba nenustatysite vertės, saugi paieška „Google“ paieškoje nebus vykdoma.</translation>
<translation id="5946082169633555022">Beta versijos kanalas</translation>
<translation id="5950205771952201658">Jei įvyksta laikinoji klaida, atlikus internetinius panaikinimo patikrinimus sauga nėra užtikrinama efektyviai, todėl jie išjungiami pagal numatytuosius nustatymus naudojant 19 ar naujesnę „<ph name="PRODUCT_NAME" />“ versiją. Nustačius šios politikos reikšmę į „true“, atkuriama ankstesnė elgsena ir internete atliekami OCSP / CRL patikrinimai.

      Jei politika nenustatyta arba jos reikšmė nustatyta kaip „false“, „<ph name="PRODUCT_NAME" />“ neatliks internetinių panaikinimo patikrinimų 19 ar naujesnės versijos „<ph name="PRODUCT_NAME" />“.</translation>
<translation id="5966615072639944554">Plėtiniams leidžiama naudoti nuotolinio patvirtinimo API</translation>
<translation id="5983708779415553259">Numatytoji elgsena, skirta svetainėms, neesančioms turinio paketuose</translation>
<translation id="5997543603646547632">Naudoti 24 val. laikrodį pagal numatytuosius nustatymus</translation>
<translation id="5997846976342452720">Nurodoma, ar reikia išjungti papildinių paieškos priemonę (nebenaudojama)</translation>
<translation id="6017568866726630990">Rodyti sistemos spausdinimo dialogo langą, o ne spaudinio peržiūrą.

      Kai šis nustatymas įgalintas, „<ph name="PRODUCT_NAME" />“ atvers sistemos spausdinimo dialogo langą, o ne integruotą spaudinio peržiūrą, kai naudotojas pateikia puslapio spausdinimo užklausą.

      Jei ši politika nenustatyta arba deaktyvinta, įvykdžius spausdinimo komandą atveriamas spaudinio peržiūros ekranas.</translation>
<translation id="6022948604095165524">Veiksmai paleidžiant</translation>
<translation id="6023030044732320798">Nurodomos politikos nuostatos, kurios bus perduotos vykdant ARC. Vertė turi būti galiojantis JSON.

      Ši politika gali būti naudojama norint sukonfigūruoti, kurios „Android“ programos yra automatiškai įdiegiamos įrenginyje:

      {
        "type": "object",
        "properties": {
          "applications": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "packageName": {
                  "description": "„Android“ programos identifikatorius, pvz., "com.google.android.gm" skirtas „Gmail“",
                  "type": "string"
                },
                "installType": {
                  "description": "Nurodoma, kaip įdiegta programa. OPTIONAL: programa neįdiegta automatiškai, bet ją gali įdiegti naudotojas. Tai yra numatytasis nustatymas, jei ši politika nėra nurodoma. PRELOAD: programa įdiegta automatiškai, bet naudotojas gali ją pašalinti. FORCE_INSTALLED: programa įdiegta automatiškai, ir naudotojas negali jos pašalinti. BLOCKED: programa yra užblokuota ir negali būti įdiegta. Jei programa buvo įdiegta galiojant ankstesnei politikai, ji bus pašalinta.",
                  "type": "string",
                  "enum": [
                    "OPTIONAL",
                    "PRELOAD",
                    "FORCE_INSTALLED",
                    "BLOCKED"
                  ]
                },
                "defaultPermissionPolicy": {
                  "description": "Leidimo suteikimo programoms užklausų politika. PERMISSION_POLICY_UNSPECIFIED: politika nenurodyta. Jei nenurodyta jokia leidimo politika jokiu lygmeniu, pagal numatytuosius nustatymus naudojama PROMPT elgsena. PROMPT: paraginti naudotoją suteikti leidimą. GRANT: automatiškai suteikti leidimą. DENY: automatiškai atmesti leidimą.",
                  "type": "string",
                  "enum": [
                    "PERMISSION_POLICY_UNSPECIFIED",
                    "PROMPT",
                    "GRANT",
                    "DENY"
                  ]
                },
                "managedConfiguration": {
                  "description": "Konkrečios programos JSON konfigūracijos objektas su rakto reikšmių porų rinkiniu, pvz., "managedConfiguration": { "key1": value1, "key2": value2 }. Raktai nurodyti programos apraše.",
                  "type": "object"
                }
              }
            }
          }
        }
      }

      Jei norite prisegti programas prie paleidimo priemonės, žr. „PinnedLauncherApps“.</translation>
<translation id="602728333950205286">Numatytojo paieškos teikėjo intuityviosios paieškos URL</translation>
<translation id="603410445099326293">Pasiūlymų URL parametrai, kuriuose naudojama POST</translation>
<translation id="6036523166753287175">Įgalinkite užkardos apėjimą iš nuotolinės prieigos prieglobos</translation>
<translation id="6070667616071269965">Įrenginio prisijungimo ekrano klaviatūros išdėstymai</translation>
<translation id="6074963268421707432">Neleisti jokioje svetainėje rodyti darbalaukio pranešimų</translation>
<translation id="6074964551275531965">Atnaujinimo pranešimų laikotarpio nustatymas</translation>
<translation id="6076099373507468537">Apibrėžiamas USB įrenginių, kuriuos leidžiama atjungti nuo branduolio tvarkyklės, kad būtų galima naudoti naudojant chrome.usb API tiesiai žiniatinklio programoje, sąrašas. Įrašai – tai USB paslaugos teikėjo identifikatoriaus ir produkto identifikatoriaus poros, nurodančios konkrečią aparatinę įrangą.

      Jei ši politika nesukonfigūruota, atjungiamų USB įrenginių sąrašas yra tuščias.</translation>
<translation id="6083631234867522991">„Windows“ („Windows“ klientai):</translation>
<translation id="6091233616732024397">Priverstinis naudotojų prisijungimas norint naudoti naršyklę</translation>
<translation id="6093156968240188330">Leisti nuotoliniams naudotojams sąveikauti su pakeltais langais nuotolinės pagalbos sesijose</translation>
<translation id="6095999036251797924">Nurodo laikotarpį, per kurį naudotojas neatliko įvesties veiksmų ir po kurio užrakinamas ekranas, kai įrenginys veikia naudojant kintamosios srovės arba akumuliatoriaus maitinimą.

          Kai laikotarpis nustatytas į didesnę nei nulis vertę, tai nurodo, kiek laiko naudotojas turi išlikti neaktyvus prieš „<ph name="PRODUCT_OS_NAME" />“ užrakinant ekraną.

          Kai laikotarpis nustatytas į nulį, „<ph name="PRODUCT_OS_NAME" />“ neužrakina ekrano naudotojui tapus neaktyviam.

          Kai laikotarpis nenustatytas, naudojama numatytoji laikotarpio vertė.

          Rekomenduojamas būdas užrakinti ekraną, kai naudotojas tampa neaktyvus, – įgalinti ekrano užraktą, kai įrenginys laikinai sustabdomas, ir nustatyti, kad „<ph name="PRODUCT_OS_NAME" />“ kad laikinai sustabdytų įrenginį po neaktyvumo laikotarpio. Ši politika turėtų būti naudojama tik norint, kad ekrano užraktas būtų suaktyvintas žymiai anksčiau nei laikinas sustabdymas arba kai įrenginys neturi būti laikinai sustabdomas po neaktyvumo laikotarpio.

          Politikos vertė turėtų būti nurodyta milisekundėmis. Vertės apribojamos, kad būtų mažesnės nei neaktyvumo laikotarpis.</translation>
<translation id="6097601282776163274">Įgalinti URL pagrįstą anonimizuotų duomenų rinkimą</translation>
<translation id="6099853574908182288">Numatytasis spausdinimas spalvotu režimu</translation>
<translation id="6111936128861357925">Leisti dinozaurų Velykų kiaušinių žaidimą</translation>
<translation id="6114416803310251055">nepatvirtinta</translation>
<translation id="6133088669883929098">Leisti visoms svetainėms naudoti rakto generavimą</translation>
<translation id="6145799962557135888">Leidžiama nurodyti URL šablonų, nurodančių svetaines, kuriose leidžiama paleisti „JavaScript“, sąrašą.

          Nenustačius šios politikos visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „Numatytasis „JavaScript“ nustatymas“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="614662973812186053">Ši politika taip pat valdo „Android“ naudojimą ir diagnostikos duomenų rinkimą.</translation>
<translation id="6155936611791017817">Nustatyti numatytąją didelio žymeklio prisijungimo ekrane būklę</translation>
<translation id="6157537876488211233">Kableliais atskirtų tarpinio serverio apėjimo taisyklių sąrašas</translation>
<translation id="6158324314836466367">Įmonės internetinės parduotuvės pavadinimas (nebenaudojama)</translation>
<translation id="6181608880636987460">Galima nustatyti URL šablonų, kuriuose nurodomos svetainės, kurioms neleidžiama paleisti papildinio „<ph name="FLASH_PLUGIN_NAME" />“, sąrašą.

          Jei ši politika nenustatyta, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultPluginsSetting“ (jei ji nustatyta) arba naudotojo asmeninės konfigūracijos (kitu atveju).</translation>
<translation id="6190022522129724693">Numatytasis iššokančiųjų langų nustatymas</translation>
<translation id="6190367314942602985">Naudotojo identifikavimo informacijos pranešimas</translation>
<translation id="6197453924249895891">Suteikiama galimybė įmonės raktais pasiekti plėtinius.

      Raktus galima naudoti tik įmonėje, jei jie sugeneruoti naudojant „chrome.enterprise.platformKeys“ API valdomoje paskyroje. Importuoti arba kitu būdu sugeneruoti raktai nėra skirti naudoti įmonėje.

      Galimybė pasiekti įmonėje skirtus naudoti raktus valdoma tik naudojant šią politiką. Naudotojas negali suteikti galimybės įmonės raktams pasiekti arba jos atšaukti plėtiniams arba naudodamas plėtinius.

      Pagal numatytuosius nustatymus plėtinyje negalima naudoti rakto, kuris skirtas naudoti įmonėje. Tai atitinka konkretaus plėtinio parinkties „allowCorporateKeyUsage“ nustatymą į „false“.

      Tik jei plėtinio parinktis „allowCorporateKeyUsage“ nustatyta į „true“, jame galima pasirašyti pasirenkamus duomenis naudojant bet kurios platformos raktą, skirtą naudoti įmonėje. Šis leidimas turėtų būti suteiktas, tik jei plėtinys patikimas, kad būtų galima apsaugoti raktą nuo užgrobėjų.</translation>
<translation id="6208896993204286313">„<ph name="PRODUCT_NAME" />“ politikos informacijos pranešimas</translation>
<translation id="6210259502936598222">OS ir „<ph name="PRODUCT_NAME" />“ versijos informacijos pranešimas</translation>
<translation id="6211428344788340116">Pateikti įrenginio veiklos laiką.

      Jei šis nustatymas nenustatytas arba nustatytas kaip „True“, užregistruoti įrenginiai pateiks įrenginio naudotojo veiklos laikotarpio informaciją. Jei nustatymas nustatytas kaip „False“, įrenginio veiklos laikas nebus įrašomas ar pateikiamas.</translation>
<translation id="6212868225782276239">Rodomi visi spausdintuvai, išskyrus įtrauktuosius į juodąjį sąrašą.</translation>
<translation id="6219965209794245435">Naudojant šią politiką priverstinai importuojami automatinio pildymo formų duomenys iš ankstesnės numatytosios naršyklės (jei įgalinta). Be to, jei įgalinta, ši politika paveikia importavimo dialogo langą.

      Jei ši politika išjungta, automatinio pildymo formų duomenys neimportuojami.

      Jei nenustatyta, naudotojo gali būti paklausta, ar importuoti, arba gali būti automatiškai importuojama.</translation>
<translation id="6224304369267200483">URL / domenams automatiškai leidžiama tiesioginė saugos rakto atestacija</translation>
<translation id="6233173491898450179">Nustatyti atsisiuntimo katalogą</translation>
<translation id="6244210204546589761">Paleidžiant atidaromi URL</translation>
<translation id="6258193603492867656">Nurodoma, ar į sugeneruotą „Kerberos“ SPN turi būti įtrauktas nestandartinis prievadas.

          Jei įgalinsite šį nustatymą ir įvesite nestandartinį prievadą (t. y. ne 80 arba 443, o kitokį prievadą), jis bus įtrauktas į sugeneruotą „Kerberos“ SPN.

          Jei šio nustatymo neleisite, į sugeneruotą „Kerberos“ SPN niekada nebus įtrauktas prievadas.</translation>
<translation id="6261643884958898336">Įrenginio identifikavimo informacijos pranešimas</translation>
<translation id="6281043242780654992">Konfigūruoja savosios susirašinėjimo pranešimais programos politiką. Į juodąjį sąrašą įtrauktos savųjų susirašinėjimo pranešimais programų prieglobos nebus leidžiamos, kol nebus įtrauktos į baltąjį sąrašą.</translation>
<translation id="6282799760374509080">Leisti arba atmesti garso įrašo fiksavimą</translation>
<translation id="6284362063448764300">1.1 versijos TLS</translation>
<translation id="6310223829319187614">Domeno pavadinimo automatinio užbaigimo prisijungiant naudotojui įgalinimas</translation>
<translation id="6315673513957120120">„Chrome“ rodo įspėjimo puslapį, kai naudotojai naršo svetaines su SSL klaidomis. Pagal numatytuosius nustatymus arba kai ši politika nustatyta į „true“, naudotojams leidžiama spustelėjus pašalinti šiuos įspėjimo puslapius.
      Kai ši politika nustatyta į „false“, naudotojams neleidžiama spustelėjus pašalinti šių įspėjimo puslapių.</translation>
<translation id="6352543686437322588">Vietinė įrenginio paskyra, skirta automatiškai prijungti po delsos.

      Jei ši politika nustatyta, prie nurodytos sesijos bus automatiškai prisijungta prisijungimo ekrane praėjus tam tikram laikui be naudotojo sąveikos. Vietinė įrenginio paskyra jau turi būti sukonfigūruota (žr. |DeviceLocalAccounts|).

      Jei ši politika nenustatyta, nebus automatiškai prijungiama.</translation>
<translation id="6353901068939575220">Nurodomi parametrai, naudojami ieškant URL naudojant POST. Jie sudaryti iš kableliais atskirtų pavadinimų / verčių porų. Jei vertė yra šablono parametras, pvz., {searchTerms} anksčiau pateiktame pavyzdyje, ji pakeičiama realiais paieškos terminų duomenimis.

          Ši politika pasirenkama. Jei nenustatyta, paieškos užklausa siunčiama naudojant GET metodą.

          Šios politikos laikomasi, tik jei įgalinta politika „DefaultSearchProviderEnabled“.</translation>
<translation id="6367755442345892511">Ar naudotojui (-ai) turėtų būti leidžiama konfigūruoti paleidimo kanalą</translation>
<translation id="6368011194414932347">Konfigūruoti pagrindinio puslapio URL</translation>
<translation id="6368403635025849609">Leisti „JavaScript“ šiose svetainėse</translation>
<translation id="6376659517206731212">Gali būti nustatyta kaip būtina</translation>
<translation id="6377355597423503887">Ši politika nebenaudojama. Vietoje jos turėtumėte naudoti „BrowserSignin“.

      Naudotojui leidžiama prisijungti prie „<ph name="PRODUCT_NAME" />“.

      Jei nustatysite šią politiką, galėsite konfigūruoti, ar naudotojui leidžiama prisijungti prie „<ph name="PRODUCT_NAME" />“. Šią politiką nustačius kaip „Netiesa“ nebus leidžiama veikti programoms ir plėtiniams, kuriuose naudojama „chrome.identity“ API, todėl vietoje jos turėtumėte naudoti „SyncDisabled“.</translation>
<translation id="6378076389057087301">Nurodykite, ar garso įrašo veikla paveikia energijos valdymą</translation>
<translation id="637934607141010488">Pateikti neseniai prisijungusių įrenginio naudotojų sąrašą.

      Jei politika nustatyta kaip „False“, naudotojų informacija nebus pateikta.</translation>
<translation id="6394350458541421998">Ši politika nebenaudojama 29 ir naujesnėse „<ph name="PRODUCT_OS_NAME" />“ versijose. Vietoje jos naudokite politiką „PresentationScreenDimDelayScale“.</translation>
<translation id="6401669939808766804">Atjungti naudotoją</translation>
<translation id="6426205278746959912">Negalite priversti „Android“ programų naudoti tarpinio serverio. „Android“ programos gali pasiekti dalį tarpinio serverio nustatymų, į kuriuos gali savanoriškai atsižvelgti.

          Jei pasirinksite niekada nenaudoti tarpinio serverio, „Android“ programoms bus pranešta, kad nesukonfigūruotas joks tarpinis serveris.

          Jei pasirinksite naudoti sistemos tarpinį serverį arba fiksuotą serverio tarpinį serverį, „Android“ programoms pateikiamas „http“ tarpinio serverio adresas ir prievadas.

          Jei pasirinksite automatiškai aptikti tarpinį serverį, „Android“ programoms pateikiamas scenarijaus URL „http://wpad/wpad.dat“. Nenaudojama jokia kita tarpinio serverio automatinio aptikimo protokolo dalis.

          Jei pasirinksite naudoti .pac tarpinio serverio scenarijų, „Android“ programoms pateikiamas scenarijaus URL.</translation>
<translation id="6430366557948788869">„Chrome“ ataskaitų teikimo plėtinys</translation>
<translation id="6440051664870270040">Leisti svetainėms vienu metu naršyti ir atidaryti iššokančiuosius langus</translation>
<translation id="6447948611083700881">Atsarginis kopijavimas ir atkūrimas išjungtas</translation>
<translation id="645425387487868471">Įgalinti „<ph name="PRODUCT_NAME" />“ priverstinį prisijungimą</translation>
<translation id="6464074037294098618">Adresų automatinio pildymo funkcijos įgalinimas</translation>
<translation id="6473623140202114570">Domenų, kuriuose Saugaus naršymo funkcija nesuaktyvins įspėjimų, sąrašo konfigūravimas.</translation>
<translation id="6491139795995924304">Leisti „Bluetooth“ įrenginyje</translation>
<translation id="6520802717075138474">Importuoti paieškos variklius iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="6525955212636890608">Jei įgalinsite šį nustatymą, visas svetainėse, kurių turinio nustatymuose nustatyta leisti „Flash“ (atsižvelgiant į naudotojo nustatymus ar įmonės politiką), įterptas „Flash“ turinys bus leidžiamas, įskaitant turinį iš kitų šaltinių ar nedidelės apimties turinį.

      Kad galėtumėte valdyti, kurioms svetainėms leidžiama vykdyti „Flash“, žr. „DefaultPluginsSetting“, „PluginsAllowedForUrls“ ir „PluginsBlockedForUrls“ politikos nuostatas.

      Jei šis nustatymas išjungtas arba nenustatytas, „Flash“ turinys iš kitų šaltinių arba mažos apimties turinys gali būti blokuojamas.</translation>
<translation id="6532769014584932288">Pažadinimo užraktų leidimas</translation>
<translation id="653608967792832033">Nurodoma laiko trukmė be naudotojo įvesties, po kurios ekranas užrakinamas, kai naudojama akumuliatoriaus energija.

          Kai šios politikos vertė yra didesnė už nulį, ji nurodo laiko trukmę, kurią naudotojas turi neatlikti jokių veiksmų, kol „<ph name="PRODUCT_OS_NAME" />“ užrakins ekraną.

          Kai politika nustatyta į nulį, „<ph name="PRODUCT_OS_NAME" />“ neužrakina ekrano, kai naudotojas neatlieka jokių veiksmų.

          Kai ši politika nenustatyta, naudojama numatytoji laiko trukmė.

          Rekomenduojamas būdas užrakinti ekraną, kai neatliekama veiksmų, yra įgalinti ekrano užraktą, kai veiksmai laikinai neatliekami, ir nustatyti, kad „<ph name="PRODUCT_OS_NAME" />“ būtų laikinai sustabdyta po neveikos delsos. Ši politika turėtų būti naudojama, tik jei ekranas turėtų būti užrakinamas daug greičiau iki laikino sustabdymo arba kai visiškai nepageidaujama, kad būtų laikinai sustabdoma, kai neatliekama jokių veiksmų.

          Politikos vertė turėtų būti nurodyta milisekundėmis. Vertės sumažinamos, kad neviršytų neveikos delsos laiko.</translation>
<translation id="6536600139108165863">Automatinis paleidimas iš naujo, kai išjungiamas įrenginys</translation>
<translation id="6539246272469751178">Ši politika neturi įtakos „Android“ programoms. „Android“ programos visada naudoja numatytąjį atsisiuntimų katalogą ir negali pasiekti „<ph name="PRODUCT_OS_NAME" />“ atsisiųstų failų į nenumatytą atsisiuntimų katalogą.</translation>
<translation id="654303922206238013">Failų sistemos „eCryptfs“ perkėlimo strategija</translation>
<translation id="6544897973797372144">Jei šios politikos nustatymas yra „True“ (tiesa) ir politika „ChromeOsReleaseChannel“ („Chrome“ OS paleidimo kanalas) nenurodyta, tada užregistruoto domeno naudotojams leidžiama keisti įrenginio paleidimo kanalą. Jei šios politikos nustatymas yra „False“ (netiesa), įrenginys užrakinamas bet kuriame kanale, kuriame paskutinį kartą buvo nustatytas.

      Naudotojo (-os) pasirinktas kanalas bus pakeistas taikant politiką „ChromeOsReleaseChannel“ („Chrome“ OS paleidimo kanalas), bet jei politikos kanalas stabilesnis nei tas, kuris įdiegtas įrenginyje, kanalas perjungiamas, tik kai stabilesnio kanalo versija yra naujesnė nei įdiegta įrenginyje.</translation>
<translation id="6553143066970470539">Ekrano skaisčio procentas</translation>
<translation id="6559057113164934677">Neleisti jokiai svetainei pasiekti kameros ir mikrofono</translation>
<translation id="6561396069801924653">Rodyti pasiekiamumo parinktis sistemos dėklo meniu</translation>
<translation id="6565312346072273043">Nustatyti numatytąją ekrano klaviatūros pasiekiamumo funkcijos būseną prisijungimo ekrane.

          Jei ši politika galioja, ekrano klaviatūra bus įgalinta, kai bus rodomas prisijungimo ekranas.

          Jei ši politika negalioja, ekrano klaviatūra bus išjungta, kai bus rodomas prisijungimo ekranas.

          Jei nustatysite šią politiką, naudotojai galės laikinai nepaisyti jos įgalindami arba išjungdami ekrano klaviatūrą. Tačiau naudotojo pasirinkimas nėra nuolatinis ir numatytasis nustatymas atkuriamas, kai prisijungimo ekranas parodomas iš naujo ar naudotojas minutę neatlieka jokių veiksmų prisijungimo ekrane.

          Jei ši politika nenustatyta, ekrano klaviatūra išjungiama, kai prisijungimo ekranas parodomas pirmą kartą. Naudotojai gali įgalinti arba išjungti ekrano klaviatūrą bet kuriuo metu. Ekrano klaviatūros būsena prisijungimo ekrane yra nuolatinė visiems naudotojams.</translation>
<translation id="6573305661369899995">Išorinio URL apribojimų šaltinio nustatymas</translation>
<translation id="6598235178374410284">Naudotojo pseudoportreto vaizdas</translation>
<translation id="6603004149426829878">Visada siųsti visus pasiekiamus vietovės signalus serveriui nustatant laiko juostą</translation>
<translation id="6628646143828354685">Galite nustatyti, ar svetainės gali pasiekti netoliese esančius „Bluetooth“ įrenginius. Galimybę pasiekti įrenginius galima visiškai užblokuoti arba naudotojo gali būti paklausta kiekvieną kartą, kai svetainė nori pasiekti netoliese esančius „Bluetooth“ įrenginius.

          Jei ši politika nenustatyta, bus naudojama vertė „3“ ir naudotojas galės ją pakeisti.</translation>
<translation id="663685822663765995">Spausdinimo spalvotu režimu ribojimas</translation>
<translation id="6641981670621198190">Neleisti palaikyti trimatės grafikos API</translation>
<translation id="6647965994887675196">Jei ši politika galioja, galima sukurti ir naudoti prižiūrimus naudotojus.

          Jei ši politika negalioja arba yra nesukonfigūruota, prižiūrimo naudotojo kūrimas ir prisijungimas bus neleidžiamas. Visi esami prižiūrimi naudotojai bus paslėpti.

          PASTABA: numatytoji klientų ir įmonės įrenginių elgsena skiriasi: klientų įrenginiuose prižiūrimi naudotojai pagal numatytuosius nustatymus yra įgalinti, o įmonės įrenginiuose – neleidžiami.</translation>
<translation id="6649397154027560979">Ši politika nebenaudojama, vietoje jos naudokite politiką „URLBlacklist“.

      Išjungiamos pateiktos protokolo schemos „<ph name="PRODUCT_NAME" />“.

      Šio sąrašo schemą naudojantys URL nebus įkeliami ir jų negalima naršyti.

      Jei ši politika nenustatyta ar sąrašas yra tuščias, visos schemos bus pasiekiamos „<ph name="PRODUCT_NAME" />“.</translation>
<translation id="6652197835259177259">Vietoje tvarkomų naudotojų paskyrų nustatymai</translation>
<translation id="6658245400435704251">Nurodoma, iki kiek sekundžių įrenginys gali atsitiktinai atidėti naujinio atsisiuntimą nuo tada, kai naujinys buvo pirmąkart išsiųstas iš serverio. Įrenginys gali laukti dalį šio laiko pagal realųjį laiką, o likusią dalį – pagal naujinio tikrinimo kartus. Bet kuriuo atveju yra nustatyta viršutinė sklaidos riba (tam tikra trukmė), kad įrenginys nelauktų atsisiuntimo be galo.</translation>
<translation id="6665670272107384733">Nustatyti, kaip dažnai naudotojas turi įvesti slaptažodį, kad galėtų naudoti spartųjį atrakinimą</translation>
<translation id="6681229465468164801">Galite nustatyti URL šablonų, kuriuose nurodomos svetainės, kurioms neleidžiama prašyti naudotojo suteikti jiems galimybės pasiekti USB įrenginį, sąrašą.

          Jei ši politika nenustatyta, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultWebUsbGuardSetting“ (jei ji nustatyta) arba naudotojo asmeninės konfigūracijos (kitu atveju).

          Šios politikos URL šablonai negali būti nesuderinami su tais, kurie sukonfigūruoti naudojant „WebUsbAskForUrls“. Nenurodyta, kuri iš dviejų politikų turi pirmenybę, jei URL atitinka jas abi.</translation>
<translation id="6689792153960219308">Aparatinės įrangos būsenos ataskaitos pateikimas</translation>
<translation id="6698632841807204978">Įgalinti vienspalvį spausdinimą</translation>
<translation id="6699880231565102694">Įgalinti nuotolinės prieigos prieglobų autentifikavimą dviem veiksniais</translation>
<translation id="6724842112053619797">Jei įgalinsite šį nustatymą, saugomą „<ph name="PRODUCT_NAME" />“ profiliuose, pvz., žymėse, automatinio pildymo duomenyse, slaptažodžiuose ir kt., išsaugoti nustatymai taip pat bus įrašyti į failą, saugomą tarptinklinio ryšio naudotojo profilio aplanke arba administratoriaus nurodytoje vietoje pagal „<ph name="ROAMING_PROFILE_LOCATION_POLICY_NAME" />“ politiką. Sinchronizavimas debesyje automatiškai išjungiamas, kai įgalinama ši politika.

      Jei ši politika išjungta ar nenustatyta, bus naudojami tik įprasti vietiniai profiliai.

      „<ph name="SYNC_DISABLED_POLICY_NAME" />“ politika išjungia visų duomenų sinchronizavimą ir nepaiso „RoamingProfileSupportEnabled“.</translation>
<translation id="6731757988219967594">Filtruoti turinį suaugusiesiems aukščiausio lygio svetainėse (bet ne įterptuose „iframe“)</translation>
<translation id="6734521799274931721">Valdomas „Chrome“ OS skirtų tinklo failų bendrinimo įrenginių pasiekiamumas</translation>
<translation id="6735701345096330595">Priverstinis rašybos tikrinimo kalbų įgalinimas</translation>
<translation id="673699536430961464">Naudodami šį nustatymą naudotojai gali perjungti „Google“ paskyras naršyklės lango turinio srityje po to, kai prisijungia prie „<ph name="PRODUCT_OS_NAME" />“ įrenginio.

      Jei ši politika nustatyta kaip „false“, nebus leidžiama prisijungti prie kitos paskyros naršyklės turinio srityje naršant ne inkognito režimu.

      Jei ši politika nenustatyta arba nustatyta kaip „true“, bus naudojama numatytoji elgsena: naršyklės turinio srityje bus leidžiama prisijungti prie kitos paskyros, išskyrus vaikų paskyras, kurios bus blokuojamos turinio srityje naršant ne inkognito režimu.

      Jei prisijungti prie kitos paskyros neturėtų būti leidžiama naršant inkognito režimu, turėtumėte užblokuoti tą režimą naudodami politiką „IncognitoModeAvailability“.

      Atminkite, kad naudotojai galės pasiekti „Google“ paslaugas, nenustatant jų tapatybės, blokuodami slapukus.</translation>
<translation id="6738326937072482736">Konfigūruojamas <ph name="TPM_FIRMWARE_UPDATE_TPM" /> aparatinės programinės įrangos atnaujinimo funkcijų pasiekiamumas ir elgsena.

      Atskirus nustatymus galima nurodyti JSON nuosavybėse.

      „<ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH" />“: jei nustatyta į „<ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH_TRUE" />“, naudotojai galės suaktyvinti funkcijos „Powerwash“ eigą ir įdiegti <ph name="TPM_FIRMWARE_UPDATE_TPM" /> aparatinės programinės įrangos naujinį.

      „<ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE" />“: jei nustatyta į „<ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE_TRUE" />“, naudotojai galės iškviesti <ph name="TPM_FIRMWARE_UPDATE_TPM" /> programinės aparatinės įrangos atnaujinimo eigą, kuri išsaugos įrenginio būseną (įskaitant įmonės užregistravimą), bet bus prarasti naudotojo duomenys. Ši atnaujinimo eiga pasiekiama 68 ir naujesnės versijos sistemoje.

      Jei politika nenustatyta, <ph name="TPM_FIRMWARE_UPDATE_TPM" /> aparatinės programinės įrangos atnaujinimo funkcijos nebus pasiekiamos.</translation>
<translation id="6757438632136860443">Galima nustatyti URL šablonų, kuriuose nurodomos svetainės, kurioms leidžiama paleisti papildinį „<ph name="FLASH_PLUGIN_NAME" />“, sąrašą.

          Jei ši politika nenustatyta, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultPluginsSetting“ (jei ji nustatyta) arba naudotojo asmeninės konfigūracijos (kitu atveju).</translation>
<translation id="6762235610019366960">Leidžiama valdyti per visą skirtuką pateikiamo reklaminio ir (arba) mokomojo turinio rodymą naršyklėje „<ph name="PRODUCT_NAME" />“.

      Jei nesukonfigūruota ar neįgalinta (nustatyta kaip „tiesa“), „<ph name="PRODUCT_NAME" />“ gali būti rodomas per visą skirtuką pateikiamas turinys naudotojams, norint teikti produkto informaciją.

      Jei išjungta (nustatyta kaip „netiesa“), „<ph name="PRODUCT_NAME" />“ nerodomas per visą skirtuką pateikiamas turinys naudotojams, norint teikti produkto informaciją.

      Šis nustatymas valdo pasisveikinimo puslapių, kuriuose padedama naudotojams prisijungti prie naršyklės „<ph name="PRODUCT_NAME" />“, pasirinkti ją kaip numatytąją naršyklę ar kitais būdais informuoti apie produkto funkcijas, rodymą.</translation>
<translation id="6766216162565713893">Leisti svetainėms prašyti naudotojo suteikti leidimą pasiekti netoliese esantį „Bluetooth“ įrenginį</translation>
<translation id="6770454900105963262">Informacijos apie aktyvias viešojo terminalo sesijas ataskaitos pateikimas</translation>
<translation id="6786747875388722282">Plėtiniai</translation>
<translation id="6786967369487349613">Nustatyti tarptinklinio ryšio profilio katalogą</translation>
<translation id="6810445994095397827">Blokuoti „JavaScript“ šiose svetainėse</translation>
<translation id="681446116407619279">Palaikomos tapatumo nustatymo schemos</translation>
<translation id="6816212867679667972">Nustatomas įrenginio, naudoto DHCP užklausose, prieglobos serverio pavadinimas.

      Jei ši politika nustatyta kaip netuščia eilutė, ši eilutė bus naudojama kaip įrenginio prieglobos serverio pavadinimas pateikiant DHCP užklausą.

      Eilutėje gali būti kintamųjų ${ASSET_ID}, ${SERIAL_NUM}, ${MAC_ADDR}, ${MACHINE_NAME}, kurie bus pakeisti įrenginio vertėmis, prieš naudojant juos kaip prieglobos serverio pavadinimą. Rodomas pakeitimas turi būti tinkamas prieglobos serverio pavadinimas (RFC 1035, 3.1 skiltis).

      Jei ši politika nenustatyta arba po pakeitimo rodoma vertė nėra tinkamas prieglobos serverio pavadinimas, DHCP užklausoje nebus nustatytas joks prieglobos serverio pavadinimas. </translation>
<translation id="6835883744948188639">Pasikartojančio raginimo, kuriame nurodoma, kad rekomenduojama paleisti iš naujo, rodymas naudotojui</translation>
<translation id="6838056959556423778">Nepaisoma „<ph name="PRODUCT_NAME" />“ numatytojo spausdintuvo pasirinkimo taisyklių.

      Pagal šią politiką nustatomos numatytojo spausdintuvo pasirinkimo „<ph name="PRODUCT_NAME" />“ taisyklės. Spausdintuvas pasirenkamas pirmą kartą profilyje naudojant spausdinimo funkciją.

      Kai ši politika nustatyta, „<ph name="PRODUCT_NAME" />“ bandys rasti visus nurodytus atributus atitinkantį spausdintuvą ir pasirinks jį kaip numatytąjį spausdintuvą. Pasirenkamas pirmas politiką atitikęs spausdintuvas. Jei atitiktis nėra unikali, gali būti pasirinktas bet koks spausdintuvas, atsižvelgiant į spausdintuvų aptikimo eilės tvarką.

      Jei ši politika nenustatyta arba per skirtą laiką nerandamas atitinkantis spausdintuvas, kaip numatytasis spausdintuvas pasirenkamas įtaisytasis PDF spausdintuvas arba nepasirenkamas joks spausdintuvas, jei PDF spausdintuvas nepasiekiamas.

      Vertė analizuojama kaip JSON objektas, atitinkantis toliau nurodytą schemą:
      {
        "type": "object",
        "properties": {
          "kind": {
            "description": "Whether to limit the search of the matching printer to a specific set of printers.",
            "type": "string",
            "enum": [ "local", "cloud" ]
          },
          "idPattern": {
            "description": "Regular expression to match printer id.",
            "type": "string"
          },
          "namePattern": {
            "description": "Regular expression to match printer display name.",
            "type": "string"
          }
        }
      }
      Prie „<ph name="CLOUD_PRINT_NAME" />“ prijungti spausdintuvai laikomi „<ph name="PRINTER_TYPE_CLOUD" />“, o kiti spausdintuvai priskiriami kategorijai „<ph name="PRINTER_TYPE_LOCAL" />“.
      Jei laukas praleidžiamas, tai reiškia, kad atitiko visos vertės. Pvz., nenurodžius ryšio spausdinimo peržiūra inicijuos visų tipų spausdintuvų (vietinių ir iš debesies) aptikimą.
      Reguliariųjų reiškinių šablonai turi atitikti „JavaScript“ reguliariųjų reiškinių sintaksę. Atitiktyse skiriamos didžiosios ir mažosios raidės.</translation>
<translation id="684856667300805181">Ši politika pašalinta „<ph name="PRODUCT_NAME" />“ 68 ir pakeista „<ph name="ARC_GLS_POLICY_NAME" />“.</translation>
<translation id="6856743875250214792">Ši politika nebenaudojama ir yra pašalinta iš M66, nes ji buvo naudojama tik vidinio testavimo tikslais ir tai yra saugos atsakomybė.

      Nurodomos žymos, kurios turėtų būti pritaikytos, kai paleidžiama „<ph name="PRODUCT_NAME" />“. Nurodytos žymos pritaikomos tik prisijungimo ekrane. Naudojant šią politiką nustatytos žymos nepertraukia naudotojų sesijų.</translation>
<translation id="685769593149966548">Vykdyti griežtai ribotą režimą sistemoje „YouTube“</translation>
<translation id="686079137349561371">7 ar naujesnės versijos „Microsoft Windows“</translation>
<translation id="687046793986382807">Ši politika nebegalioja išleidus „<ph name="PRODUCT_NAME" />“ 35 versiją.

      Vis tiek teikiamos atminties informacijos ataskaitos puslapyje, neatsižvelgiant į parinkties vertę, bet nurodomi dydžiai
      suapvalinami ir naujinių dažnumas ribojamas saugumo sumetimais. Kad gautumėte tikslius duomenis realiuoju laiku,
      naudokite tokius įrankius kaip telemetrija.</translation>
<translation id="6894178810167845842">Naujo skirtuko puslapio URL</translation>
<translation id="6899705656741990703">Automatiškai aptikti tarpinio serverio nustatymus</translation>
<translation id="6903814433019432303">Ši politika aktyvi tik dirbant mažmeninės prekybos režimu.

      Nustatoma, ar URL rinkinys turi būti įkeltas, kai paleidžiama demonstracinės versijos sesija. Ši politika panaikina visus kitus pradinio URL nustatymo mechanizmus ir todėl gali būti taikoma tik su konkrečiu naudotoju nesusijusiai sesijai.</translation>
<translation id="6908640907898649429">Konfigūruojamas numatytasis paieškos teikėjas. Galite nurodyti numatytąjį paieškos teikėją, kurį naudotojas naudos, arba pasirinkti neleisti numatytosios paieškos.</translation>
<translation id="6913068954484253496">Leisti „<ph name="PRODUCT_NAME" />“ prisijungti prie visų perdavimo įrenginių, pasiekiamų visais IP adresais.</translation>
<translation id="6915442654606973733">Įgalinti ekrano skaitymo balsu funkciją.

          Jei ši politika nustatyta, ekrano skaitymas balsu bus visada įgalintas.

          Jei ši politika nenustatyta, ekrano skaitymas balsu bus visada išjungtas.

          Jei nustatysite šią politiką, naudotojai negalės jos pakeisti arba nepaisyti.

          Jei ši politika nenustatyta, ekrano skaitymas balsu bus išjungtas, bet naudotojas galės bet kada jį įgalinti.</translation>
<translation id="6916507170737609563">
      Gali būti naudinga peržiūrėti politikos nustatymą „IsolateOriginsAndroid“, kad efektyviai panaudotumėte atskyrimą darydami ribotą įtaką naudotojams, pasitelkdami „IsolateOriginsAndroid“ su svetainių, kurias norite atskirti, sąrašu. Nustatymu „SitePerProcessAndroid“ atskiriamos visos svetainės.
      Įgalinus politiką kiekviena svetainė vykdys atskirą procesą.
      Išjungus politiką nebus taikomas svetainių atskyrimas, o „IsolateOriginsAndroid“ ir „SitePerProcessAndroid“ bandomieji variantai bus išjungti. Naudotojai vis tiek galės neautomatiškai įgalinti „SitePerProcess“.
      Nesukonfigūravus politikos naudotojas galės pakeisti šį nustatymą.

      PASTABA: sistemoje „Android“ svetainių atskyrimas yra eksperimentinis. Palaikymas bus pagerintas laikui bėgant, bet šiuo metu tai gali sukelti našumo problemų.

      PASTABA: ši politika taikoma tik naršyklei „Chrome“ sistemoje „Android“, įrenginiuose, kuriuose būtinai yra daugiau nei 1 GB laisvosios prieigos atminties. Kad politiką pritaikytumėte ne „Android“ platformose, naudokite „SitePerProcess“.
      </translation>
<translation id="6922040258551909078">
      Jei ši politika nustatyta kaip „True“, debesies politikai yra teikiama pirmenybė, jei ji prieštarauja įrenginio politikai.
      Jei ši politika nustatyta kaip „False“ arba nėra sukonfigūruota, įrenginio politikai yra teikiama pirmenybė, jei ji prieštarauja debesies politikai.
      Jei reikia daugiau informacijos apie politikų pirmumą, apsilankykite adresu https://support.google.com/chrome?p=set_chrome_policies_for_devices

      Ši politika negalima „Windows“ objektuose, kurie nėra prijungti prie „<ph name="MS_AD_NAME" />“ domeno.
      </translation>
<translation id="6922884955650325312">Užblokuoti papildinį „<ph name="FLASH_PLUGIN_NAME" />“</translation>
<translation id="6923366716660828830">Nurodomas numatytojo paieškos teikėjo pavadinimas. Jei laukas paliekamas tuščias arba nenustatomas, naudojamas paieškos URL nurodytas prieglobos pavadinimas.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Numatytasis paieškos teikėjas įgalintas“.</translation>
<translation id="6926703471186170050">Įgalinti ilgojo krašto dvipusį spausdinimą</translation>
<translation id="6931242315485576290">Neleisti sinchronizuoti duomenų su „Google“</translation>
<translation id="6936894225179401731">Nurodomas didžiausias galimas prisijungimų prie įgaliotojo serverio vienu metu skaičius.

      Kai kurie įgaliotieji serveriai negali suvaldyti didelio vieno kliento prisijungimų skaičiaus vienu metu. Šią problemą galima išspręsti nustačius mažesnę vertę šioje politikoje.

      Šios politikos vertė turėtų būti mažesnė nei 100 ir didesnė nei 6; numatytoji vertė yra 32.

      Kai kurios žiniatinklio programos naudoja daug prisijungimų su užribiniais GET, todėl nustačius mažesnį skaičių nei 32, naršyklės darbas tinkle strigs, jei bus atidaryta per daug tokių žiniatinklio programų. Nustatę mažesnę vertę nei numatytoji, atsakomybę prisiimsite patys.

      Nenustačius šios politikos, bus naudojama numatytoji vertė, kuri yra 32.</translation>
<translation id="6943577887654905793">„Mac“ / „Linux“ nuostatos pavadinimas:</translation>
<translation id="6944167205014013774">Informacija apie „Linux“ programų naudojimą siunčiama atgal į
      serverį.

      Jei politika nustatyta į „False“ arba nenustatyta, naudojimo informacija nebus
      pateikiama. Jei nustatyta į „True“, naudojimo informacija bus pateikiama.

      Ši politika taikoma tik įgalinus „Linux“ programų palaikymą.</translation>
<translation id="69525503251220566">Parametras, nurodantis paieškos pagal vaizdą funkciją numatytajam paieškos teikėjui</translation>
<translation id="6956272732789158625">Neleisti jokiai svetainei naudoti rakto generavimo</translation>
<translation id="6965859329738616662">Nurodoma, ar išmaniajam pritemdymo modeliui leidžiama pratęsti laiką iki ekrano pritemdymo.

      Kai ekranas turėtų būti pritemdomas, išmanusis pritemdymo modelis įvertina, ar ekrano pritemdymo nereikia atidėti. Jei išmanusis pritemdymo modelis atideda ekrano pritemdymą, jis veiksmingai pratęsia laiką iki ekrano pritemdymo. Tokiu atveju ekrano išjungimo, ekrano užrakto ir neveikos būsenos delsos koreguojamos siekiant išlaikyti vienodą laiką nuo pirminės sukonfigūruotos pritemdymo delsos.
      Jei ši politika nustatyta kaip „True“ arba paliekama nenustatyta, išmanusis pritemdymo modelis bus įgalintas ir jam bus leista pratęsti laiką iki ekrano pritemdymo. Jei ši politika nustatyta kaip „False“, išmanusis pritemdymo modelis neturės įtakos ekrano pritemdymui.</translation>
<translation id="6994082778848658360">Nurodoma, kaip vidinė saugi elemento aparatinė įranga gali būti naudojama teikiant tapatybės nustatymą dviem veiksniais, jei ji suderinama su šia funkcija. Įrenginio maitinimo mygtukas naudojamas naudotojo buvimo vietai aptikti.

      Jei pasirinkta „Išjungta“, neteikiamas joks antras veiksnys.

      Jei pasirinkta U2F, integruotas antras veiksnys veiks pagal FIDO U2F specifikacijas.

      Jei pasirinkta U2F_EXTENDED, integruotas antras veiksnys teiks U2F funkcijas ir kelis asmeninės atestacijos plėtinius.</translation>
<translation id="6997592395211691850">Ar internetinės OCSP / CRL patikros reikalingos vietiniams patikimiems prieraišams</translation>
<translation id="7003334574344702284">Pagal šią politiką priverstinai importuojami išsaugoti slaptažodžiai iš ankstesnės numatytosios naršyklės (jei įgalinta). Be to, jei įgalinta, ši politika turi įtakos importavimo dialogo langui.

      Jei neleidžiama, išsaugoti slaptažodžiai neimportuojami.

      Jei nenustatyta, naudotojo gali būti paklausta, ar importuoti, arba gali būti automatiškai importuojama.</translation>
<translation id="7003746348783715221">„<ph name="PRODUCT_NAME" />“ nuostatos</translation>
<translation id="7006788746334555276">Turinio nustatymai</translation>
<translation id="7007671350884342624">Konfigūruojamas katalogas, kurį „<ph name="PRODUCT_NAME" />“ naudos naudotojo duomenims saugoti.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME" />“ naudos nurodytą katalogą neatsižvelgiant į tai, ar naudotojas nurodė žymą „--user-data-dir“, ar ne. Kad neprarastumėte duomenų ir išvengtumėte kitų netikėtų klaidų, ši politika neturėtų būti nustatyta tomo šakniniame kataloge ar kitais tikslais naudojamame kataloge, nes „<ph name="PRODUCT_NAME" />“ tvarko savo turinį.

      Galimų naudoti kintamųjų sąrašą rasite apsilankę adresu https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Jei ši politika nenustatyta, bus naudojamas numatytasis profilio kelias ir naudotojas galės nepaisyti jo naudodamas komandos eilutės žymą „--user-data-dir“.</translation>
<translation id="7027785306666625591">Konfigūruoti energijos valdymą „<ph name="PRODUCT_OS_NAME" />“.

      Pagal šią politiką leidžiama konfigūruoti, kokius veiksmus atlieka „<ph name="PRODUCT_OS_NAME" />“, kai naudotojas tam tikrą laiką neatlieka jokių veiksmų.</translation>
<translation id="7040229947030068419">Vertės pavyzdys:</translation>
<translation id="7044883996351280650">Valdoma „Android“ atsarginio kopijavimo ir atkūrimo paslauga</translation>
<translation id="7049373494483449255">Įgalinama „<ph name="PRODUCT_NAME" />“ pateikti dokumentus „<ph name="CLOUD_PRINT_NAME" />“, kad būtų spausdinami. PASTABA: tai turi įtakos tik palaikant „<ph name="CLOUD_PRINT_NAME" />“ „<ph name="PRODUCT_NAME" />“. Dėl to nėra draudžiama naudotojams pateikti spausdinimo darbų svetainėse.

      Jei šis nustatymas įgalintas arba nesukonfigūruotas, naudotojai gali spausdinti „<ph name="CLOUD_PRINT_NAME" />“ iš „<ph name="PRODUCT_NAME" />“ spausdinimo dialogo lango.

      Jei šis nustatymas neleidžiamas, naudotojai negali spausdinti „<ph name="CLOUD_PRINT_NAME" />“ iš „<ph name="PRODUCT_NAME" />“ spausdinimo dialogo lango</translation>
<translation id="7053678646221257043">Pagal šią politiką žymės priverstinai importuojamos iš esamos numatytosios naršyklės, jei įgalinta. Be to, jei įgalinta, ši politika turi įtakos importavimo dialogo langui.

      Jei neleidžiama, jokios žymės neimportuojamos.

      Jei nenustatyta, naudotojo gali būti klausiama, ar importuoti, arba gali būti importuojama automatiškai.</translation>
<translation id="7063895219334505671">Leisti iššokančiuosius langus šiose svetainėse</translation>
<translation id="706568410943497889">
      Jei ši politika nustatyta kaip „Tiesa“, „<ph name="PRODUCT_NAME" />“ leidžiama rinkti „WebRTC“ įvykių žurnalus iš „Google“ paslaugų (pvz., „Google Meet“) ir įkelti šiuos žurnalus į „Google“.

      Jei ši politika nustatyta kaip „Netiesa“ arba nenustatyta, „<ph name="PRODUCT_NAME" />“ nerinks ir neįkels tokių žurnalų.

      Šiuose žurnaluose yra tokios informacijos kaip išsiųstų ir gautų RTP paketų laikas ir dydis, atsiliepimai apie tinklo perpildymą ir metaduomenys apie garso ir vaizdo įrašų kadrų laiką ir kokybę. Ši informacija naudinga derinant problemas dėl garso ir vaizdo skambučių „Chrome“, pavyzdžiui, siuntimo spartos vertinimo problemas ir kt. Žurnaluose nėra skambučių garso ir vaizdo turinio.

      Šį duomenų rinkimą gali suaktyvinti tik „Google“ žiniatinklio paslaugos, pvz., „Google Hangouts“ ar „Google Meet“.

      Šie žurnalai naudojantis seanso ID gali būti susieti su kitais žurnalais, kuriuos surinko pačios „Google“ paslaugos; tai skirta lengvesniam derinimui.
      </translation>
<translation id="706669471845501145">Leisti svetainėse rodyti darbalaukio pranešimus</translation>
<translation id="7072208053150563108">Įrenginio slaptažodžio keitimo dažnis</translation>
<translation id="7074513465313721551">Konfigūruojamas domenų, kuriais Saugaus naršymo funkcija galėtų pasitikėti, sąrašas. Tai reiškia, kad:
      Saugaus naršymo funkcija netikrins pavojingų šaltinių (pvz., sukčiavimo, kenkėjiškų programų ar nepageidaujamos programinės įrangos), jei jų URL atitiks šiuos domenus;
      naudojant Saugaus naršymo atsisiuntimo apsaugos paslaugą nebus tikrinami šiuose domenuose priglobiami atsisiuntimai;
      naudojant Saugaus naršymo slaptažodžių apsaugos paslaugą nebus tikrinama, ar slaptažodis naudojamas pakartotinai, jei puslapio URL atitiks šiuos domenus.

      Jei šis nustatymas įgalintas, Saugaus naršymo funkcija pasitikės šiais domenais.
      Jei šis nustatymas išjungtas arba nenustatytas, visiems šaltiniams taikoma numatytoji Saugaus naršymo apsauga.
       Ši politika nepasiekiama „Windows“ objektuose, kurie nesusieti su „<ph name="MS_AD_NAME" />“ domenu.</translation>
<translation id="7079519252486108041">Blokuoti iššokančiuosius langus šiose svetainėse</translation>
<translation id="7085803328069945025">Galite nustatyti URL šablonų, kuriuose nurodomos svetainės, kurioms leidžiama prašyti naudotojo suteikti jiems galimybę pasiekti USB įrenginį, sąrašą.

          Jei ši politika nenustatyta, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultWebUsbGuardSetting“ (jei ji nustatyta) arba naudotojo asmeninės konfigūracijos (kitu atveju).

          Šios politikos URL šablonai negali būti nesuderinami su tais, kurie sukonfigūruoti naudojant „WebUsbBlockedForUrls“. Nenurodyta, kuri iš dviejų politikų turi pirmenybę, jei URL atitinka jas abi.</translation>
<translation id="7106631983877564505">Kai „<ph name="PRODUCT_OS_NAME" />“ įrenginiai tampa neaktyvūs ar sustabdomi, įjungiamas užraktas.

      Jei įgalinsite šį nustatymą, naudotojų bus prašoma pateikti slaptažodį, kad būtų galima atrakinti įrenginį iš miego režimo.

      Jei išjungsite šį nustatymą, naudotojų nebus prašoma pateikti slaptažodžio norint atrakinti įrenginį iš miego režimo.

      Jei įgalinsite arba išjungsite šį nustatymą, naudotojai negalės jo pakeisti arba nepaisyti.

      Nenustačius politikos, naudotojas galės pasirinkti, ar atrakinant įrenginį turi būti prašoma slaptažodžio.</translation>
<translation id="7115494316187648452">Nustatoma, ar „<ph name="PRODUCT_NAME" />“ procesas pradedamas prisijungiant prie OS ir toliau vykdomas, kai uždaromas paskutinis naršyklės langas, leidžiant foninėms programoms ir dabartinei naršymo sesijai išlikti aktyvioms, įskaitant visus sesijos slapukus. Vykdant foninį procesą pateikiama piktograma sistemos juostelėje; jį galima bet kada čia uždaryti.

      Jei ši politika nustatyta į „True“, foninis režimas įgalinamas ir naudotojas negali jo valdyti naršyklės nustatymuose.

      Jei ši politika nustatyta į „False“, foninis režimas išjungiamas ir naudotojas negali jo valdyti naršyklės nustatymuose.

      Nenustačius šios politikos foninis režimas iš pradžių išjungiamas ir jį gali valdyti naudotojas naršyklės nustatymuose.</translation>
<translation id="7126716959063786004">Įgalinti procesų užbaigimą užduočių tvarkytuvėje</translation>
<translation id="7127892035367404455">Tikslinės versijos grąžinimas</translation>
<translation id="7128918109610518786">Programų identifikatorių sąrašas „<ph name="PRODUCT_OS_NAME" />“ rodomas kaip paleidimo priemonės juostoje prisegtos programos.

      Jei sukonfigūruota ši politika, nustatomas programų sąrašas ir naudotojas jo keisti negali.

      Jei ši politika paliekama nenustatyta, naudotojas gali pakeisti paleidimo priemonėje prisegtų programų sąrašą.</translation>
<translation id="7132877481099023201">URL, kuriems bus suteikta prieiga prie vaizdo įrašų užfiksavimo įrenginių be paraginimo</translation>
<translation id="7167436895080860385">Leisti naudotojams rodyti slaptažodžius slaptažodžių tvarkytuvėje (nebenaudojama)</translation>
<translation id="7173856672248996428">Efemeriškas profilis</translation>
<translation id="717630378807352957">Leisti naudoti visus spausdintuvus pasitelkus konfigūracijos failą.</translation>
<translation id="7176721759719212761">Nurodoma, ar leidžiami ekrano pažadinimo užraktai. Ekrano pažadinimo užraktų užklausas gali teikti plėtiniai, naudodami energijos tvarkymo plėtinio API, ir ARC programos.

          Jei ši politika nustatyta kaip „Tiesa“ arba nenustatyta, ekrano pažadinimo užraktams leidžiama tvarkyti energiją, nebent „AllowWakeLocks“ nustatyta kaip „Netiesa“.

          Jei ši politika nustatyta kaip „Netiesa“, ekrano pažadinimo užraktų užklausos pažeminamos ir nustatomos kaip sistemos pažadinimo užraktų užklausos.</translation>
<translation id="7185078796915954712">1.3 versijos TLS</translation>
<translation id="718956142899066210">Leistini ryšio tipai naujinant</translation>
<translation id="7194407337890404814">Numatytojo paieškos teikėjo pavadinimas</translation>
<translation id="7202925763179776247">Atsisiuntimų apribojimų leidimas</translation>
<translation id="7207095846245296855">Priverstinis „Google“ saugios paieškos naudojimas</translation>
<translation id="7216442368414164495">Naudotojams leidžiama pasirinkti Saugaus naršymo išplėstinių ataskaitų teikimą</translation>
<translation id="7221822638060296742">Galima nustatyti, ar svetainėse leidžiama automatiškai vykdyti papildinį „<ph name="FLASH_PLUGIN_NAME" />“. Automatiškai vykdyti papildinį „<ph name="FLASH_PLUGIN_NAME" />“ gali būti arba leidžiama visose svetainėse, arba draudžiama visose svetainėse.

          Naudojant paleidimo paspaudus funkciją galima vykdyti papildinį „<ph name="FLASH_PLUGIN_NAME" />“, bet naudotojas turi spustelėti rezervuotą vietą, kad pradėtų jo vykdymo procesą.

          Automatinis atkūrimas leidžiamas tik tuose domenuose, kurie yra aiškiai nurodyti politikoje „<ph name="PLUGINS_ALLOWED_FOR_URLS_POLICY_NAME" />“. Jei norite įgalinti atkūrimą visose svetainėse, pabandykite prie šio sąrašo pridėti „http://*“ ir „https://*“.

          Jei ši politika bus nenustatyta, naudotojas galės keisti šį nustatymą patys.</translation>
<translation id="7229975860249300121">Nurodant, kurios „Google“ paskyros gali būti nustatytos kaip naršyklės pagrindinės paskyros sistemoje „<ph name="PRODUCT_NAME" />“ (t. y. paskyra, kuri pasirenkama atliekant sinchronizavimo pasirinkimo veiksmus), naudojamas reguliarusis reiškinys.

      Jei naudotojas bando nustatyti naršyklės pagrindinę paskyrą naudotojo vardu, neatitinkančiu šio šablono, pateikiama atitinkama klaida.

      Jei ši politika nenustatyta arba jos laukas tuščias, naudotojas gali nustatyti bet kurią „Google“ paskyrą kaip naršyklės pagrindinę paskyrą sistemoje „<ph name="PRODUCT_NAME" />“.</translation>
<translation id="723103540848640830">Nustatyti minimalų ekrano užrakto PIN kodo ilgį</translation>
<translation id="7232816984286843471">Jei politika nustatyta kaip „Netiesa“, nesusietiems naudotojams nebus leidžiama naudoti „Crostini“.

      Jei politika nenustatyta arba nustatyta kaip „Tiesa“, „Crostini“ leidžiama naudoti visiems naudotojams, jei tai taip pat leidžiama pagal kitus nustatymus.
      Visų trijų tipų politika („VirtualMachinesAllowed“, „CrostiniAllowed“ ir „DeviceUnaffiliatedCrostiniAllowed“) turi būti nustatyta kaip „Tiesa“, kai taikoma „Crostini“, kad būtų leidžiama vykdyti.
      Kai ši politika pakeičiama į „Netiesa“, ji taikoma paleidžiant naujus „Crostini“ sudėtinius rodinius, bet nesustabdo jau vykdomų sudėtinių rodinių.</translation>
<translation id="7234280155140786597">Draudžiamų savųjų susirašinėjimo pranešimais programų prieglobų pavadinimų pavadinimai (arba simbolis *, nurodantis jas visas)</translation>
<translation id="7236775576470542603">Nustatyti numatytąjį ekrano didinimo tipą, kuris įgalintas prisijungimo ekrane.

          Jei ši politika nustatyta, pagal ją nustatomas ekrano didinimo tipas, kuris įgalinamas, kai rodomas prisijungimo ekranas. Nustačius politiką į „Joks“, ekrano didinimas išjungiamas.

          Jei nustatysite šią politiką, naudotojai galės laikinai jos nepaisyti įgalinę arba išjungę ekrano didinimą. Tačiau naudotojo pasirinkimas nėra ilgalaikis ir numatytasis nustatymas atkuriamas, kai iš naujo rodomas prisijungimo ekranas arba naudotojas vieną minutę neatlieka jokių veiksmų prisijungimo ekrane.

          Jei ši politika nenustatyta, ekrano didinimas išjungiamas, kai pirmą kartą rodomas prisijungimo ekranas. Naudotojai gali bet kada įjungti arba išjungti ekrano didinimą ir jo būsena skirtingiems naudotojams prisijungimo ekrane bus vienoda.</translation>
<translation id="7249828445670652637">Įgalinti „<ph name="PRODUCT_OS_NAME" />“ CA sertifikatus ARC programose</translation>
<translation id="725322441686394886">Jei nustatymas nenustatytas, „Chrome“ valymo įrankiui aptikus nepageidaujamos programinės įrangos, „Google“ gali būti pateikta nuskaitymo metaduomenų ataskaita, vadovaujantis „SafeBrowsingExtendedReportingEnabled“ nustatyta politika. Tada naudojant „Chrome“ valymo įrankį naudotojo bus klausiama, ar jis nori išvalyti nepageidaujamą programinę įrangą. Naudotojas gali pasirinkti bendrinti valymo rezultatus su „Google“, kad padėtų vėliau aptikti nepageidaujamą programinę įrangą. Šie rezultatai apima failų metaduomenis, automatiškai įdiegtus plėtinius ir registro raktus, kaip aprašyta „Chrome“ privatumo baltojoje knygoje.

      Jei nustatymas išjungtas, „Chrome“ valymo įrankiui aptikus nepageidaujamos programinės įrangos, nuskaitymo metaduomenų ataskaita „Google“ nebus teikiama, nepaisant bet kokios „SafeBrowsingExtendedReportingEnabled“ nustatytos politikos. Naudojant „Chrome“ valymo įrankį naudotojo bus klausiama, ar jis nori išvalyti nepageidaujamą programinę įrangą. „Google“ nebus teikiama valymo rezultatų ataskaita ir naudotojui nebus suteikta parinktis tai atlikti.

      Jei nustatymas įgalintas, „Chrome“ valymo įrankiui aptikus nepageidaujamos programinės įrangos, „Google“ gali būti pateikta nuskaitymo metaduomenų ataskaita, vadovaujantis „SafeBrowsingExtendedReportingEnabled“ nustatyta politika. Naudojant „Chrome“ valymo įrankį naudotojo bus klausiama, ar jis nori išvalyti nepageidaujamą programinę įrangą. Valymo rezultatų ataskaita bus pateikta „Google“ ir naudotojas negalės jos neteikti.

      Ši politika nepasiekiama „Windows“ objektuose, kurie nesusieti su „<ph name="MS_AD_NAME" />“ domenu.</translation>
<translation id="7258823566580374486">Įgalinti nuotolinės prieigos prieglobų slėpimą</translation>
<translation id="7260277299188117560">Įgalintas automatinis P2P naujinys</translation>
<translation id="7261252191178797385">Įrenginio ekrano fono vaizdas</translation>
<translation id="7264704483008663819">Ši politika nebetaikoma naudojant M68. Naudokite „DeveloperToolsAvailability“.

      Išjungiami kūrėjo įrankiai ir „JavaScript“ pultas.

      Jei įgalinsite šį nustatymą, nebebus galima pasiekti kūrėjo įrankių ir patikrinti svetainės elementų. Bus išjungti visi spartieji klavišai ir meniu ar kontekstinių meniu įrašai, skirti kūrėjo įrankiams ar „JavaScript“ pultui atidaryti.

      Išjungus šią parinktį ar jos nenustačius naudotojai galės naudoti kūrėjo įrankius ir „JavaScript“ pultą.

      Nustačius politiką „DeveloperToolsAvailability“, politikos „DeveloperToolsDisabled“ vertės nepaisoma.</translation>
<translation id="7266471712301230894">Ši politika pašalinta 64 ir naujesnės versijos „<ph name="PRODUCT_NAME" />“.

      Automatinė trūkstamų plėtinių paieška ir diegimas nebepalaikomi.</translation>
<translation id="7267809745244694722">Medijos klavišai pagal numatytuosius nustatymus veikia kaip funkcijų klavišai</translation>
<translation id="7271085005502526897">Importuoti pagrindinį puslapį iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="7273823081800296768">Jei šis nustatymas įgalintas arba nesukonfigūruotas, naudotojai gali pasirinkti susieti klientus ir prieglobas prisijungdami ir nereikia kaskart įvesti PIN kodo.

          Jei šis nustatymas neleidžiamas, ši funkcija nepasiekiama.</translation>
<translation id="7275334191706090484">Tvarkomos žymės</translation>
<translation id="7295019613773647480">Įgalinti prižiūrimus naudotojus</translation>
<translation id="7301543427086558500">Nurodomas alternatyvių URL, kuriuos galima naudoti paieškos terminams iš paieškos variklio gauti, sąrašas. URL turėtų būti eilutė „<ph name="SEARCH_TERM_MARKER" />“, kuri bus naudojama paieškos terminams gauti.

          Ši politika yra pasirenkamoji. Jei ji nenustatyta, gaunant paieškos terminus nebus naudojami jokie alternatyvūs URL.

          Ši politika taikoma, tik jei įgalinta politika „DefaultSearchProviderEnabled“.</translation>
<translation id="7302043767260300182">Ekrano užrakto delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="7311458740754205918">Jei ši politika nustatyta kaip „true“ arba nenustatyta, naujo skirtuko puslapyje gali būti rodomi turinio pasiūlymai pagal naudotojo naršymo istoriją, pomėgius ir vietovę.

      Jei ši politika nustatyta kaip „false“, automatiškai sugeneruoti turinio pasiūlymai naujo skirtuko puslapyje nerodomi.</translation>
<translation id="7313793931637495417">Ši politika valdo, ar pranešti versijos informaciją, pvz., OS versiją, OS platformą, OS architektūrą, „<ph name="PRODUCT_NAME" />“ versiją ir „<ph name="PRODUCT_NAME" />“ kanalą.

      Kai ši politika nenustatyta arba nustatyta kaip „Tiesa“, versijos informacija renkama.
      Kai ši politika nustatyta kaip „Netiesa“, versijos informacija nerenkama.

      Ši politika galioja, tik kai įgalintas <ph name="CHROME_REPORTING_EXTENSION_NAME" />“ ir įrenginyje užregistruota „<ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />“.</translation>
<translation id="7323896582714668701">Papildomi „<ph name="PRODUCT_NAME" />“ komandinės eilutės parametrai</translation>
<translation id="7326394567531622570">Panašu į „Wipe“ (2 vertė), bet bandoma išsaugoti prisijungimo prieigos raktus, kad naudotojui nereikėtų prisijungti dar kartą.</translation>
<translation id="7329842439428490522">Nurodoma laiko trukmė be naudotojo įvesties, po kurios ekranas išjungiamas, kai naudojama akumuliatoriaus energija.

          Kai šios politikos vertė yra didesnė už nulį, ji nurodo laiko trukmę, kurią naudotojas turi neatlikti jokių veiksmų, kol „<ph name="PRODUCT_OS_NAME" />“ išjungs ekraną.

          Kai ši politika nustatyta į nulį, „<ph name="PRODUCT_OS_NAME" />“ neišjungia ekrano, kai naudotojas neatlieka jokių veiksmų.

          Kai ši politika nenustatyta, naudojama numatytoji laiko trukmė.

          Politikos vertė turėtų būti nurodoma milisekundėmis. Vertės sumažinamos, kad neviršytų neveikos delsos laiko.</translation>
<translation id="7329968046053403405">Nurodo paskyrų, pateiktų „Android“ autentifikavimo programos, palaikančios <ph name="HTTP_NEGOTIATE" /> autentifikavimą (t. y. „Kerberos“ autentifikavimą), paskyros tipą. Šią informaciją turėtų pateikti autentifikavimo programos teikėjas. Daugiau išsamios informacijos žr. adresu https://goo.gl/hajyfN.

          Jei nepateikiamas joks nustatymas, <ph name="HTTP_NEGOTIATE" /> autentifikavimas išjungiamas sistemoje „Android“.</translation>
<translation id="7331962793961469250">Kai bus nustatyta į „Tiesa“, „Chrome“ internetinės parduotuvės programų reklamos nebus rodomos naujo skirtuko puslapyje.

      Nustačius šią parinktį į „Netiesa“ arba jos nenustačius „Chrome“ internetinės parduotuvės programų reklamos bus rodomos naujo skirtuko puslapyje</translation>
<translation id="7332963785317884918">Ši politika nebenaudojama. „<ph name="PRODUCT_OS_NAME" />“ visada bus naudojama „RemoveLRU“ išvalymo strategija.

      Valdoma automatinė išvalymo elgsena „<ph name="PRODUCT_OS_NAME" />“ įrenginiuose. Automatinis išvalymas suaktyvinamas, kai lieka labai mažai laisvos vietos diske, kad ji būtų atkurta.

      Jei ši politika nustatyta į „RemoveLRU“, automatinis išvalymas ir toliau šalins naudotojus iš įrenginio pagal seniausiai prisijungusiųjų tvarką, kol liks pakankamai laisvos vietos.

      Jei ši politika nustatyta į „RemoveLRUIfDormant“, automatinis išvalymas šalins naudotojus, kurie neprisijungė bent 3 mėnesius (pagal seniausiai prisijungusiųjų tvarką), kol liks pakankamai laisvos vietos.

      Jei ši politika nenustatyta, automatinis išvalymas naudos numatytąją įdiegtą strategiją. Šiuo metu tai strategija „RemoveLRUIfDormant“.</translation>
<translation id="7336878834592315572">Išsaugoti slapukus vykstant sesijai</translation>
<translation id="7337967786223261174">Konfigūruojamas spausdintuvų sąrašas.

      Taikant šią politiką leidžiama administratoriams teikti spausdintuvo konfigūracijas
      naudotojams.

      „<ph name="PRINTER_DISPLAY_NAME" />“ ir „<ph name="PRINTER_DESCRIPTION" />“ yra laisvos formos eilutės, kurias galima tinkinti, kad būtų lengviau pasirinkti spausdintuvą. „<ph name="PRINTER_MANUFACTURER" />“ ir „<ph name="PRINTER_MODEL" />“ naudojami, kad galutiniams naudotojams būtų lengviau identifikuoti spausdintuvą. Jie nurodo spausdintuvo gamintoją ir modelį. <ph name="PRINTER_URI" /> turėtų būti adresas, kurį galima pasiekti iš kliento kompiuterio, įskaitant <ph name="URI_SCHEME" />, <ph name="URI_PORT" /> ir <ph name="URI_QUEUE" />. <ph name="PRINTER_UUID" /> yra pasirenkamas. Jei nurodytas, jis naudojamas siekiant panaikinti pasikartojančius „<ph name="ZEROCONF_DISCOVERY" />“ spausdintuvus.

      „<ph name="PRINTER_EFFECTIVE_MODEL" />“ turi atitikti vieną iš eilučių, nurodančių „<ph name="PRODUCT_NAME" />“ palaikomą spausdintuvą. Eilutė bus naudojama siekiant identifikuoti ir įdiegti tinkamą spausdintuvo PPD. Daugiau informacijos galima rasti adresu https://support.google.com/chrome?p=noncloudprint.

      Spausdintuvo sąranka užbaigiama pirmą kartą naudojant spausdintuvą. PPD neatsisiunčiami, jei spausdintuvas nenaudojamas. Vėliau dažnai naudojami PPD saugomi talpykloje.

      Ši politika neturi įtakos tam, ar naudotojai gali konfigūruoti spausdintuvus atskiruose įrenginiuose. Ji skirta papildyti atskirų naudotojų spausdintuvų konfigūraciją.

      Jei naudojami „Active Directory“ tvarkomi įrenginiai, ši politika palaiko „Active Directory“ įrenginio pavadinimo „<ph name="MACHINE_NAME_VARIABLE" />“ arba jo poeilučio plėtinį. Pavyzdžiui, jei įrenginio pavadinimas yra „<ph name="MACHINE_NAME_EXAMPLE" />“, tada „<ph name="MACHINE_NAME_VARIABLE_EXAMPLE" />“ turėtų būti pakeistas 4 simboliais nuo 6-osios pozicijos, pvz., „<ph name="MACHINE_NAME_PART_EXAMPLE" />“. Atminkite, kad pozicija nustatoma nuo nulio.
      <ph name="MACHINE_NAME_VARIABLE_LOWERCASE" /> (mažosios raidės) ši politika nebenaudojama M71 ir bus pašalinta iš M72.
      </translation>
<translation id="7340034977315324840">Pranešti įrenginio veiklos laiką</translation>
<translation id="7343497214039883642">Įrenginiams skirtas įmonės spausdintuvų konfigūracijos failas</translation>
<translation id="7349338075015720646">Nurodomas svetainių, įdiegtų automatiškai, naudotojui neatliekant jokių veiksmų, sąrašas. Naudotojas negali jų nei išdiegti, nei išjungti.

      Kiekvienas politikos sąrašo elementas yra objektas iš dviejų narių: „url“ ir „launch_container“. „url“ turėtų būti diegiamos žiniatinklio programos URL, o „launch_container“ – „window“ arba „tab“, skirti atskirti, kaip žiniatinklio programa atidaroma įdiegus. Praleidus „launch_container“, programa bus paleista lange, jei „Chrome“ įvertins ją kaip laipsniškąją žiniatinklio programą, skirtuke – jei įvertins kitaip.</translation>
<translation id="735902178936442460">Ši politika valdo, ar pranešti informaciją, kurią galima naudoti įrenginiams identifikuoti, pvz., įrenginio pavadinimą ir tinklo adresus.

      Kai ši politika nenustatyta arba nustatyta kaip „Tiesa“, informacija, kurią galima naudoti įrenginiams identifikuoti, renkama.
      Kai ši politika nustatyta kaip „Netiesa“, informacija, kurią galima naudoti įrenginiams identifikuoti, nerenkama.

      Ši politika galioja, tik kai įgalintas „<ph name="CHROME_REPORTING_EXTENSION_NAME" />“ ir įrenginyje užregistruota „<ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />“.</translation>
<translation id="7367028210010532881">Naudojant Saugaus naršymo paslaugą rodomas įspėjimo puslapis, kai naudotojai naršo svetaines, kurios pažymėtos kaip potencialiai kenkėjiškos. Įgalinus šį nustatymą neleidžiama naudotojams iš įspėjimo puslapio tęsti veiksmų kenkėjiškoje svetainėje.

      Jei šis nustatymas išjungtas arba nesukonfigūruotas, naudotojai gali pasirinkti tęsti veiksmus pažymėtoje svetainėje, kai parodomas įspėjimas.

      Daugiau informacijos apie Saugų naršymą pateikiama adresu https://developers.google.com/safe-browsing.</translation>
<translation id="737655323154569539">Apribojamas spausdinamo puslapio dydis. Jei politika nenustatyta ar nenurodyta vertė, netaikomas joks apribojimas.</translation>
<translation id="7417728346887499628">Jei šis nustatymas išjungtas, „Chrome“ valymo įrankiui neleidžiama nuskaityti sistemos ieškant nepageidaujamos programinės įrangos ir atlikti valymo veiksmų. Neautomatinis „Chrome“ valymo įrankio suaktyvinimas apsilankius adresu chrome://settings/cleanup išjungtas.

      Jei šis nustatymas įgalintas arba nenustatytas, „Chrome“ valymo įrankis periodiškai nuskaitys sistemą ieškodamas nepageidaujamos programinės įrangos, o radus tokios įrangos naudotojo bus klausiama, ar jis nori ją pašalinti. Neautomatinis „Chrome“ valymo įrankio suaktyvinimas apsilankius adresu chrome://settings įgalintas.

      Ši politika nepasiekiama „Windows“ objektuose, kurie nesusieti su „<ph name="MS_AD_NAME" />“ domenu.</translation>
<translation id="7417972229667085380">Procentas, pagal kurį bus keičiamas neveikos delsos mastelis dirbant pristatymo režimu (nebenaudojama)</translation>
<translation id="7421483919690710988">Nustatyti medijos disko talpyklos dydį baitais</translation>
<translation id="7424751532654212117">Neleidžiamų papildinių sąrašo išimčių sąrašas</translation>
<translation id="7426112309807051726">Nurodo, ar reikia išjungti <ph name="TLS_FALSE_START" /> optimizavimą. Atsižvelgiant į istoriją, ši politika pavadinta „DisableSSLRecordSplitting“.

      Jei politika nenustatyta arba nustatyta į „false“, <ph name="TLS_FALSE_START" /> įgalinamas. Jei ji nustatyta į „true“, <ph name="TLS_FALSE_START" /> išjungiamas.</translation>
<translation id="7433714841194914373">Įgalinti intuityviąją paiešką</translation>
<translation id="7443061725198440541">Jei ši politika nenustatyta arba neįgalinta, naudotojui leidžiama naudoti rašybos tikrinimą.

      Jei ši politika išjungta, naudotojui neleidžiama naudoti rašybos tikrinimo. Politikos „SpellcheckLanguage“ taip pat bus nepaisoma, kai ši politika išjungta.
      </translation>
<translation id="7443616896860707393">Mišrios kilmės HTTP pagrindinio autentifikavimo raginimai</translation>
<translation id="7458437477941640506">Negrąžinti tikslinės versijos, jei OS versija naujesnė nei tikslinė. Naujiniai taip pat išjungiami.</translation>
<translation id="7464991223784276288">Ribojami slapukai, kad URL nesutaptų su dabartine sesija</translation>
<translation id="7469554574977894907">Įgalinti paieškos pasiūlymus</translation>
<translation id="7474249562477552702">Ar leidžiami SHA-1 pasirašyti sertifikatai, išduoti naudojant vietinius patikimus prieraišus</translation>
<translation id="7485481791539008776">Numatytojo spausdintuvo pasirinkimo taisyklės</translation>
<translation id="749556411189861380">Pateikti užregistruotų įrenginių OS ir programinės aparatinės įrangos versiją.

      Jei šis nustatymas nenustatytas arba nustatytas kaip „True“, užregistruoti įrenginiai periodiškai pateiks OS ir programinės aparatinės įrangos versiją. Jei nustatymas nustatytas kaip „False“, versijos informacija nebus pateikta.</translation>
<translation id="7498946151094347510">Nurodomi spausdintuvai, kurių naudotojas negali naudoti.

      Ši politika naudojama, tik jei pasirinktas politikos „<ph name="DEVICE_PRINTERS_ACCESS_MODE" />“ nustatymas „<ph name="PRINTERS_BLACKLIST" />“.

      Jei ši politika naudojama, naudotojui teikiami visi spausdintuvai, išskyrus šioje politikoje nurodytus ID. ID turi atitikti laukus „id“ arba „guid“ faile, kuris nurodytas „<ph name="DEVICE_PRINTERS_POLICY" />“.
      </translation>
<translation id="7511361072385293666">Jei ši politika nustatyta į „true“ arba yra nenustatyta, QUIC protokolo naudojimas sistemoje „<ph name="PRODUCT_NAME" />“ leidžiamas.
      Jei ši politika nustatyta į „false“ QUIC protokolo naudojimas neleidžiamas.</translation>
<translation id="7517845714620372896">Nurodomas ekrano skaisčio procentas.
          Kai ši politika nustatyta, pirminis ekrano skaistis koreguojamas pagal politikos vertę, bet naudotojas vėliau gali ją pakeisti. Automatinio skaisčio funkcijos išjungtos.
          Kai ši politika nenustatyta, tai neturi įtakos naudotojo ekrano valdikliams ir automatinio skaisčio funkcijoms.
          Politikos vertės turi būti nurodytos procentais nuo 0 iki 100.</translation>
<translation id="7519251620064708155">Leisti rakto generavimą šiose svetainėse</translation>
<translation id="7529100000224450960">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose leidžiama atidaryti iššokančiuosius langus, sąrašą.

          Nenustačius šios politikos, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „Numatytasis iššokančiųjų langų nustatymas“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="7529144158022474049">Automatiškai atnaujinamas sklaidos veiksnys</translation>
<translation id="7534199150025803530">Ši politika neturi įtakos „Android“ skirtai „Google“ disko programai. Jei norite neleisti naudoti „Google“ disko veikiant koriniam ryšiui, turėtumėte uždrausti „Android“ skirtos „Google“ disko programos diegimą.</translation>
<translation id="7547549430720182663">Sujungti</translation>
<translation id="7553535237300701827">Kai ši politika nustatyta, prisijungimo autentifikavimo eiga priklausys nuo nustatymo vertės:

      Jei vertė nustatyta į GAIA, prisijungimas bus atliekamas naudojant įprastą GAIA autentifikavimo eigą.

      Jei vertė nustatyta į SAML_INTERSTITIAL, prisijungiant bus rodomas tarpinis ekranas, kuriame naudotojui bus siūloma tęsti autentifikavimą per įrenginio registravimo domeno „SAML IdP“ arba grįžti į įprastą GAIA prisijungimo eigą.</translation>
<translation id="755951849901630953">Įgalinami visų „<ph name="PRODUCT_NAME" />“ komponentų naujiniai, kai nenustatyta arba nustatyta į „True“.

      Jei nustatyta į „False“, komponentų naujiniai bus išjungti. Tačiau kai kuriems komponentams ši politika netaikoma: komponentų, kuriuose nėra vykdomojo kodo, arba kurie nežymiai pakeičia naršyklės veikimą ar kurie yra labai svarbūs jos saugai, naujiniai nėra išjungiami.
      Tokių komponentų pavyzdžiai yra sertifikatų anuliavimo sąrašai ir Saugaus naršymo duomenys.
      Daugiau informacijos apie Saugų naršymą pateikiama adresu https://developers.google.com/safe-browsing.</translation>
<translation id="7566878661979235378">SAML prisijungimo autentifikavimo tipas</translation>
<translation id="757395965347379751">Kai šis nustatymas įgalintas, „<ph name="PRODUCT_NAME" />“ leidžia naudoti SHA-1 pasirašytus sertifikatus, jei jie yra sėkmingai patvirtinti ir yra susiję su vietiniu mastu įdiegtais CA sertifikatais.

      Atminkite, kad ši politika pagrįsta operacinės sistemos sertifikatu, kuriuo leidžiami SHA-1 parašai. Jei atnaujinus OS pasikeičia OS SHA-1 sertifikatų apdorojimo būdas, ši politika gali nebegalioti.  Be to, ši politika teikiama kaip laikinas sprendimo būdas, kuris įmonėms suteikia daugiau laiko pereiti nuo SHA-1.  Ši politika bus pašalinta 2019 m. sausio 1 d. arba šiek tiek vėliau / anksčiau.

      Jei ši politika nenustatyta arba nustatyta į „false“, „<ph name="PRODUCT_NAME" />“ vykdys viešai paskelbtą SHA-1 naudojimo nutraukimo tvarkaraštį.</translation>
<translation id="7593523670408385997">Konfigūruojamas talpyklos, kurią „<ph name="PRODUCT_NAME" />“ naudos talpyklos failams diske saugoti, dydį.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME" />“ naudos nurodyto dydžio talpyklą nepaisydama to, ar naudotojas nurodė, ar nenurodė parametro „--disk-cache-size“. Šioje politikoje nurodyta vertė nėra griežta riba, bet tiesiog pasiūlymas talpyklos sistemai. Mažesnė nei kelių megabaitų vertė yra per maža ir bus suapvalinta iki įprastos minimalios vertės.

      Jei politikos vertė nustatoma į 0, bus naudojama numatytojo dydžio talpykla, bet naudotojas negalės jos pakeisti.

      Jei ši politika nenustatyta, bus naudojamas numatytasis dydis, o naudotojas galės jį perrašyti naudodamas parametrą „--disk-cache-size“.</translation>
<translation id="759957074386651883">Saugaus naršymo nustatymai</translation>
<translation id="7604169113182304895">„Android“ programos gali pasirinkti atsižvelgti į šį sąrašą. Negalite priversti jų atsižvelgti į jį.</translation>
<translation id="7612157962821894603">Visos sistemos žymos, kurios bus taikomos paleidžiant „<ph name="PRODUCT_NAME" />“</translation>
<translation id="7614663184588396421">Neleidžiamų protokolų schemų sąrašas</translation>
<translation id="7617319494457709698">Pagal šią politiką nustatomi plėtiniai, kuriems leidžiama naudoti „<ph name="ENTERPRISE_PLATFORM_KEYS_API" />“ funkciją „<ph name="CHALLENGE_USER_KEY_FUNCTION" />“ patvirtinant nuotoliniu būdu. Plėtiniai turi būti pridėti prie šio sąrašo, kad būtų galima naudoti API.

          Jei plėtinio nėra sąraše arba sąrašas nenustatytas, iškviečiant API įvyks klaida ir bus pateiktas jos kodas.</translation>
<translation id="7618907117929117943">Grąžinti ir palikti tikslinę versiją, jei OS versija naujesnė nei tikslinė ir galima perduoti įrenginio lygio konfigūraciją (įskaitant tinklo prisijungimo duomenis) grąžinant, taip pat praleidžiant OOBE po grąžinimo. Nevykdykite ar nenutraukite grąžinimo, jei tai neįmanoma (nes tikslinė versija nepalaiko duomenų atkūrimo arba dėl nesuderinamo atgalinio pakeitimo).
          Palaikoma naudojant 70 ir naujesnių versijų „<ph name="PRODUCT_OS_NAME" />“. Jei kliento programa senesnė, ši vertė reiškia, kad grąžinimas išjungtas.</translation>
<translation id="7625444193696794922">Nurodomas leidimo kanalas, su kuriuo šis įrenginys turėtų būti sujungtas.</translation>
<translation id="7632724434767231364">GSSAPI bibliotekos pavadinimas</translation>
<translation id="7635471475589566552">„<ph name="PRODUCT_NAME" />“ konfigūruojama programos lokalė ir naudotojams neleidžiama jos keisti.

      Jei įgalinsite šį nustatymą, „<ph name="PRODUCT_NAME" />“ naudos nurodytą lokalę. Jei sukonfigūruota lokalė nebus palaikoma, bus naudojama „en-US“.

      Jei šio nustatymo neleisite arba nekonfigūruosite, „<ph name="PRODUCT_NAME" />“ naudos naudotojo nurodytą pageidaujamą lokalę (jei ji sukonfigūruota), sistemos lokalę arba atsarginę lokalę „en-US“.</translation>
<translation id="7641363659597330616">Konfigūruojamas atsisiuntimų, kuriuos „<ph name="PRODUCT_NAME" />“ visiškai užblokuos, tipas ir naudotojams neleidžiama nepaisyti saugos sprendimo.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME" />“ neleis tam tikrų tipų atsisiuntimų ir naudotojai negalės nepaisyti saugos įspėjimų.

      Kai pasirinkta parinktis „Blokuoti pavojingus atsisiuntimus“, bus leidžiami visi atsisiuntimai, išskyrus atsisiuntimus su Saugaus naršymo įspėjimais.

      Kai pasirinkta parinktis „Blokuoti potencialiai pavojingus atsisiuntimus“, leidžiami visi atsisiuntimai, išskyrus atsisiuntimus su Saugaus naršymo įspėjimais apie potencialiai pavojingus atsisiuntimus.

      Kai pasirinkta parinktis „Blokuoti visus atsisiuntimus“, blokuojami visi atsisiuntimai.

      Kai ši politika nenustatyta (arba pasirinkta parinktis „Nėra specialių apribojimų“), atsisiuntimams bus taikomi įprasti saugos apribojimai, nustatyti atsižvelgiant į Saugaus naršymo analizės rezultatus.

      Atminkite, kad šie apribojimai taikomi atsisiuntimams, kurie suaktyvinti iš tinklalapio turinio ir naudojant kontekstinio meniu parinktį „atsisiųsti nuorodą...“. Šie apribojimai netaikomi, kai naudojama parinktis išsaugoti / atsisiųsti rodomą puslapį arba naudojama spausdinimo parinktis išsaugoti puslapį kaip PDF.

      Daugiau informacijos apie Saugų naršymą pateikiama adresu https://developers.google.com/safe-browsing.</translation>
<translation id="7643883929273267746">„<ph name="PRODUCT_NAME" />“ matomų paskyrų ribojimas</translation>
<translation id="7651739109954974365">Nustatoma, ar įrenginyje turėtų būti įgalintas duomenų tarptinklinis ryšys. Jei nustatyta į „true“ (tiesa), leidžiamas duomenų tarptinklinis ryšys. Jei nesukonfigūruojama ar nustatoma į „false“, duomenų tarptinklinis ryšys nepasiekiamas.</translation>
<translation id="7673194325208122247">Laikotarpis (milisekundėmis)</translation>
<translation id="7676708657861783864">Pagal puslapius, atitinkančius šiuos URL šablonus, nustatyti slapukai bus ribojami ir taikomi tik dabartinei sesijai, t. y. išėjus iš naršyklės jie bus ištrinti.

          URL, parengtiems ne pagal čia nurodytus šablonus, arba visiems URL, kai nenustatyta ši politika, bus naudojama visuotinė numatytoji vertė iš politikos „DefaultCookiesSetting“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.

          Atminkite, kad jei „<ph name="PRODUCT_NAME" />“ veikia foninio atkūrimo režimu, sesijos negalima uždaryti, kai uždaromas paskutinis naršyklės langas, bet reikia palikti aktyvią, kol išeinama iš naršyklės. Daugiau informacijos apie šio veikimo konfigūravimą galite gauti peržiūrėję politiką „BackgroundModeEnabled“.

          Taip pat žiūrėkite politikas „CookiesAllowedForUrls“ ir „CookiesBlockedForUrls“. Atminkite, kad negali būti nesuderinamų šių trijų politikų URL šablonų, nes nenurodyta, kuriai politikai teikiama pirmenybė.

          Jei politika „RestoreOnStartup“ nustatyta atkurti URL iš ankstesnių sesijų, į šią politiką nebus atsižvelgiama ir slapukai tose svetainėse bus išsaugomi visam laikui.</translation>
<translation id="7683777542468165012">Dinaminis politikos atnaujinimas</translation>
<translation id="7694807474048279351">Suplanuoti automatinį operacinės sistemos įkėlimą, kai pritaikytas „<ph name="PRODUCT_OS_NAME" />“ naujinys.

      Jei ši politika nustatyta, automatinis operacinės sistemos įkėlimas iš naujo suplanuojamas, kai pritaikomas „<ph name="PRODUCT_OS_NAME" />“ naujinys ir būtina įkelti operacinę sistemą iš naujo, kad būtų užbaigtas atnaujinimas. Operacinės sistemos įkėlimas suplanuojamas nedelsiant, bet gali būti atidėtas iki 24 val., jei naudotojas šiuo metu naudoja įrenginį.

      Kai ši politika nenustatyta, pritaikius „<ph name="PRODUCT_OS_NAME" />“ naujinį, nesuplanuojamas joks automatinis atnaujinimas. Atnaujinimo procesas užbaigiamas, kai naudotojas kitą kartą įkelia operacinę sistemą iš naujo.

      Jei nustatysite šią politiką, naudotojai negalės jos pakeisti arba nepaisyti.

      Pastaba: šiuo metu automatinis operacinės sistemos įkėlimas įgalinamas, tik kai rodomas prisijungimo ekranas arba vykdomas viešojo terminalo seansas. Tai bus pakeista ateityje ir politika bus visada taikoma neatsižvelgiant į tai, ar vyksta bet kokio tipo seansas.</translation>
<translation id="7701341006446125684">Programų ir plėtinių talpyklos dydžio nustatymas (baitais)</translation>
<translation id="7709537117200051035">Žodynų susiejimo prieglobos serverių pavadinimai, skirti loginiam žymėjimui, nurodantys, ar prieiga prie prieglobos turėtų būti leidžiama (tiesa) arba blokuojama (netiesa).

          Ši politika skirta naudoti tik „<ph name="PRODUCT_NAME" />“ viduje.</translation>
<translation id="7712109699186360774">Klausti kiekvieną kartą, kai svetainė nori pasiekti kamerą ir (arba) mikrofoną</translation>
<translation id="7713608076604149344">Atsisiuntimų apribojimai</translation>
<translation id="7715711044277116530">Procentas, pagal kurį bus keičiamas ekrano užtemdymo delsos mastelis dirbant pristatymo režimu</translation>
<translation id="7717938661004793600">Konfigūruokite „<ph name="PRODUCT_OS_NAME" />“ pasiekiamumo funkcijas.</translation>
<translation id="7724994675283793633">Ši politika įgalina HTTP/0.9 protokolą ne HTTP 80 ir HTTPS 443 prievaduose.

      Politika pagal numatytuosius nustatymus neleidžiama, o ją įgalinus naudotojai gali susidurti su saugos problema, aprašyta adresu https://crbug.com/600352.

      Politikos tikslas – suteikti įmonėms galimybę perkelti esamus serverius, naudojančius HTTP/0.9 protokolą, ir ateityje ji bus pašalintą.

      Jei politika nenustatyta, nenumatytuose prievaduose HTTP/0.9 protokolas bus išjungtas.</translation>
<translation id="7749402620209366169">Įgalinamas nuotolinės prieigos prieglobų autentifikavimas dviem veiksniais vietoje naudotojo (-os) nurodyto PIN kodo naudojimo.

          Jei šis nustatymas įgalintas, naudotojai privalo pateikti galiojantį dviejų veiksnių kodą pasiekdami prieglobą.

          Jei šis nustatymas neleidžiamas arba nenustatytas, dviejų veiksnių funkcija neįgalinama ir naudojama numatytoji naudotojo (-os) nurodyto PIN kodo funkcija.</translation>
<translation id="7750991880413385988">Naujo skirtuko puslapio atidarymas</translation>
<translation id="7754704193130578113">Prieš atsiunčiant failą klausti, kur jį išsaugoti</translation>
<translation id="7761446981238915769">Įdiegtų programų sąrašo konfigūravimas prisijungimo ekrane</translation>
<translation id="7763479091692861127"> Ryšių, leidžiamų naudoti OS naujiniams, tipai. OS naujiniai potencialiai apsunkina ryšį dėl savo dydžio, todėl gali būti taikomi papildomi mokesčiai. Taigi pagal numatytuosius nustatymus jie nėra įgalinti brangiais laikomiems ryšių tipams, įskaitant šiuo metu naudojamus „WiMax“, „Bluetooth“ ir „Cellular“.

      Atpažįstami ryšio tipo identifikatoriai yra „ethernet“, „wifi“, „wimax“, „bluetooth“ ir „cellular“.</translation>
<translation id="7763614521440615342">Rodyti turinio pasiūlymus naujo skirtuko puslapyje</translation>
<translation id="7765879851993224640">Leidimas naudoti „Smart Lock“ prisijungimo funkciją.</translation>
<translation id="7774768074957326919">Naudoti sistemos tarpinio serverio nustatymus</translation>
<translation id="7775831859772431793">Čia galite nurodyti įgaliotojo serverio URL.

          Ši politika pradeda galioti, tik jei pasirinkote neautomatinius tarpinio serverio nustatymus skiltyje „Pasirinkti, kaip nurodyti tarpinio serverio nustatymus“.

          Jei pasirinkote kokį nors kitą tarpinio serverio politikos nustatymo režimą, turėtumėte nenustatyti šios politikos.

          Jei reikia daugiau parinkčių ir išsamių pavyzdžių, apsilankykite adresu
          <ph name="PROXY_HELP_URL" /></translation>
<translation id="7781069478569868053">Naujo skirtuko puslapis</translation>
<translation id="7788511847830146438">Vienam profiliui</translation>
<translation id="7788872453000173219">
      Gali būti naudinga peržiūrėti politikos nustatymą „IsolateOrigins“, kad efektyviai panaudotumėte atskyrimą darydami ribotą įtaką naudotojams, pasitelkdami „IsolateOrigins“ su svetainių, kurias norite atskirti, sąrašu. Nustatymu „SitePerProcess“ atskiriamos visos svetainės.
      Įgalinus politiką kiekviena svetainė vykdys atskirą procesą.
      Išjungus politiką nebus taikomas svetainių atskyrimas, o „IsolateOrigins“ ir „SitePerProcess“ bandomosios versijos bus išjungtos. Naudotojai vis tiek galės neautomatiškai įgalinti „SitePerProcess“.
      Nesukonfigūravus politikos naudotojas galės pakeisti šį nustatymą.
      Sistemoje „<ph name="PRODUCT_OS_NAME" />“ taip pat rekomenduojama nustatyti tą pačią įrenginio politikos „<ph name="DEVICE_LOGIN_SCREEN_SITE_PER_PROCESS_POLICY_NAME" />“ vertę. Jei abiejų tipų politikos nustatytos vertės neatitinka viena kitos, pradedant naudotojo sesiją gali būti uždelsta, kol taikoma naudotojo politikos nurodyta vertė.

      PASTABA: ši politika netaikoma sistemoje „Android“. Kad įgalintumėte „SitePerProcess“ sistemoje „Android“, naudokite politikos nustatymą „SitePerProcessAndroid“.
      </translation>
<translation id="780603170519840350">Išjungiamas sąraše nurodytų „subjectPublicKeyInfo“ maišų sertifikato skaidrumo reikalavimų įgyvendinimas.

      Naudojant šią politiką galima išjungti sertifikato skaidrumo atskleidimo reikalavimus, skirtus sertifikatų grandinėms, kuriose yra sertifikatų su viena iš nurodytų „subjectPublicKeyInfo“ maišų. Taip leidžiama naudoti sertifikatus, kurie kitaip būtų nepatikimi, nes nėra tinkamai viešai atskleisti, kad būtų galima toliau naudoti įmonės prieglobos serveriuose.

      Kad sertifikato skaidrumo įgyvendinimas būtu išjungtas, kai nustatyta ši politika, maiša turi atitikti vieną iš toliau nurodytų sąlygų.
      1. Tai yra serverio serverio sertifikato „subjectPublicKeyInfo“ maiša.
      2. Tai yra „subjectPublicKeyInfo“ vertės, kuri pateikta sertifikatų grandinės CA sertifikate, maiša, CA sertifikatas apribotas naudojant „X.509v3“ „nameConstraints“ plėtinį, kintamajame „permittedSubtrees“ yra viena ar daugiau „directoryName“ „nameConstraints“ verčių ir kintamajame „directoryName“ yra „organizationName“ atributas.
      3. Tai yra „subjectPublicKeyInfo“ vertės, kuri pateikta sertifikatų grandinės CA sertifikate, maiša, CA sertifikato temoje yra vienas ar daugiau „organizationName“ atributų ir serverio sertifikate yra toks pat skaičius „organizationName“ atributų, pateiktų tokia pačia tvarka ir su identiškomis vertėmis (atitinka kiekvienas baitas).

      „subjectPublicKeyInfo“ maiša nurodoma sujungus maišos algoritmo pavadinimą, simbolį „/“ ir to maišos algoritmo „Base64“ koduotę, pritaikytą nurodyto sertifikato DER užkoduotai „subjectPublicKeyInfo“ vertei. Ši „Base64“ koduotė nurodoma tuo pačiu formatu, kaip ir SPKI piršto antspaudas (apibrėžta RFC 7469, 2.4 skiltyje). Neatpažintų maišos algoritmų nepaisoma. Šiuo metu palaikomas tik „sha256“ maišos algoritmas.

      Jei ši politika nenustatyta, bet koks sertifikatas, kurį reikia atskleisti taikant sertifikato skaidrumą, bus laikomas nepatikimu, jei nebus atskleistas atsižvelgiant į sertifikato skaidrumo politikos nuostatas.</translation>
<translation id="7818131573217430250">Nustatyti numatytąją didelio kontrasto režimo prisijungimo ekrane būklę</translation>
<translation id="7822837118545582721">Kai ši politika nustatyta į „true“, naudotojai negali nieko įrašyti į išorinius įrenginius.

      Jei šis nustatymas nustatytas į „false“ arba nesukonfigūruotas, naudotojai gali kurti ir keisti failus išorinės saugyklos įrenginiuose, į kuriuos galima įrašyti turinio.

      Politikai „ExternalStorageDisabled“ teikiama pirmenybė šios politikos atžvilgiu. Jei „ExternalStorageDisabled“ nustatyta į „true“, visi leidimai pasiekti išorinę saugyklą panaikinami ir šios politikos nepaisoma.

      Dinaminis šios politikos atnaujinimas palaikomas naudojant M56 ir naujesnes versijas.</translation>
<translation id="7831595031698917016">Nurodoma maksimali politikos atšaukimo ir naujos politikos gavimo iš įrenginio tvarkymo paslaugos delsa milisekundėmis.

      Nustačius šią politiką perrašoma numatytoji 5 000 milisekundžių vertė. Tinkamos šios politikos vertės yra nuo 1 000 (1 sek.) iki 300 000 (5 min.). Visoms į šį diapazoną neįtrauktoms vertėms bus taikomi atitinkami apribojimai.

      Nenustačius šios politikos „<ph name="PRODUCT_NAME" />“ bus naudojama numatytoji 5 000 milisekundžių vertė.</translation>
<translation id="7841880500990419427">Minimalios versijos numatytasis TLS</translation>
<translation id="7842869978353666042">„Google“ disko parinkčių konfigūravimas</translation>
<translation id="787125417158068494">Nustačius „SyncDisabled“ arba nesukonfigūravus, <ph name="PRODUCT_OS_NAME" /> sertifikatų nebus galima naudoti ARC programose.

      Nustačius „CopyCaCerts“, visi per ONC įdiegti CA sertifikatai su „<ph name="WEB_TRUSTED_BIT" />“ bus prieinami ARC programose.</translation>
<translation id="7882585827992171421">Ši politika taikoma tik mažmeninės prekybos režimu.

      Nustatomas plėtinio, kuris turėtų būti naudojamas kaip ekrano užsklanda prisijungimo ekrane, ID. Plėtinys turi būti „AppPack“ (programų paketo), kuris sukonfigūruotas šiam domenui taikant politiką „DeviceAppPack“ (įrenginio programų paketas), dalis.</translation>
<translation id="7882857838942884046">Išjungus „Google“ sinchronizavimą „Android“ atsarginė kopija ir atkūrimas neveiks tinkamai.</translation>
<translation id="7882890448959833986">Nerodyti nepalaikomos OS įspėjimo</translation>
<translation id="7892077286206685156">
      Ši politika taikoma prisijungimo ekranui. Taip pat žr. politiką „<ph name="SITE_PER_PROCESS_POLICY_NAME" />“, kuri taikoma naudotojo sesijai. Rekomenduojama abiems politikoms nustatyti tą pačią vertę. Jei vertės neatitiks, pradedant naudotojo sesiją gali būti uždelsta, kol taikoma naudotojo politikos nurodyta vertė.
      Gali būti naudinga peržiūrėti politikos nustatymą „IsolateOrigins“, kad galėtumėte efektyviai naudoti atskyrimą darydami ribotą įtaką naudotojams, pasitelkdami „IsolateOrigins“ su svetainių, kurias norite atskirti, sąrašu. Nustatymu „SitePerProcess“ atskiriamos visos svetainės.
      Įgalinus politiką kiekviena svetainė vykdys atskirą procesą.
      Išjungus politiką nebus taikomas svetainių atskyrimas, o „IsolateOrigins“ ir „SitePerProcess“ bandomosios versijos bus išjungtos. Naudotojai vis tiek galės neautomatiškai įgalinti „SitePerProcess“.
      Nesukonfigūravus politikos naudotojas galės pakeisti šį nustatymą.
      </translation>
<translation id="7902255855035461275">Šiame sąraše pateikti šablonai bus palyginti su užklausą pateikusio
      URL saugos šaltiniu. Jei bus rasta atitiktis, galimybė pasiekti vaizdo įrašą
      fiksuojančius įrenginius bus suteikta be raginimo.

      PASTABA: iki 45 versijos programos ši politika buvo palaikoma tik įjungus viešojo terminalo režimą.</translation>
<translation id="7912255076272890813">Konfigūruoti leidžiamus programų / plėtinių tipus</translation>
<translation id="7915236031252389808">Čia galite nurodyti tarpinio serverio .pac failo URL.

          Ši politika galioja, tik jei skiltyje „Pasirinkti, kaip nurodyti tarpinio serverio nustatymus“ pasirinkote neautomatinius tarpinio serverio nustatymus.

          Jei pasirinkote kokį nors kitą tarpinio serverio politikos nustatymo režimą, neturėtumėte nustatyti šios politikos.

          Jei reikia išsamių pavyzdžių, apsilankykite adresu
          <ph name="PROXY_HELP_URL" /></translation>
<translation id="793134539373873765">Nurodoma, ar P2P bus naudojamas naudingosiose OS naujinių apkrovose. Jei ši politika galioja, įrenginiai bendrins ir bandys naudoti naujinio naudingąsias apkrovas per LAN, taip potencialiai sumažindami interneto pralaidumo naudojimą ir perpildymą. Jei naujinio naudingoji apkrova nepasiekiama naudojant LAN, įrenginys vykdys atsisiuntimą iš naujinio serverio. Jei ši politika negalioja ar yra nesukonfigūruota, P2P nebus naudojama.</translation>
<translation id="7933141401888114454">Įgalinti prižiūrimų naudotojų kūrimą</translation>
<translation id="793473937901685727">Nustatykite, ar sertifikatai bus prieinami ARC programose</translation>
<translation id="7937766917976512374">Leisti arba blokuoti vaizdo įrašo fiksavimą</translation>
<translation id="7941975817681987555">Nenumatyti tinklo veiksmų, naudojant bet kurį tinklo ryšį</translation>
<translation id="7952880400776676958">
      Įgalinus politiką kiekvienas pavadinimą turintis šaltinis, įtrauktas
      į kableliais atskirtų verčių sąrašą, vykdys atskirą procesą. Taip pat bus atskiriami
      šaltiniai, pavadinti pagal padomenius, pvz., nurodžius https://example.com/ taip pat
      bus atskiriamas ir padomenis https://foo.example.com/ kaip svetainės
      https://example.com/ dalis.
      Išjungus politiką nebus taikomas svetainių atskyrimas, o „IsolateOriginsAndroid“ ir „SitePerProcessAndroid“ bandomosios versijos bus išjungtos. Naudotojai vis tiek galės neautomatiškai įgalinti „IsolateOrigins“.
      Nesukonfigūravus politikos naudotojas galės pakeisti šį nustatymą.

      PASTABA: sistemoje „Android“ svetainių atskyrimas yra eksperimentinis. Palaikymas bus pagerintas laikui bėgant, bet šiuo metu tai gali sukelti našumo problemų.

      PASTABA: ši politika taikoma tik naršyklei „Chrome“ sistemoje „Android“, įrenginiuose, kuriuose būtinai yra daugiau nei 1 GB laisvosios prieigos atminties. Kad politiką pritaikytumėte ne „Android“ platformose, naudokite „IsolateOrigins“.
      </translation>
<translation id="7953256619080733119">Tvarkomos naudotojo neautomatinių išimčių prieglobos</translation>
<translation id="7961779417826583251">Išjungti sąraše nurodytų pasenusių sertifikavimo institucijų sertifikato skaidrumo reikalavimų įgyvendinimą</translation>
<translation id="7974114691960514888">Ši politika nebepalaikoma.
          Įgalinamas STUN ir perdavimo serverių naudojimas, kai prisijungiama prie nuotolinių programų.

          Jei šis nustatymas įgalintas, šis įrenginys gali rasti nuotolinės prieglobos įrenginius ir prie jų prisijungti, net jei jos atskirtos taikant užkardą.

           Jei šis nustatymas neleidžiamas ir išeinantys UDP ryšiai filtruojami taikant užkardą, šis įrenginys gali prisijungti tik prie prieglobos įrenginių vietiniame tinkle.</translation>
<translation id="7976157349247117979">„<ph name="PRODUCT_NAME" />“ paskirties vietos pavadinimas</translation>
<translation id="7980227303582973781">Nėra specialių apribojimų</translation>
<translation id="7985242821674907985">„<ph name="PRODUCT_NAME" />“</translation>
<translation id="7992136759457836904">Galima valdyti, ar virtualiesiems įrenginiams leidžiama veikti „Chrome“ OS.

      Jei politika nustatyta kaip „Tiesa“, įrenginiui leidžiama paleisti virtualiuosius įrenginius.
      Jei politika nustatyta kaip „Netiesa“, įrenginiui neleidžiama paleisti virtualiųjų įrenginių.
      Visų trijų tipų politika („VirtualMachinesAllowed“, „CrostiniAllowed“ ir „DeviceUnaffiliatedCrostiniAllowed“) turi būti nustatyta kaip „Tiesa“, kai taikoma „Crostini“, kad būtų leidžiama vykdyti.
      Kai ši politika pakeičiama į „Netiesa“, ji taikoma paleidžiant naujus virtualiuosius įrenginius, bet nesustabdo jau vykdomų virtualiųjų įrenginių.
      Jei ši politika nenustatyta valdomame įrenginyje, įrenginiui neleidžiama paleisti virtualiųjų įrenginių.
      Nevaldomiems įrenginiams leidžiama paleisti virtualiuosius įrenginius.</translation>
<translation id="8001701200415781021">„Google“ paskyrų, kurias leidžiama nustatyti kaip naršyklės pagrindines paskyras sistemoje „<ph name="PRODUCT_NAME" />“, ribojimas</translation>
<translation id="802147957407376460">Pasukti ekraną 0 laipsnių kampu</translation>
<translation id="8033913082323846868">Ši politika nebenaudojama naudojant M70. Naudokite „AutofillAddressEnabled“ ir „AutofillCreditCardEnabled“.

      Įgalinama „<ph name="PRODUCT_NAME" />“ automatinio pildymo funkcija ir naudotojams leidžiama automatiškai pildyti žiniatinklio formas naudojant anksčiau išsaugotą informaciją, pvz., adresą arba kredito kortelės informaciją.

      Jei šio nustatymo neleisite, naudotojai negalės naudoti automatinio pildymo funkcijos.

      Jei šį nustatymą įgalinsite arba vertės nenustatysite, naudotojai ir toliau galės valdyti Automatinį pildymą. Taip jie galės konfigūruoti automatinio pildymo profilius ir savo nuožiūra įjungti arba išjungti Automatinio pildymo funkciją.</translation>
<translation id="8044493735196713914">Pranešti įrenginio operacinės sistemos paleidimo būseną</translation>
<translation id="8050080920415773384">Vietinis spausdinimas</translation>
<translation id="8053580360728293758">Nepaisoma numatytojo spausdinimo spalvotu režimu. Jei režimas nepasiekiamas, šios politikos nepaisoma.</translation>
<translation id="8059164285174960932">URL, kur nuotolinės prieigos klientai turėtų gauti autentifikavimo prieigos raktą</translation>
<translation id="8078366200175825572">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose neleidžiama nustatyti slapukų, sąrašą.

          Nenustačius šios politikos, visose svetainėse naudojama visuotinė numatytoji vertė iš politikos „DefaultCookiesSetting“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.

          Taip pat žiūrėkite politikas „CookiesAllowedForUrls“ ir „CookiesSessionOnlyForUrls“. Atminkite, kad negali būti nesuderinamų šių trijų politikų URL šablonų, nes nenurodyta, kuriai politikai teikiama pirmenybė.</translation>
<translation id="8099880303030573137">Neveikos delsa, kai naudojama akumuliatoriaus energija</translation>
<translation id="8102913158860568230">Numatytasis medijos srautinio perdavimo nustatymas</translation>
<translation id="8104186956182795918">Leidžiama nustatyti, ar svetainėse galima pateikti vaizdų. Vaizdus pateikti gali būti leidžiama arba neleidžiama visose svetainėse.

          Nenustačius šios politikos, bus naudojama „AllowImages“ ir naudotojas galės tai pakeisti.

          Atkreipkite dėmesį, kad anksčiau ši politika per klaidą buvo įgalinta „Android“, bet ši funkcija šioje platformoje niekada nebuvo visiškai palaikoma.</translation>
<translation id="8104962233214241919">Automatiškai pasirinkti šių svetainių kliento sertifikatus</translation>
<translation id="8112122435099806139">Nurodomas laikrodžio formatas, kuris bus naudojamas įrenginyje.

      Pagal šią politiką konfigūruojamas laikrodžio formatas, kuris bus naudojamas prisijungimo ekrane ir bus numatytasis nustatymas naudotojų sesijose. Naudotojai vis tiek galės savo paskyroje nepaisyti laikrodžio formato.

      Jei politika galioja, įrenginys naudos 24 val. laikrodžio formatą. Jei politika negalioja, įrenginyje bus naudojamas 12 val. laikrodžio formatas.

      Jei ši politika nenustatyta, įrenginyje automatiškai bus nustatytas numatytasis 24 val. laikrodžio formatas.</translation>
<translation id="8114382167597081590">Nevykdyti riboto režimo sistemoje „YouTube“</translation>
<translation id="8118665053362250806">Nustatyti medijos disko talpyklos dydį</translation>
<translation id="8124468781472887384">Įrenginių spausdintuvų konfigūracijos pasiekiamumo politika.</translation>
<translation id="8135937294926049787">Nurodoma laiko trukmė be naudotojo įvesties, po kurios ekranas išjungiamas, kai naudojama kintamosios srovės energija.

          Kai šios politikos vertė yra didesnė už nulį, ji nurodo laiko trukmę, kurią naudotojas turi neatlikti jokių veiksmų, kol „<ph name="PRODUCT_OS_NAME" />“ išjungs ekraną.

          Kai ši politika nustatyta į nulį, „<ph name="PRODUCT_OS_NAME" />“ neišjungia ekrano, kai naudotojas neatlieka jokių veiksmų.

          Kai ši politika nenustatyta, naudojama numatytoji laiko trukmė.

          Politikos vertė turėtų būti nurodoma milisekundėmis. Vertės sumažinamos, kad neviršytų neveikos delsos laiko.</translation>
<translation id="8138009212169037227">Ši politika valdo, ar pranešti politikos duomenis ir politikos gavimo laiką.

      Kai ši politika nenustatyta arba nustatyta kaip „Tiesa“, politikos duomenys ir politikos gavimo laikas renkami.
      Kai ši politika nustatyta kaip „Netiesa“, politikos duomenys ir politikos gavimo laikas nerenkami.

      Ši politika galioja, tik kai įgalintas „<ph name="CHROME_REPORTING_EXTENSION_NAME" />“ ir įrenginyje užregistruota „<ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />“.</translation>
<translation id="8140204717286305802">Serveryje pateikti tinklo sąsajų sąrašą su jų tipais ir aparatinės įrangos adresais.

      Jei politika nustatyta kaip „False“, sąsajų sąrašas nebus pateiktas.</translation>
<translation id="8141795997560411818">Ši politika nedraudžia naudotojui naudoti „Android“ skirtos „Google“ disko programos. Jei norite neleisti pasiekti „Google“ disko, taip pat turėtumėte neleisti diegti „Android“ skirtos „Google“ disko programos.</translation>
<translation id="8142894094385450823">Rekomenduojamų valdomos sesijos lokalių nustatymas</translation>
<translation id="8146727383888924340">Leisti naudotojams pasinaudoti pasiūlymais atliekant „Chrome“ OS registraciją</translation>
<translation id="8148785525797916822">Nerodomas įspėjimas, kuris rodomas, kai „<ph name="PRODUCT_NAME" />“ veikia kompiuteryje ar operacinėje sistemoje, kuri nebepalaikoma.</translation>
<translation id="8148901634826284024">Įgalinti didelio kontrasto režimo pasiekiamumo funkciją.

          Jei ši politika galioja, didelio kontrasto režimas bus visada įgalintas.

          Jei ši politika negalioja, didelio kontrasto režimas bus visada išjungtas.

          Jei nustatysite šią politiką, naudotojai negalės jos keisti ar nepaisyti.

          Jei ši politika nebus nustatyta, didelio kontrasto režimas bus išjungtas, bet naudotojas jį gali bet kada įgalinti.</translation>
<translation id="815061180603915310">Jei ši politika įgalinama, priverstinai įjungiamas profilio trumpalaikis režimas. Jei ši politika nurodyta kaip OS politika (pvz., „Windows“ sistemoje taikomas GPO), ji bus taikoma kiekvienam sistemos profiliui; jei politika nustatyta kaip debesies politika, ji bus taikoma tik tam profiliui, prie kurio prisijungta naudojant valdomą paskyrą.

      Jei įjungtas šis režimas, profilio duomenys diske išlieka tik naudotojo seanso laiką. Uždarius naršyklę, funkcijos, pvz., naršyklės istorija, plėtiniai ir jų duomenys, bei žiniatinklio duomenys, pvz., slapukai ir žiniatinklio duomenų bazės, neišsaugomi. Tačiau naudotojas vis tiek gali neautomatiškai į diską atsisiųsti bet kokius failus, išsaugoti puslapius ar juos atsispausdinti.

      Jei naudotojas įgalina sinchronizavimo funkciją, visi šie duomenys išsaugomi sinchronizavimo profilyje taip, kaip jie būtų išsaugomi įprastuose profiliuose. Be to, galima naudoti inkognito režimą, jei politikos nuostatose aiškiai nenurodyta, jog jis neleidžiamas.

      Jei politika neįgalinta arba nenustatyta, prisijungiant jungiamasi prie įprastų profilių.</translation>
<translation id="8158758865057576716">Įgalinti „<ph name="PRODUCT_NAME" />“ profilio duomenų tarptinklinio ryšio kopijų kūrimą.</translation>
<translation id="817455428376641507">Leidžiama prieiga prie pateiktų URL kaip prie juodojo URL sąrašo išimčių.

      Žr. juodojo URL sąrašo politiką, joje rasite šio sąrašo įrašų formatus.

      Šią politiką galima naudoti norint atidaryti apribotų juodųjų sąrašų išimtis. Pavyzdžiui, „*“ gali būti įtrauktas į juodąjį sąrašą, kad blokuotų visas užklausas, o ši politika gali būti naudojama siekiant leisti prieigą ribotam URL skaičiui. Ji gali būti naudojama tam tikrų schemų, kitų domenų padomenių, prievadų ar konkrečių kelių išimtims atidaryti.

      Konkrečiausias filtras nustatys, ar URL blokuojamas, ar leidžiamas. Baltasis sąrašas turi pirmenybę prieš juodąjį sąrašą.

      Į politiką galima įtraukti iki 1 000 įrašų – į kitus nebus atsižvelgiama.

      Jei ši politika nenustatoma, nebus jokių politikos „URLBlacklist“ juodojo sąrašo išimčių.</translation>
<translation id="8176035528522326671">Leisti įmonei būti tik pirminiu kelių profilių naudotoju (numatytoji elgsena įmonių valdomiems naudotojams)</translation>
<translation id="8214600119442850823">Konfigūruoja slaptažodžių tvarkytuvę.</translation>
<translation id="8244525275280476362">Maksimali gavimo delsa atšaukus politiką</translation>
<translation id="8256688113167012935">Valdomas paskyros pavadinimas, kurį „<ph name="PRODUCT_OS_NAME" />“ rodo atitinkamo įrenginio vietinės paskyros prisijungimo ekrane.

      Jei ši politika nustatyta, prisijungimo ekrano prisijungimo vardo parinkiklyje prie atitinkamos vietinės paskyros bus naudojama nurodyta eilutė.

      Jei ši politika nenustatyta, „<ph name="PRODUCT_OS_NAME" />“ kaip prisijungimo ekrane pateikiamas pavadinimas bus naudojamas įrenginio vietinės paskyros el. pašto paskyros ID.

      Ši politika netaikoma įprastose naudotojų paskyrose.</translation>
<translation id="8259375588339409826">Tiek „Chromium“, tiek „Google Chrome“ palaiko tas pačias politikos nuostatas. Atminkite, kad šiame dokumente gali būti neišleistų politikos nuostatų (pvz., įrašu „Palaikoma naudojant“ nurodomas neišleistos versijos „<ph name="PRODUCT_NAME" />“), kurios gali būti pakeistos arba pašalintos be įspėjimo ir dėl kurių neteikiamos jokios garantijos, įskaitant garantijas dėl jų saugos ir privatumo nuostatų.

Šios politikos nuostatos griežtai skirtos tik „<ph name="PRODUCT_NAME" />“ objektams konfigūruoti organizacijos viduje. Šių politikos nuostatų naudojimas už organizacijos ribų (pvz., viešai platinamoje programoje) laikomas kenkėjišku ir „Google“ bei antivirusinės programinės įrangos teikėjai tai tikriausiai laikys kenkėjiška programa.

Šių nustatymų nereikia konfigūruoti neautomatiškai! Lengvai naudojamų šablonų, skirtų „Windows“, „Mac“ ir „Linux“, galite atsisiųsti adresu <ph name="POLICY_TEMPLATE_DOWNLOAD_URL" />.

Rekomenduojame politiką sistemoje „Windows“ nustatyti naudojant GPO, tačiau aprūpinimo politika naudojant registrą vis tiek palaikoma „Windows“ objektuose, kurie susieti su „<ph name="MS_AD_NAME" />“ domenu.</translation>
<translation id="8264653492961233132">Nurodomas programų ir plėtinių, kurie įdiegiami automatiškai,
          naudotojui neatliekant jokių veiksmų, ir kurių naudotojas negali pašalinti ar
          išjungti, sąrašas. Visi programų / plėtinių prašomi
          leidimai suteikiami netiesiogiai, naudotojui neatliekant jokių veiksmų,
          įskaitant visus papildomus leidimus, kurių bus prašoma naudojant būsimos versijos
          programą / plėtinį. Be to, leidimai suteikiami plėtinių API
          „enterprise.deviceAttributes“ ir „enterprise.platformKeys“.
          (Abu šie API nepasiekiami programoms / plėtiniams, kurie
          nėra priverstinai įdiegiami.)

          Šiai politikai teikiama pirmenybė prieš potencialiai nesuderinamą politiką „<ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" />“. Jei programa ar plėtinys, kuris anksčiau buvo priverstinai įdiegtas, pašalinamas iš šio sąrašo, „<ph name="PRODUCT_NAME" />“ jį automatiškai pašalina.

          „Windows“ objektų, kurie neprijungti prie „<ph name="MS_AD_NAME" />“ domeno, priverstinis diegimas ribojamas naudojant programas ir plėtinius, nurodytus „Chrome“ internetinėje parduotuvėje.

          Atminkite, kad naudotojai gali keisti bet kurio plėtinio šaltinio kodą, naudodami kūrėjo įrankius (tai gali sutrikdyti plėtinio pateikimą). Jei tai kelia rūpesčių, reikia nustatyti politiką „<ph name="DEVELOPER_TOOLS_POLICY_NAME" />“.

          Kiekvienas politikos sąrašo elementas yra eilutė, kurioje yra plėtinio ID ir „naujinio“ URL, atskirti kabliataškiu (<ph name="SEMICOLON" />). Plėtinio ID yra 32 raidžių eilutė, aptinkama, pvz. <ph name="CHROME_EXTENSIONS_LINK" />, dirbant kūrėjo režimu. „Naujinio“ URL (jei nurodytas) turėtų nurodyti naujinio aprašo XML dokumentą, kaip aprašyta <ph name="LINK_TO_EXTENSION_DOC1" />. Pagal numatytuosius nustatymus naudojamas „Chrome“ internetinės parduotuvės naujinio URL (kuris šiuo metu yra „https://clients2.google.com/service/update2/crx“). Atminkite, kad šioje politikoje nustatytas „naujinio“ URL naudojamas tik atliekant pirminį diegimą. Tolesni plėtinio naujiniai naudos naujinio URL, nurodytą plėtinio apraše. Be to, atminkite, kad buvo būtina aiškiai nurodyti „naujinio“ URL 67 ir ankstesnių versijų „<ph name="PRODUCT_NAME" />“.

          Pavyzdžiui, <ph name="EXTENSION_POLICY_EXAMPLE" /> įdiegia „<ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME" />“ programą iš standartinio „Chrome“ internetinės parduotuvės „naujinio“ URL. Jei reikia daugiau informacijos apie plėtinių priglobimą, žr. <ph name="LINK_TO_EXTENSION_DOC2" />.

          Nenustačius šios politikos, jokios programos ar plėtiniai neįdiegiami automatiškai, o naudotojas gali pašalinti bet kurią programą ar plėtinį naudodamas „<ph name="PRODUCT_NAME" />“.

          Atminkite, kad ši politika netaikoma inkognito režimu.</translation>
<translation id="8274603902181597201">Panaikinamas naudotojo „eCryptfs“ pagrindinis katalogas ir pradedama naudoti naują „ext4“ šifruotą pagrindinį katalogą.</translation>
<translation id="8285435910062771358">Viso ekrano didinimas įgalintas</translation>
<translation id="8288199156259560552">„Android“ skirtos „Google“ vietovių paslaugos įgalinimas</translation>
<translation id="8294750666104911727">Paprastai puslapiai, kuriuose „X-UA-Compatible“ nustatyta į „chrome=1“ bus pateikti „<ph name="PRODUCT_FRAME_NAME" />“, neatsižvelgiant į politiką „ChromeFrameRendererSettings“.

          Jei įgalinsite šį nustatymą, puslapiai nebus nuskaitomi ieškant metažymų.

          Jei išjungsite šį nustatymą, puslapiai bus nuskaitomi ieškant metažymų.

          Jei ši politika nenustatyta, puslapiai bus nuskaitomi ieškant metažymų.</translation>
<translation id="8300455783946254851">Jei reikšmė nustatyta kaip „true“, naudojant korinio tinklo ryšį išjungiamas „Google“ disko sinchronizavimas „<ph name="PRODUCT_OS_NAME" />“ programoje „Failai“. Tokiu atveju duomenys sinchronizuojami su „Google“ disku, kai prisijungiama prie „Wi-Fi“ ar eterneto.

          Jei politika nenustatyta arba reikšmė yra „false“, naudotojai galės perkelti failus į „Google“ diską korinio tinklo ryšiu.</translation>
<translation id="8300992833374611099">Kūrėjo įrankių naudojimo valdymas</translation>
<translation id="8312129124898414409">Leidžiama nustatyti, ar svetainėse leidžiama naudoti rakto generavimą. Naudoti rakto generavimą gali būti leidžiama arba draudžiama visose svetainėse.

          Nenustačius šios politikos, bus naudojama „BlockKeygen“ ir naudotojas galės tai pakeisti.</translation>
<translation id="8329984337216493753">Ši politika aktyvi tik mažmeninės prekybos režimu.

      Kai nurodyta „Įrenginio neveikos būsenos atjungimo skirtasis laikas“, pagal šią politiką apibrėžiama įspėjimo laukelio su laiko skaičiavimo atgal laikmačiu, kuris rodomas naudotojui prieš atjungiant, trukmė.

      Politikos vertė turėtų būti nurodyta milisekundėmis.</translation>
<translation id="8339420913453596618">Antras veiksnys išjungtas</translation>
<translation id="8344454543174932833">Importuoti žymes iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="8359734107661430198">Įgalinkite „ExampleDeprecatedFeature“ API iki 2008-09-02</translation>
<translation id="8367209241899435947">„Chrome“ valymo įrankio įgalinimas sistemoje „Windows“</translation>
<translation id="8369602308428138533">Ekrano išjungimo delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="8371178326720637170">Tvarkomi plėtiniai įgalinami naudoti įmonės aparatinės įrangos platformos API</translation>
<translation id="8382184662529825177">Įgalinti nuotolinio patvirtinimo naudojimą siekiant apsaugoti įrenginio turinį</translation>
<translation id="838870586332499308">Įgalinti duomenų tarptinklinį ryšį</translation>
<translation id="8390049129576938611">Išjungiama vidinė PDF peržiūros priemonė „<ph name="PRODUCT_NAME" />“. Failai laikomi atsisiuntimu ir naudotojui leidžiama atidaryti PDF failus naudojant numatytąją programą.

      Jei ši politika nenustatyta ar išjungta, PDF failams atidaryti bus naudojamas PDF papildinys (jei naudotojas jo neišjungė).</translation>
<translation id="8402079500086185021">Visada atidaryti PDF failus už programos ribų</translation>
<translation id="8412312801707973447">Ar atliekami OCSP / CRL patikrinimai prisijungus</translation>
<translation id="8417305981081876834">Nustatyti maksimalų užrakinimo ekrano PIN kodo ilgį</translation>
<translation id="841977920223099909">Įspėjimo dėl slaptažodžio apsaugos aktyviklis</translation>
<translation id="8424255554404582727">Nustatyti numatytąjį ekrano sukimo nustatymą, kuris bus iš naujo pritaikomas kiekvieną kartą paleidus iš naujo</translation>
<translation id="8426231401662877819">Sukti ekraną pagal laikrodžio rodyklę 90 laipsnių kampu</translation>
<translation id="8433423491036718210">Įmonių prisijungimo URL, kuriais slaptažodžio apsaugos paslauga turėtų užfiksuoti slaptažodžio piršto antspaudą, sąrašo konfigūravimas.</translation>
<translation id="8451988835943702790">Naudoti naujo skirtuko puslapį kaip pagrindinį puslapį</translation>
<translation id="8459216513698220096">Nurodoma, ar apdorojama naudotojo politika iš kompiuterio GPO ir kaip apdorojama.

      Jei politika nustatyta kaip „Numatytoji“ arba nenustatyta, naudotojo politika skaitoma tik iš naudotojo GPO (kompiuterio GPO nepaisoma).

      Jei politika nustatyta kaip „Sujungti“, naudotojo politika naudotojo GPO sujungiama su naudotojo politika kompiuterio GPO (pirmenybė teikiama kompiuterio GPO).

      Jei politika nustatyta kaip „Pakeisti“, naudotojo politika naudotojo GPO pakeičiama naudotojo politika kompiuterio GPO (naudotojo GPO nepaisoma).</translation>
<translation id="8465065632133292531">Intuityviosios paieškos URL parametrai, kuriuose naudojama POST</translation>
<translation id="847472800012384958">Neleisti jokioje svetainėje rodyti iššokančiųjų langų</translation>
<translation id="8477885780684655676">1.0 versijos TLS</translation>
<translation id="8483004350080020634">Perduodamos neskelbtinos https:// URL privatumo ir saugos dalys prieš pateikiant jas PAC (automatinės tarpinio serverio konfigūracijos) scenarijams, kuriuos „<ph name="PRODUCT_NAME" />“ naudoja per tarpinio serverio nustatymo procesą.

      Kai politika nustatyta į „True“, saugos funkcija yra įgalinta, o https:// URL
      perduodami prieš pateikiant juos į PAC scenarijų. Taip PAC scenarijus negali
      peržiūrėti duomenų, kurie paprastai apsaugomi naudojant šifruotą kanalą
      (pvz., URL kelią ir užklausą).

      Kai politika nustatyta į „False“, saugos funkcija yra išjungta, o PAC
      scenarijams suteikiama galimybė peržiūrėti visus https:// URL komponentus.
      Tai taikoma visiems PAC scenarijams, neatsižvelgiant į kilmę (įskaitant
      perduotus naudojant nesaugų perdavimo protokolą ar nesaugiai aptiktus
      naudojant WPAD).

      Pagal numatytuosius nustatymus ši politika nustatyta į „True“ (saugos funkcija
      įgalinta).

      Rekomenduojama šią politiką nustatyti į „True“. Į „False“ nustatytina tik
      kilus suderinamumo su esamais PAC scenarijais problemų.

      M75 ši politika bus pašalinta.</translation>
<translation id="8484458986062090479">Tinkinkite URL šablonų, kuriuos prieglobos naršyklė visada turėtų pateikti, sąrašą.

          Jei ši politika nenustatyta, numatytasis pateikėjas naudojamas visose svetainėse, kaip nurodyta politikoje „ChromeFrameRendererSettings“.

          Šablonų pavyzdžių galite rasti apsilankę adresu https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8493645415242333585">Neleisti išsaugoti naršyklės istorijos</translation>
<translation id="8498293625012059298">Konfigūruojamas slaptažodžio keitimo URL (tik HTTP ir HTTPS schemos). Naudojant slaptažodžio apsaugos paslaugą naudotojai bus nukreipiami šiuo URL, kad pakeistų slaptažodžius, jei buvo rodomas įspėjimas naršyklėje.
      Kad „<ph name="PRODUCT_NAME" />“ tinkamai užfiksuotų naujo slaptažodžio piršto antspaudą šiame slaptažodžio keitimo puslapyje, įsitikinkite, kad slaptažodžio keitimo puslapyje laikomasi gairių, pasiekiamų adresu https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Jei šis nustatymas įgalintas, naudojant slaptažodžio apsaugos paslaugą naudotojai bus siunčiami šiuo URL, kad pakeistų slaptažodžius, jei buvo rodomas įspėjimas naršyklėje.
      Jei šis nustatymas išjungtas arba nenustatytas, naudojant slaptažodžio apsaugos paslaugą naudotojai bus siunčiami adresu https://myaccounts.google.com, kad pakeistų slaptažodį.
      Ši politika nepasiekiama „Windows“ objektuose, kurie nesusieti su „<ph name="MS_AD_NAME" />“ domenu.</translation>
<translation id="8499172469244085141">Numatytieji nustatymai (naudotojai gali nepaisyti)</translation>
<translation id="8507835864888987300">Nustatoma tikslinė automatinių naujinių versija.

      Nurodomas tikslinės versijos, į kurią turėtų būti atnaujinta „<ph name="PRODUCT_OS_NAME" />“, priešdėlis. Jei įrenginyje vykdoma ankstesnė nei nurodyto priešdėlio versija, naudojant nurodytą priešdėlį atnaujinama į naujausią versiją. Jei įrenginyje jau veikia naujesnė versija, poveikis priklauso nuo „<ph name="DEVICE_ROLLBACK_TO_TARGET_VERSION_POLICY_NAME" />“ vertės. Priešdėlio formatas veikia pagal komponentus, kaip nurodyta šiame pavyzdyje:

      "" (arba nesukonfigūruota): atnaujinti į naujausią pasiekiamą versiją
      "1412.": atnaujinti į šalutinę 1412 versiją (pvz., 1412.24.34 arba 1412.60.2)
      "1412.2.": atnaujinti į šalutinę 1412.2 versiją (pvz., 1412.2.34 arba 1412.2.2)
      "1412.24.34": atnaujinti tik į šią konkrečią versiją

      Įspėjimas: nerekomenduojama konfigūruoti versijos apribojimų, nes dėl jų naudotojai gali negauti programinės įrangos naujinių ir svarbių saugos pataisų. Apribojus, kad būtų įdiegti tik konkrečios versijos priešdėlio naujiniai, gali kilti grėsmė naudotojų saugai.</translation>
<translation id="8519264904050090490">Tvarkomi naudotojo neautomatinių išimčių URL</translation>
<translation id="8538235451413605457">Konfigūruoja seniausios leistinos „<ph name="PRODUCT_NAME" />“ versijos reikalavimą. Senesnės nei nurodyta versijos laikomos pasenusiomis ir įrenginys neleistų naudotojui prisijungti neatnaujinus OS.
      Jei dabartinė versija tampa pasenusi per naudotojo sesiją, naudotas priverstinai atjungiamas.

      Jei ši politika nenustatyta, netaikomi jokie apribojimai ir naudotojas gali prisijungti neatsižvelgiant į „<ph name="PRODUCT_NAME" />“ versiją.

      Čia „Versija“ gali būti tiksli versija, pvz., „61.0.3163.120“ arba versijos priešdėlis, pvz., „61.0“  </translation>
<translation id="8544375438507658205">Numatytasis „<ph name="PRODUCT_FRAME_NAME" />“ HTML teikėjas</translation>
<translation id="8544465954173828789">Leisti SMS pranešimus sinchronizuoti iš telefono į „Chromebook“.</translation>
<translation id="8548832052135586762">Nustatomas tik spalvoto, tik vienspalvio arba nespalvoto režimo apribojimas. Jei politika nenustatyta, netaikomi jokie apribojimai.</translation>
<translation id="8549772397068118889">Įspėti, kai apsilankoma svetainėse, nesančiose turinio paketuose</translation>
<translation id="8566842294717252664">Internetinės parduotuvės slėpimas Naujo skirtuko puslapyje ir programų paleidimo priemonėje</translation>
<translation id="857369585509260201">Ši politika nebenaudojama. Vietoje jos turėtumėte naudoti „BrowserSignin“.

      Jei ši politika nustatyta kaip „tiesa“, naudotojas naršyklėje turi prisijungti prie „<ph name="PRODUCT_NAME" />“ naudodamas savo profilį. O numatytoji „BrowserGuestModeEnabled“ vertė bus nustatyta kaip „netiesa“. Atminkite, kad įgalinus šią politiką esami profiliai, prie kurių neprisijungta, bus užrakinti ir nepasiekiami. Jei reikia daugiau informacijos, žr. pagalbos centro straipsnį.

      Jei ši politika nustatyta kaip „netiesa“ arba nesukonfigūruota, naudotojas galės naudoti naršyklę neprisijungęs prie „<ph name="PRODUCT_NAME" />“.</translation>
<translation id="8586528890725660268">Nurodomi spausdintuvai, kurių naudotojas negali naudoti.

      Ši politika naudojama, tik jei pasirinktas politikos „<ph name="BULK_PRINTERS_ACCESS_MODE" />“ nustatymas „<ph name="PRINTERS_BLACKLIST" />“.

      Jei ši politika naudojama, naudotojui teikiami visi spausdintuvai, išskyrus šioje politikoje nurodytus ID. ID turi atitikti laukus „id“ arba „guid“ faile, kuris nurodytas „<ph name="BULK_PRINTERS_POLICY" />“.
      </translation>
<translation id="8587229956764455752">Leisti kurti naujų naudotojų paskyras</translation>
<translation id="8598350264853261122">Jei politika nustatyta į „false“, nesusietiems naudotojams nebus leidžiama naudoti ARC.

      Jei politika nenustatyta arba nustatyta į „true“, ARC leidžiama naudoti visiems naudotojams (jei ARC neišjungta kitomis priemonėmis).

      Politikos pakeitimai bus taikomi tik neveikiant ARC, pvz., kol paleidžiama „Chrome“ OS.</translation>
<translation id="8615400197788843468">Įgalinama „<ph name="PRODUCT_NAME" />“ riboto prisijungimo funkcija sistemoje „G Suite“ ir naudotojams neleidžiama keisti šio nustatymo.

      Įjungus šį nustatymą naudotojas galės pasiekti „Google“
      programas tik naudodamas paskyras iš nurodytų domenų (atminkite, kad norint leisti
      gmail.com/googlemail.com paskyras reikia pridėti „consumer_accounts“
      (be kabučių) prie domenų sąrašo).

      Šis nustatymas neleis naudotojui prisijungti ir pridėti antrinės
      paskyros tvarkomame įrenginyje, kuriame reikia atlikti „Google“ autentifikavimo procesą, jei ši
      paskyra neįtraukta į anksčiau nurodytą leidžiamų domenų sąrašą.

      Jei paliksite šį nustatymą tuščią ar nesukonfigūruotą, naudotojas galės
      pasiekti „G Suite“ naudodamas bet kurią paskyrą.

      Pagal šią politiką antraštė „X-GoogApps-Allowed-Domains“ pridedama prie
      visų HTTP ir HTTPS užklausų visuose google.com domenuose, kaip aprašyta adresu
      https://support.google.com/a/answer/1668854.

      Naudotojai negali pakeisti ar nepaisyti šio nustatymo.</translation>
<translation id="8631434304112909927">iki <ph name="UNTIL_VERSION" /> versijos</translation>
<translation id="863319402127182273">„Android“ programose ši politika turi įtakos tik integruotam fotoaparatui. Kai ši politika nustatyta į „Tiesa“, fotoaparatas išjungiamas visose „Android“ programose be išimčių.</translation>
<translation id="8649763579836720255">„Chrome“ OS įrenginiai gali naudoti nuotolinį patvirtinimą (patvirtinta prieiga), kad gautų „Chrome“ OS CA išduotą sertifikatą, pagal kurį nurodoma, kad įrenginys yra tinkamas paleisti apsaugotą turinį. Šis procesas apima aparatinės įrangos patvirtinimo informacijos siuntimą „Chrome“ OS CA, kuri unikaliai identifikuoja įrenginį.

          Jei šis nustatymas negalioja, įrenginys nenaudos nuotolinio turinio apsaugos patvirtinimo ir galbūt įrenginys negalės paleisti apsaugoto turinio.

          Jei šis nustatymas galioja ar yra nenustatytas, nuotolinis patvirtinimas gali būti naudojamas turiniui apsaugoti.</translation>
<translation id="8650974590712548439">„Windows“ klientų vieta „Windows“ registre:</translation>
<translation id="8654286232573430130">Nurodoma, kurie serveriai turėtų būti įtraukti į baltąjį integruoto autentifikavimo sąrašą. Integruotas autentifikavimas įgalinamas, tik kai „<ph name="PRODUCT_NAME" />“ gauna autentifikavimo užklausą iš įgaliotojo serverio ar serverio, esančio leidžiamųjų sąraše.

          Kelis serverių pavadinimus atskirkite kableliais. Leidžiama naudoti pakaitos simbolius (*).

          Jei nenustatysite šios politikos, „<ph name="PRODUCT_NAME" />“ bandys nustatyti, ar serveris yra intranete ir tik tada atsakys į IWA užklausas. Jei serveris aptinkamas internete, „<ph name="PRODUCT_NAME" />“ nepaisys jo siunčiamų IWA užklausų.</translation>
<translation id="8669669491594628013">Galite valdyti įspėjimo dėl slaptažodžio apsaugos suaktyvinimą. Slaptažodžio apsauga įspėja naudotojus, kai jie pakartotinai naudoja apsaugotus slaptažodžius potencialiai įtartinose svetainėse.

      Politiką „PasswordProtectionLoginURLs“ ir „PasswordProtectionChangePasswordURL“ galite naudoti konfigūruodami, kuriuos slaptažodžius apsaugoti.

      Jei ši politika nustatyta kaip „PasswordProtectionWarningOff“, nebus rodomas įspėjimas dėl slaptažodžio apsaugos.
      Jei ši politika nustatyta kaip „PasswordProtectionWarningOnPasswordReuse“, įspėjimas dėl slaptažodžio apsaugos bus rodomas, kai naudotojas pakartotinai naudos apsaugotą slaptažodį svetainėje, kuri neįtraukta į baltąjį sąrašą.
      Jei ši politika nustatyta kaip „PasswordProtectionWarningOnPhishingReuse“, įspėjimas dėl slaptažodžio apsaugos bus rodomas, kai naudotojas pakartotinai naudos apsaugotą slaptažodį svetainėje, kurioje sukčiaujama.
      Jei ši politika nenustatyta, slaptažodžio apsaugos paslauga apsaugos tik „Google“ slaptažodžius, bet naudotojas galės pakeisti šį nustatymą.</translation>
<translation id="8672321184841719703">Taikomo automatinio naujinio versija</translation>
<translation id="867410340948518937">U2F (universalusis antras veiksnys, angl. „Universal Second Factor“)</translation>
<translation id="8682611302223077049">Leidžiama nustatyti laikotarpį (milisekundėmis), per kurį naudotojams pranešama, kad „<ph name="PRODUCT_NAME" />“ arba „<ph name="PRODUCT_OS_NAME" />“ įrenginį reikia paleisti iš naujo, norint pritaikyti laukiantį naujinį.

      Per šį laikotarpį naudotojui bus pakartotinai pranešama apie reikalingą atnaujinimą. „<ph name="PRODUCT_OS_NAME" />“ įrenginiuose paleidimo iš naujo pranešimas rodomas sistemos juostelėje, kai aptinkamas naujovinimas. Praėjus trečdaliui pranešimo laikotarpio „<ph name="PRODUCT_NAME" />“ naršyklėse pakeičiamas programų meniu nurodant, kad reikia paleisti iš naujo. Šio pranešimo spalva pakeičiama praėjus dviem trečdaliams pranešimo laikotarpiui ir dar kartą praėjus visam pranešimo laikotarpiui. Tas pats tvarkaraštis taikomas papildomiems pranešimams naršyklėse, įgalintiems taikant „<ph name="RELAUNCH_NOTIFICATION_POLICY_NAME" />“ politiką.

      Jei nenustatyta, „<ph name="PRODUCT_OS_NAME" />“ įrenginiams naudojamas numatytasis 345 600 000 milisekundžių (keturių dienų) laikotarpis, o „<ph name="PRODUCT_NAME" />“ – 604 800 000 milisekundžių (vienos savaitės) laikotarpis.</translation>
<translation id="8685024486845674965">Įspėjimas dėl slaptažodžio apsaugos suaktyvinamas pakartotinai naudojant slaptažodį</translation>
<translation id="8693243869659262736">Naudoti integruotą DNS kliento programą</translation>
<translation id="8704831857353097849">Neleidžiamų papildinių sąrašas</translation>
<translation id="8711086062295757690">Nurodomas raktinis žodis, kuris yra spartusis klavišas, naudojamas „Omnibox“ šio teikėjo paieškai suaktyvinti.

          Ši politika pasirenkama. Jos nenustačius, joks raktinis žodis nesuaktyvins paieškos teikėjo.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Numatytasis paieškos teikėjas įgalintas“.</translation>
<translation id="8731693562790917685">Turinio nustatymų skiltyje leidžiama nurodyti, kaip turi būti naudojamas konkretaus tipo turinys (pvz., slapukai, vaizdai arba „JavaScript“).</translation>
<translation id="8733448613597049197">Įgalinamas „<ph name="PRODUCT_NAME" />“ saugaus naršymo išplėstinių ataskaitų teikimas ir neleidžiama naudotojams keisti šio nustatymo.

      Naudojant išplėstinių ataskaitų teikimo funkciją tam tikra sistemos informacija ir puslapio turinys siunčiami į „Google“ serverius siekiant aptikti pavojingas programas ir svetaines.

      Jei nustatymas nustatytas į „true“, ataskaitos kuriamos ir siunčiamos, kada reikia (pvz., kai rodomas saugos tarpinis puslapis).

      Jei šis nustatymas nustatytas į „false“, ataskaitos niekada nesiunčiamos.

      Jei ši politika nustatyta į „true“ arba „false“, naudotojas negali keisti nustatymo.

      Jei ši politika nenustatyta, naudotojas gali keisti nustatymą ir nuspręsti, ar siųsti ataskaitas.

      Daugiau informacijos apie Saugų naršymą pateikiama adresu https://developers.google.com/safe-browsing.</translation>
<translation id="8736538322216687231">Priverstinis minimalaus „YouTube“ riboto režimo vykdymas</translation>
<translation id="8749370016497832113">Įgalinamas naršyklės ir atsisiuntimo istorijos ištrynimas „<ph name="PRODUCT_NAME" />“ ir naudotojams neleidžiama keisti šio nustatymo.

      Atminkite, kad net jei ši politika neleidžiama, negarantuojama, kad naršymo ir atsisiuntimo istorijos bus saugomos: naudotojai galbūt galės tiesiogiai redaguoti ar ištrinti failus, gali baigtis naršyklės galiojimo laikas ar ji gali archyvuoti bet kuriuos ar visus istorijos elementus.

      Jei šis nustatymas įgalintas arba nenustatytas, naršymo ir atsisiuntimo istorija gali būti ištrinta.

      Jei šis nustatymas neleidžiamas, naršymo ir atsisiuntimo istorija negali būti ištrinta.</translation>
<translation id="8759829385824155666">Leidžiami „Kerberos“ šifruotės tipai</translation>
<translation id="8764119899999036911">Nurodoma, ar sugeneruotas „Kerberos“ SPN veikia kanoniniu DNS vardu ar originaliu įvestu vardu.

          Jei įgalinsite šį nustatymą, CNAME paieška bus praleista ir bus naudojamas įvestas serverio pavadinimas.

          Jei neleisite šio nustatymo arba jo nenustatysite, kanoninis serverio pavadinimas bus nustatytas naudojant CNAME paiešką.</translation>
<translation id="8782750230688364867">Nurodomas procentas, pagal kurį bus keičiamas ekrano užtemdymo delsos mastelis, kai įrenginyje veikia pristatymo režimas.

          Jei ši politika nustatyta, ji nurodo procentą, pagal kurį keičiamas ekrano užtemdymo delsos mastelis, kai įrenginyje veikia pristatymo režimas. Kai nustatomas užtemdymo delsos mastelis, reguliuojamas ekrano išjungimas ar užrakinimas, kad būtų palaikomos vienodos ekrano užtemdymo delsos trukmės, kurios buvo sukonfigūruotos iš pradžių.

          Jei ši politika nenustatyta, naudojamas numatytasis skalės mastelio faktorius.

          Skalės mastelio faktorius turi būti 100 proc. ar daugiau. Vertės, dėl kurių ekrano užtemdymo delsos laikas dirbant pristatymo režimu būtų trumpesnis nei įprastos ekrano užtemdymo delsos laikas, neleidžiamos.</translation>
<translation id="8798099450830957504">Numatytasis</translation>
<translation id="8801680448782904838">Pranešimas naudotojui apie rekomenduojamą ar būtiną naršyklės arba įrenginio paleidimą iš naujo</translation>
<translation id="8818173863808665831">Pranešti geografinę šio įrenginio vietą.

      Jei ši politika nenustatyta ar nustatyta „Ne“, nebus pranešta apie vietą.</translation>
<translation id="8818768076343557335">Numatyti tinklo veiksmus bet kuriame ne mobiliojo ryšio tinkle.
          (Nebenaudojama nuo 50 versijos, pašalinta 52 versijoje. Po 52 versijos, jei nustatyta 1 vertė, ji bus laikoma 0 – numatyti tinklo veiksmus bet kurio ryšio tinkle.)</translation>
<translation id="8825782996899863372">Įspėjimas dėl slaptažodžio apsaugos suaktyvinamas pakartotinai naudojant slaptažodį sukčiavimo puslapyje</translation>
<translation id="8828766846428537606">Konfigūruojamas numatytasis pagrindinis „<ph name="PRODUCT_NAME" />“ puslapis, kurio keisti naudotojams neleidžiama.

      Naudotojo pagrindinio puslapio nustatymai bus visiškai užrakinti tik tada, jei kaip pagrindinį puslapį pasirinksite naujo skirtuko puslapį arba nustatysite, kad į jį būtų įkeltas URL, ir nurodysite pagrindinio puslapio URL. Jei pagrindinio puslapio URL nenurodysite, naudotojui ir toliau bus leidžiama kaip pagrindinį puslapį nustatyti naujo skirtuko puslapį nurodant „chrome://newtab“.</translation>
<translation id="8833109046074170275">Autentifikavimas per numatytąją GAIA eigą</translation>
<translation id="8838303810937202360">„<ph name="PRODUCT_OS_NAME" />“ talpykloje išsaugo programas ir plėtinius, kad juos galėtų įdiegti keli vieno įrenginio naudotojai ir kiekvienam naudotojui nereikėtų jų atsiųsti.
      Jei ši politika nesukonfigūruota arba vertė nustatyta į mažiau nei 1 MB, „<ph name="PRODUCT_OS_NAME" />“ naudos numatytojo dydžio talpyklą.</translation>
<translation id="8858642179038618439">Priverstinis „YouTube“ saugos režimas</translation>
<translation id="8860342862142842017">Išjungti sąraše nurodytų „subjectPublicKeyInfo“ maišų sertifikato skaidrumo įgyvendinimą</translation>
<translation id="8864975621965365890">Nerodomas raginimas išjungti, kuris rodomas, kai svetainę pateikia „<ph name="PRODUCT_FRAME_NAME" />“.</translation>
<translation id="8867464911288727016">Įgalinama integruota „Google“ vertėjo paslauga „<ph name="PRODUCT_NAME" />“.

      Jei įgalinsite šį nustatymą, „<ph name="PRODUCT_NAME" />“ bus teikiama vertimo funkcija naudotojui, rodant integruotą vertėjo įrankių juostą (kai galima) ir vertimo parinktį kontekstiniame meniu, kuris rodomas spustelėjus dešiniuoju pelės klavišu.

      Jei išjungsite šį nustatymą, visos integruotos vertimo funkcijos bus išjungtos.

      Jei įgalinsite arba išjungsite šį nustatymą, naudotojai negalės pakeisti ar nepaisyti šio nustatymo „<ph name="PRODUCT_NAME" />“.

      Nenustačius šio nustatymo, naudotojas galės nuspręsti, ar naudoti šią funkciją.</translation>
<translation id="8870318296973696995">Pagrindinis puslapis</translation>
<translation id="8876188741456358123">Nepaisoma numatytojo spausdinimo dvipusiu režimu. Jei režimas nepasiekiamas, šios politikos nepaisoma.</translation>
<translation id="8882006618241293596">Užblokuoti papildinį „<ph name="FLASH_PLUGIN_NAME" />“ šiose svetainėse</translation>
<translation id="890403179930035128">Priverstinai įgalinamos rašybos tikrinimo kalbos. Bus nepaisoma tame sąraše nurodytų neatpažintų kalbų.

      Jei įgalinsite šią politiką, be kalbų, kurių rašybos tikrinimą įgalino naudotojas, bus įgalintas nurodytų kalbų rašybos tikrinimas.

      Jei šios politikos nenustatysite arba ją išjungsite, nebus atlikta naudotojo rašybos tikrinimo nuostatų pakeitimų.

      Jei politika „SpellcheckEnabled“ išjungta, ši politika neturės jokio poveikio.

      Šiuo metu palaikomos šios kalbos: af, bg, ca, cs, da, de, el, en-AU, en-CA, en-GB, en-US, es, es-419, es-AR, es-ES, es-MX, es-US, et, fa, fo, fr, he, hi, hr, hu, id, it, ko, lt, lv, nb, nl, pl, pt-BR, pt-PT, ro, ru, sh, sk, sl, sq, sr, sv, ta, tg, tr, uk, vi.</translation>
<translation id="8906768759089290519">Įgalinti svečio režimą</translation>
<translation id="8908294717014659003">Leidžiama jums nustatyti, ar svetainėms leidžiama prieiga prie medijos vaizdų įvedimo įrenginių. Medijos vaizdų įvedimo įrenginių prieiga gali būti leidžiama pagal numatytuosius nustatymus arba naudotojo (-os) gali būti klausiama kiekvieną kartą, kai svetainė nori gauti prieigą prie medijos vaizdų įvedimo įrenginių.

          Nenustačius šios politikos naudojama „PromptOnAccess“ (paraginti pasiekiant) ir naudotojas (-a) gali tai pakeisti.</translation>
<translation id="8909280293285028130">Nurodoma laiko trukmė be naudotojo įvesties, po kurios ekranas užrakinamas, kai naudojama kintamosios srovės energija.

          Kai šios politikos vertė yra didesnė už nulį, ji nurodo laiko trukmę, kurią naudotojas turi neatlikti jokių veiksmų, kol „<ph name="PRODUCT_OS_NAME" />“ užrakins ekraną.

          Kai ši politika nustatyta į nulį, „<ph name="PRODUCT_OS_NAME" />“ neužrakina ekrano, kai naudotojas neatlieka jokių veiksmų.

          Kai ši politika nenustatyta, naudojama numatytoji laiko trukmė.

          Rekomenduojamas būdas užrakinti ekraną, kai neatliekama veiksmų, yra įgalinti ekrano užraktą, kai veiksmai laikinai neatliekami, ir nustatyti, kad „<ph name="PRODUCT_OS_NAME" />“ būtų laikinai sustabdyta po neveikos delsos. Ši politika turėtų būti naudojama, tik jei ekranas turėtų būti užrakinamas daug greičiau iki laikino sustabdymo arba kai visiškai nepageidaujama, kad būtų laikinai sustabdoma, kai neatliekate jokių veiksmų.

          Politikos vertė turėtų būti nurodoma milisekundėmis. Vertės sumažinamos, kad neviršytų neveikos delsos laiko.</translation>
<translation id="891435090623616439">koduojama JSON eilute, daugiau informacijos pateikiama apsilankius adresu <ph name="COMPLEX_POLICIES_URL" /></translation>
<translation id="8934944553121392674">Valdoma, kurie spausdintuvai iš „<ph name="DEVICE_PRINTERS_POLICY" />“ pasiekiami naudotojams.

      Nustatoma, kuri pasiekiamumo politika naudojama masinei spausdintuvų konfigūracijai. Jei pasirinkta „<ph name="PRINTERS_ALLOW_ALL" />“, rodomi visi spausdintuvai. Jei pasirinkta „<ph name="PRINTERS_BLACKLIST" />“, „<ph name="DEVICE_PRINTERS_BLACKLIST" />“ naudojama pasiekiamumui prie nurodytų spausdintuvų apriboti. Jei pasirinkta „<ph name="PRINTERS_WHITELIST" />“, „<ph name="DEVICE_PRINTERS_WHITELIST" />“ nustato tik tuos spausdintuvus, kuriuos galima pasirinkti.

      Jei ši politika nenustatyta, taikoma „<ph name="PRINTERS_ALLOW_ALL" />“.
      </translation>
<translation id="8938932171964587769">Ši politika nebenaudojama naudojant M69. Naudokite
      „OverrideSecurityRestrictionsOnInsecureOrigin“.

      Politikoje nurodytas šaltinių (URL) arba prieglobos serverio pavadinimo 
      šablonų (pvz., *.example.com), kuriems nebus taikomi nesaugių šaltinių 
      apribojimai, sąrašas.

      Siekiama leisti organizacijoms nustatyti pasenusių programų, negalinčių taikyti
      TLS, baltojo sąrašo šaltinius arba darbinį serverį vidiniams žiniatinklio
      tobulinimams atlikti, kad organizacijų kūrėjai galėtų išbandyti funkcijas,
      kurioms reikia saugaus konteksto, ir darbiniame serveryje nereikėtų diegti
      TLS. Ši politika taip pat neleis, kad „omnibox“ šaltinis būtų pažymėtas kaip
      „Nesaugus“.

      Šioje politikoje nustačius URL sąrašą poveikis toks pat, kaip nustačius
      komandinės eilutės žymą „--unsafely-treat-insecure-origin-as-secure“ į
      kableliais atskirtų tų pačių URL sąrašą. Jei ši politika nustatyta, bus
      nepaisoma komandinės eilutės žymos.

      Vietoj šios politikos M69 naudojama
      „OverrideSecurityRestrictionsOnInsecureOrigin“. Jei yra abi politikos,
      „OverrideSecurityRestrictionsOnInsecureOrigin“ pakeis šią politiką.

      Daugiau informacijos apie saugius kontekstus pateikiama adresu
      https://www.w3.org/TR/secure-contexts/
      </translation>
<translation id="8942616385591203339">Pagal šią politiką valdoma, ar sutikimas sinchronizuoti gali būti rodomas naudotojui prisijungiant pirmą kartą. Ji turi būti nustatyta kaip „false“, jei naudotojui niekada nereikia sutikimo sinchronizuoti.
      Nustačius kaip „false“, sutikimas sinchronizuoti nebus pateikiamas.
      Nustačius kaip „true“ arba nenustačius, sutikimas sinchronizuoti gali būti pateikiamas.</translation>
<translation id="8947415621777543415">Pranešti įrenginio vietą</translation>
<translation id="8951350807133946005">Nustatyti disko talpyklos katalogą</translation>
<translation id="8952317565138994125">Išjungiamas „<ph name="PRODUCT_NAME" />“ duomenų sinchronizavimas naudojant „Google“ priglobtas sinchronizavimo paslaugas ir naudotojams neleidžiama keisti šio nustatymo.

      Jei įgalinsite šį nustatymą, naudotojai negalės pakeisti ar nepaisyti šio nustatymo programoje „<ph name="PRODUCT_NAME" />“.

      Jei šią politiką paliksite nenustatytą, naudotojai galės pasirinkti, ar naudoti „Google“ sinchronizavimą.

      Kad visiškai išjungtumėte „Google“ sinchronizavimą, rekomenduojame išjungti „Google“ sinchronizavimą apsilankius „Google Admin Console“.

      Ši politika neturėtų būti įgalinta, kai „<ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" />“ politika nustatyta kaip įgalinta, nes ta funkcija bendrai naudoja tas pačias kliento programos funkcijas. Šiuo atveju „Google“ priglobtos sinchronizavimo paslaugos yra visiškai išjungtos.</translation>
<translation id="8955719471735800169">Į pradžią</translation>
<translation id="8959992920425111821">Numatytoji konfigūracija</translation>
<translation id="8960850473856121830">Šiame sąraše pateikti šablonai bus palyginti su užklausą pateikusio
      URL saugos šaltiniu. Jei bus rasta atitiktis, galimybė pasiekti garsą 
      fiksuojančius įrenginius bus suteikta be raginimo.

      PASTABA: iki 45 versijos programos ši politika buvo palaikoma tik įjungus viešojo terminalo režimą.</translation>
<translation id="8970205333161758602">Nerodyti „<ph name="PRODUCT_FRAME_NAME" />“ išjungimo paraginimo</translation>
<translation id="8976248126101463034">Leidžiamas nuotolinės prieigos prieglobos serverių „Gnubby“ autentifikavimas</translation>
<translation id="8976531594979650914">Naudoti sistemos numatytąjį spausdintuvą kaip numatytąjį nustatymą</translation>
<translation id="898520305112996948">Leidžiama nustatyti URL šablonus, nurodančius, kurioms svetainėms bus automatiškai suteikiamas leidimas pasiekti nurodyto gamintojo USB įrenginį, turintį nurodytą produkto ID. Kad politika galiotų, kiekviename sąraše esančiame elemente turi būti įrenginių ir URL šablonai. Kiekvienas įrenginiuose esantis elementas gali turėti pardavėjo ID ir produkto ID lauką. Kiekvienas nenurodytas ID laikomas pakaitos simboliu su viena išimtimi – produkto ID negali būti nurodytas, jei nenurodytas pardavėjo ID. Priešingu atveju politika negalios. Negaliojančių politikų nepaisoma.

        Jei ši politika nenustatyta, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „DefaultPluginsSetting“ (jei ji nustatyta) arba naudotojo asmeninės konfigūracijos (kitu atveju).

        Šios politikos URL šablonai negali būti nesuderinami su tais, kurie sukonfigūruoti naudojant „WebUsbBlockedForUrls“. Jei jie nesuderinami, šiai politikai teikiama pirmenybė prieš „WebUsbBlockedForUrls“ ir „WebUsbAskForUrls“.</translation>
<translation id="8992176907758534924">Neleisti jokioje svetainėje rodyti vaizdų</translation>
<translation id="9012851181124311976">Konfigūruojamas įmonių prisijungimo URL (tik HTTP ir HTTPS schemų) sąrašas. Šiais URL bus užfiksuotas slaptažodžio piršto antspaudas, kuris bus naudojamas aptinkant, kada slaptažodis naudojamas pakartotinai.
      Kad „<ph name="PRODUCT_NAME" />“ tinkamai užfiksuotų slaptažodžių kontrolinius kodus, įsitikinkite, kad prisijungimo puslapiuose laikomasi šių gairių: https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Įgalinus šį nustatymą, taikant slaptažodžio apsaugos paslaugą bus fiksuojamas slaptažodžio piršto antspaudas šiais URL adresais, siekiant aptikti, kada slaptažodis naudojamas pakartotinai.
      Jei šis nustatymas išjungtas arba nenustatytas, taikant slaptažodžio apsaugos paslaugą slaptažodžio piršto antspaudas bus užfiksuotas tik adresu https://accounts.google.com.
      Ši politika nepasiekiama „Windows“ objektuose, kurie nesusieti su „<ph name="MS_AD_NAME" />“ domenu.</translation>
<translation id="9035964157729712237">Į juodąjį sąrašą neįtrauktinų plėtinių ID</translation>
<translation id="9042911395677044526">Leidžiama pateikti tinklo konfigūraciją, kad būtų taikoma „<ph name="PRODUCT_OS_NAME" />“ įrenginiui pagal naudotoją. Tinklo konfigūracija yra JSON formatuota eilutė, apibrėžta pagal „Atvirosios tinklo konfigūracijos“ formatą, nurodytą šiuo adresu: <ph name="ONC_SPEC_URL" /></translation>
<translation id="9077227880520270584">Automatinio prisijungimo prie vietinės įrenginio paskyros laikmatis</translation>
<translation id="9084985621503260744">Nurodykite, ar vaizdo įrašo veikla paveikia energijos valdymą</translation>
<translation id="9088433379343318874">Įgalinti prižiūrimo naudotojo turinio teikėją</translation>
<translation id="9088444059179765143">Automatinio laiko juostos aptikimo metodo konfigūravimas</translation>
<translation id="9094064873808699479">Grąžinti ir palikti tikslinę versiją, jei OS versija naujesnė nei tikslinė. Pabandykite perduoti įrenginio lygio konfigūraciją (įskaitant tinklo prisijungimo duomenis) vykdydami grąžinimo procesą, jei įmanoma, bet grąžinimą atlikite naudodami išsamų „Powerwash“, net jei negalima atkurti duomenų (nes tikslinė versija nepalaiko duomenų atkūrimo arba dėl nesuderinamo atgalinio pakeitimo).
          Palaikoma naudojant 70 ir naujesnių versijų „<ph name="PRODUCT_OS_NAME" />“. Jei kliento programa senesnė, ši vertė reiškia, kad grąžinimas išjungtas.</translation>
<translation id="9096086085182305205">Tapatumo nustatymo serverio baltasis sąrašas</translation>
<translation id="9098553063150791878">HTTP autentifikavimo politika</translation>
<translation id="9105265795073104888">„Android“ programos gali pasiekti tik dalį tarpinio serverio konfigūravimo parinkčių. „Android“ programos gali pasirinkti naudoti tarpinį serverį. Negalite jų priversti naudoti tarpinio serverio.</translation>
<translation id="9106865192244721694">„WebUSB“ leidimas šiose svetainėse</translation>
<translation id="9112727953998243860">Įmonės spausdintuvo konfigūracijos failas</translation>
<translation id="9112897538922695510">Leidžiama registruoti protokolo doroklių sąrašą. Tai gali būti tik rekomenduojama politika. Ypatybė |protocol| turėtų būti nustatyta į schemą, pvz., „mailto“, o ypatybė |url| turėtų būti nustatyta į schemą apdorojančios programos URL šabloną. Šablone gali būti įtrauktas „%s“, kurį pakeis apdorotas URL.

          Pagal politiką užregistruotos protokolo doroklės sujungiamos su naudotojo užregistruotomis doroklėmis ir jas abi galima naudoti. Naudotojas gali nepaisyti pagal politiką įdiegtų protokolo doroklių įdiegdamas naują numatytąją doroklę, bet jis negali pašalinti pagal politiką užregistruotos protokolo doroklės.</translation>
<translation id="9123211093995421438">Nurodomas minimalus „<ph name="PRODUCT_OS_NAME" />“ ankstesnių versijų, kurias bet kada turėtų būti leidžiama grąžinti, skaičius, pradedant nuo stabilios versijos.

      Numatytasis nustatymas klientų užregistruotiems įrenginiams yra 0, įmonių užregistruotiems įrenginiams – 8 (maždaug 1 metai).

       Nustačius šią politiką neleidžiama taikyti grąžinimo apsaugos bent šiam ankstesnių versijų skaičiui.

      Nustačius mažesnę šios politikos vertę, tai taikoma visą laiką: gali būti, kad įrenginyje NEBUS galima grąžinti ankstesnių versijų, net iš naujo nustačius didesnę politikos vertę.

      Faktines grąžinimo galimybes taip pat gali lemti aparatinė įranga ir kritinio pažeidžiamumo pataisos.</translation>
<translation id="913195841488580904">Blokuoti prieigą prie URL sąrašo</translation>
<translation id="9135033364005346124">Įgalinti <ph name="CLOUD_PRINT_NAME" /> tarpinį serverį</translation>
<translation id="9136399279941091445">Nenaudojimo valandų intervalai, kai išleidžiama nurodyta įrenginio politika</translation>
<translation id="9147029539363974059">Siunčiami sistemos žurnalai valdymo serveriui, kad būtų leidžiama
      administratoriams stebėti sistemos žurnalus.

      Jei ši politika nustatyta į „true“, bus siunčiami sistemos žurnalai. Jei nustatyta
      į „false“ arba yra nenustatyta, sistemos žurnalai siunčiami nebus.</translation>
<translation id="9150416707757015439">Ši politika nepatvirtinta. Vietoje jos naudokite „Inkognito režimo pasiekiamumas“.
      Įgalinamas inkognito režimas „<ph name="PRODUCT_NAME" />“.

      Jei šis nustatymas įgalintas arba nesukonfigūruotas, naudotojai gali atidaryti tinklalapius inkognito režimu.

      Jei šis nustatymas neleidžiamas, naudotojai negali atidaryti tinklalapių inkognito režimu.

      Nenustačius šios politikos, tai bus įgalinta ir naudotojas (-a) galės naudoti inkognito režimą.</translation>
<translation id="915194831143859291">Jei ši politika nustatyta į „false“ arba nesukonfigūruota, „<ph name="PRODUCT_OS_NAME" />“ leidžia naudotojui išjungti įrenginį.
      Jei ši politika nustatyta į „true“, „<ph name="PRODUCT_OS_NAME" />“ suaktyvina paleidimą iš naujo, kai naudotojas išjungia įrenginį. Visus išjungimo mygtukų atvejus NS „<ph name="PRODUCT_OS_NAME" />“ pakeičia paleidimo iš naujo mygtukais. Jei naudotojas išjungia įrenginį naudodamas maitinimo mygtuką, įrenginys nėra automatiškai paleidžiamas iš naujo, net jei politika įgalinta.</translation>
<translation id="9152473318295429890">Kontekstinių susijusių tinklalapių siūlymų įgalinimas</translation>
<translation id="9158929520101169054">Leidimas naršyklėje prisijungti prie kelių paskyrų</translation>
<translation id="9159126470527871268">Pranešama naudotojams, kad būtina iš naujo paleisti „<ph name="PRODUCT_NAME" />“ arba „<ph name="PRODUCT_OS_NAME" />“, norint pritaikyti laukiantį naujinį.

      Taikant šį politikos nustatymą įgalinami pranešimai, kuriais naudotojas informuojamas, kad rekomenduojama arba būtina iš naujo paleisti naršyklę ar įrenginį. Nenustačius, „<ph name="PRODUCT_NAME" />“ subtiliais meniu pakeitimais nurodo naudotojui, kad reikia paleisti iš naujo, o „<ph name="PRODUCT_OS_NAME" />“ tai praneša sistemos juostelės pranešimais. Nustačius kaip „Rekomenduojama“, naudotojui rodomas pasikartojantis įspėjimas, kad rekomenduojama paleisti iš naujo. Naudotojas gali atsisakyti šio pranešimo, kad atidėtų paleidimą iš naujo. Nustačius kaip „Būtina“, naudotojui rodomas pasikartojantis įspėjimas, nurodantis, kad naršyklė bus priverstinai paleista iš naujo pasibaigus pranešimo laikotarpiui. Pagal numatytuosius nustatymus šis laikotarpis „<ph name="PRODUCT_NAME" />“ yra septynios, o „<ph name="PRODUCT_OS_NAME" />“ – keturios dienos. Jį galima konfigūruoti politikos „<ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" />“ nustatymuose.

      Paleidus iš naujo, naudotojo sesija atkuriama.</translation>
<translation id="9165792353046089850">Galite nustatyti, ar svetainėms leidžiama pasiekti prijungtus USB įrenginius. Pasiekiamumą galima užblokuoti visiškai arba naudotojo gali būti klausiama kiekvieną kartą, kai svetainė nori pasiekti prijungtus USB įrenginius.

          Šios politikos galima nepaisyti konkretiems URL šablonams, naudojantiems politiką „WebUsbAskForUrls“ ir „WebUsbBlockedForUrls“.

          Jei ši politika nenustatyta, bus naudojama vertė „3“ ir naudotojas galės ją pakeisti.</translation>
<translation id="9167719789236691545">Išjungti Diską „<ph name="PRODUCT_OS_NAME" />“ programoje „Failai“</translation>
<translation id="9187743794267626640">Neleisti montuoti išorinės atminties</translation>
<translation id="9197740283131855199">Ekrano užtemdymo delsos mastelio keitimo procentas, naudojamas, jei naudotojas atlieka veiksmų po užtemdymo</translation>
<translation id="9200828125069750521">Vaizdo URL parametrai, kuriuose naudojama POST</translation>
<translation id="920209539000507585">Antraštės ir poraštės priverstinai įjungiamos arba išjungiamos spausdinimo dialogo lange.

      Jei politika nenustatyta, naudotojas gali nuspręsti, ar spausdinti antraštes ir poraštes.

      Jei politika nustatyta kaip „Netiesa“, parinktis „Antraštės ir poraštės“ nepasirenkama spaudinio peržiūros dialogo lange ir naudotojas negali to pakeisti.

      Jei politika nustatyta kaip „Tiesa“, parinktis „Antraštės ir poraštės“ pasirenkama spaudinio peržiūros dialogo lange ir naudotojas negali to pakeisti.</translation>
<translation id="9210953373038593554">Konfigūruojamas SAML prisijungimo autentifikavimo tipas.

      Kai ši politika nenustatyta arba nustatyta į numatytąją parinktį (vertę „0“), SAML prisijungimo elgseną nustato naršyklė, atsižvelgdama į kitus veiksnius. Paprasčiausiu atveju naudotojų autentifikavimas ir talpykloje saugomų naudotojo duomenų apsauga vykdoma pasitelkiant naudotojų neautomatiškai įvedamus slaptažodžius.

      Kai ši politika nustatyta į „ClientCertificate“ (vertė „1“), naujai pridėtų naudotojų, kurie prisijungia per SAML, tapatybei nustatyti naudojamas kliento sertifikato autentifikavimas. Tokiems naudotojas autentifikuoti nenaudojami slaptažodžiai, o talpykloje saugomi vietiniai duomenys apsaugomi naudojant atitinkamus kriptografinius raktus. Pvz., naudojant šį nustatymą galima konfigūruoti išmaniąją kortelę pasitelkiant naudotojo autentifikavimą (atminkite, kad išmaniosios kortelės tarpinės programos turi būti įdiegtos naudojant politiką „DeviceLoginScreenAppInstallList“).

      Ši politika daro įtaką tik naudotojams, kurie autentifikuojami naudojant SAML.</translation>
<translation id="9213347477683611358">Konfigūruokite įrenginio lygio ekrano fono vaizdą, kuris rodomas prisijungimo ekrane, jei prie įrenginio neprisijungė joks naudotojas. Politika nustatoma nurodant URL, kuriuo „Chrome“ OS įrenginys gali atsisiųsti ekrano fono vaizdą ir kriptografinę maišos vertę, kuri naudojama atsisiuntimo vientisumui patvirtinti. Vaizdas turi būti JPEG formato, o dydis neturi viršyti 16 MB. URL turi būti pasiekiamas be autentifikavimo. Ekrano fono vaizdas atsisiunčiamas ir įkeliamas į talpyklą. Jis bus iš naujo atsisiųstas pasikeitus URL arba maišos vertei.

      Politika turėtų būti nurodyta kaip eilutė, kurioje pateikiamas URL ir maišos vertė JSON formatu, pvz.,
      {
        "url": "https://example.com/device_wallpaper.jpg",
        "hash": "examplewallpaperhash"
      }

      Jei nustatyta įrenginio politika, „Chrome“ OS įrenginys atsisiųs ir naudos ekrano fono vaizdą prisijungimo ekrane, jei joks naudotojas neprisijungė prie įrenginio. Kai naudotojas prisijungs, įsigalios naudotojo ekrano fono politika.

      Jei įrenginio ekrano fono politika nenustatyta, naudotojo ekrano fono politika, jei nustatyta, lemia, kas bus rodoma.</translation>
<translation id="9217154963008402249">Tinklo paketų stebėjimo dažnis</translation>
<translation id="922540222991413931">Konfigūruokite plėtinio, programos ir naudotojo scenarijaus įdiegimo šaltinius.</translation>
<translation id="924557436754151212">Importuoti išsaugotus slaptažodžius iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="930930237275114205">Nustatyti „<ph name="PRODUCT_FRAME_NAME" />“ naudotojo duomenų katalogą</translation>
<translation id="944817693306670849">Nustatyti disko talpyklos dydį</translation>
<translation id="981346395360763138">„Google“ vietovės paslaugos išjungtos</translation>
<translation id="982497069985795632">Rašybos tikrinimo įgalinimas</translation>
<translation id="988537626274109600">Pagal šią politiką valdomi laikotarpiai, per kuriuos „<ph name="PRODUCT_OS_NAME" />“ įrenginiui neleidžiama automatiškai tikrinti, ar yra naujinių.
      Kai ši politika nustatyta kaip ne tuščias laikotarpių sąrašas:
      įrenginiai negalės automatiškai tikrinti, ar yra naujinių, nurodytais laikotarpiais. Įrenginiams, kuriuose reikia grąžinti ankstesnę „<ph name="PRODUCT_OS_NAME" />“ versiją ar kurių versija yra senesnė nei minimali reikalaujama, ši politika neturės jokios įtakos dėl potencialių saugos problemų. Be to, ši politika neblokuos naujinių patikrinimų, kurių užklausas bus pateikę naudotojai ar administratoriai.
      Kai ši politika nenustatyta ar joje nėra jokių laikotarpių:
      jokie automatiniai naujinių patikrinimai pagal šią politiką nebus blokuojami, tačiau jie gali būti blokuojami pagal kitą politiką.</translation>
</translationbundle>