<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="lt">
<translation id="1503959756075098984">Automatiškai diegiami plėtinių ID ir atnaujinimo URL</translation>
<translation id="2463365186486772703">Programos lokalė</translation>
<translation id="1397855852561539316">Numatytojo paieškos teikėjo siūlymo URL</translation>
<translation id="3347897589415241400">Numatytoji elgsena, skirta svetainėms, neesančioms turinio paketuose.

          Ši politika skirta naudoti tik „Chrome“ viduje.</translation>
<translation id="7040229947030068419">Vertės pavyzdys:</translation>
<translation id="1213523811751486361">Nurodomas paieškos variklio, naudoto 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.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Numatytasis paieškos teikėjas įgalintas“.</translation>
<translation id="6106630674659980926">Įgalinti slaptažodžių tvarkytuvę</translation>
<translation id="7109916642577279530">Leisti arba atmesti garso fiksavimą.

      Jei ši politika yra įgalinta arba nesukonfigūruota (numatytasis nustatymas), naudotojas bus paragintas
      suteikti prieigą fiksuoti garsą, išskyrus sąraše „AudioCaptureAllowedUrls“
      sukonfigūruotiems URL, kuriems prieiga bus suteikta be paraginimo.

      Kai ši politika išjungta, naudotojas niekada nebus raginamas ir garso
      fiksavimas bus pasiekiamas tik sąraše „AudioCaptureAllowedUrls“ sukonfigūruotiems URL.

      Ši politika turi įtakos visoms garso įrašų įvestims, ne tik įdiegtam mikrofonui.</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="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="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="7818131573217430250">Nustatyti numatytąją didelio kontrasto režimo prisijungimo ekrane būklę</translation>
<translation id="7614663184588396421">Neleidžiamų protokolų schemų sąrašas</translation>
<translation id="2309390639296060546">Numatytasis geografinės vietovės nustatymas</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="7443616896860707393">Mišrios kilmės HTTP pagrindinio autentifikavimo raginimai</translation>
<translation id="2337466621458842053">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose leidžiama pateikti vaizdų, sąrašą.

          Nenustačius šios politikos, visose svetainėse naudojama visuotinė numatytoji vertė iš politikos „Numatytasis vaizdų nustatymas“ (jei nustatyta) ar naudotojo asmeninės konfigūracijos.</translation>
<translation id="4680961954980851756">Įgalinti automatinį pildymą</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="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="3185009703220253572">nuo <ph name="SINCE_VERSION"/> versijos</translation>
<translation id="2204753382813641270">Valdyti automatinį lentynos paslėpimą</translation>
<translation id="3816312845600780067">Įgalinti laisvuosius sparčiuosius klavišus automatiškai prisijungiant</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="5330684698007383292">Leisti „<ph name="PRODUCT_FRAME_NAME"/>“ naudoti šių tipų turinį</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="69525503251220566">Parametras, nurodantis paieškos pagal vaizdą funkciją numatytajam paieškos teikėjui</translation>
<translation id="5469825884154817306">Blokuoti vaizdus šiose svetainėse</translation>
<translation id="8412312801707973447">Ar atliekami OCSP / CRL patikrinimai prisijungus</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="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="2908277604670530363">Didžiausias jungčių prie tarpinio serverio vienu metu skaičius</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="4838572175671839397">Nurodant, kurie naudotojai gali prisijungti prie „<ph name="PRODUCT_NAME"/>“, naudojamas reguliarusis reiškinys.

      Jei naudotojas bando prisijungti naudotoju vardu, neatitinkančiu šio šablono, pateikiama atitinkama klaida.

      Jei ši politika nenustatyta arba jos laukas tuščias, tada bet kuris naudotojas gali prisijungti prie „<ph name="PRODUCT_NAME"/>“.</translation>
<translation id="2892225385726009373">Kai šis nustatymas bus įgalintas, „<ph name="PRODUCT_NAME"/>“ visada atliks serverio sertifikatų, kurie sėkmingai 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 „Ne“, „Chrome“ naudoja esamus panaikinimo tikrinimo prisijungus nustatymus.</translation>
<translation id="1438955478865681012">Konfigūruojama su plėtiniais susijusi politika. Naudotojui neleidžiama diegti į juodąjį sąrašą įtrauktų plėtinių, jei jų nėra baltajame sąraše. Taip pat galite nustatyti, kad „<ph name="PRODUCT_NAME"/>“ automatiškai įdiegtų plėtinius, nurodydama juos „<ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>“. Juodasis sąrašas laikomas prioritetiniu privalomai įdiegiamų plėtinių sąrašo atžvilgiu.</translation>
<translation id="3516856976222674451">Apribojama maksimali naudotojo sesijos trukmė.

      Kai ši politika nustatyta, nurodoma trukmė, po kurios naudotojas automatiškai atjungiamas ir sesija nutraukiama. Naudotojui likusi trukmė nurodoma atgalinės atskaitos laikmačiu, pateikiamu sistemos dėkle.

      Kai ši politika nenustatyta, sesijos trukmė neribojama.

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

      Politikos vertė turi būti nurodyta milisekundėmis. Vertė gali būti nuo 30 sekundžių iki 24 valandų.</translation>
<translation id="9200828125069750521">Vaizdo URL parametrai, kuriuose naudojama POST</translation>
<translation id="2769952903507981510">Konfigūruoti reikiamą nuotolinės prieigos prieglobų domeno pavadinimą</translation>
<translation id="3478024346823118645">Ištrinti naudotojo duomenis atsijungiant</translation>
<translation id="8668394701842594241">Nurodomas „<ph name="PRODUCT_NAME"/>“ įgalintų papildinių sąrašas ir naudotojams šio nustatymo keisti neleidžiama.

      Kad įrašai atitiktų abejotinų simbolių sekas, galima naudoti pakaitos simbolius „*“ ir „?“. „*“ atitinka abejotiną simbolių skaičių, o „?“ nurodo vieną pasirinktinį simbolį, t. y. atitinka nulio arba vieneto simbolį. Kaitos simbolis yra „\“, taigi, kad simboliai atitiktų faktinius „*“, „?“ arba „\“ simbolius, prieš juos galite įvesti „\“.

      „<ph name="PRODUCT_NAME"/>“ visada naudojamas nurodytas papildinių sąrašas, jei jie yra įdiegti. Papildiniai žymimi kaip įgalinti skiltyje „about:plugins“ ir naudotojai negali jų neleisti.

     Atminkite, kad nustačius šią politiką bus nepaisoma nei neleidžiamų papildinių, nei neleidžiamų papildinių išimčių politikos.

      Nenustačius šios politikos, naudotojas (-a) gali neleisti sistemoje įdiegtų papildinių.</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="4157003184375321727">Pranešti OS ir programinės aparatinės įrangos versiją</translation>
<translation id="4752214355598028025">Naudojant Saugaus naršymo paslaugą rodomas įspėjimo puslapis, kai naudotojai naršo svetaines, kurios pažymėtos kaip potencialiai kenksmingos. Įgalinus šį nustatymą neleidžiama naudotojams iš įspėjimo puslapio tęsti veiksmų kenkėjiškoje svetainėje.

      Jei nustatymas neleidžiamas arba nesukonfigūruotas, naudotojai gali pasirinkti tęsti veiksmus pažymėtoje svetainėje, kai parodomas įspėjimas.</translation>
<translation id="5255162913209987122">Gali būti rekomenduojama</translation>
<translation id="1861037019115362154">Nurodomas „<ph name="PRODUCT_NAME"/>“ neleidžiamų papildinių sąrašas ir naudotojams šio nustatymo keisti neleidžiama.

       Kad įrašai atitiktų atsitiktinių simbolių sekas, galima naudoti pakaitos simbolius „*“ ir „?“. „*“ atitinka atsitiktinį simbolių skaičių, o „?“ nurodo vieną pasirinktinį simbolį, t. y. atitinka nulio arba vieneto simbolį. Kaitos simbolis yra „\“, todėl, kad simboliai atitiktų faktinius „*“, „?“ arba „\“ simbolius, prieš juos galite įvesti „\“.

      Jei įgalinate šį nustatymą, nurodytas papildinių sąrašas niekada nenaudojamas „<ph name="PRODUCT_NAME"/>“. Papildiniai žymimi kaip neleidžiami skiltyje „about:plugins“ ir naudotojai negali jų įgalinti.

      Atminkite, kad šią politiką galima pakeisti taikant „EnabledPlugins“ (įgalinti papildiniai) ir „DisabledPluginsExceptions“ (neleidžiamų papildinių išimtys).

      Nenustačius šios politikos, naudotojas (-a) gali naudoti bet kokį sistemoje įdiegtą papildinį, išskyrus užprogramuotuosius nesuderinamus, pasenusius ar pavojingus papildinius.</translation>
<translation id="9197740283131855199">Ekrano užtemdymo delsos mastelio keitimo procentas, naudojamas, jei naudotojas atlieka veiksmų po užtemdymo</translation>
<translation id="1492145937778428165">Nurodomas laikotarpis milisekundėmis, kuriuo įrenginio valdymo paslaugai pateikiama užklausa dėl įrenginio politikos informacijos.

      Nustačius šią politiką panaikinama numatytoji 3 valandų vertė. Galiojančios šios politikos vertės patenka į diapazoną nuo 1 800 000 (30 min.) iki 86 400 000 (1 d.). Bet kokioms į šį diapazoną nepatenkančioms vertėms bus taikomi atitinkami apribojimai.

      Nenustačius šios politikos „<ph name="PRODUCT_OS_NAME"/>“ bus naudojama numatytoji 3 val. vertė.</translation>
<translation id="3765260570442823273">Neveikos būsenos atjungimo įspėjimo pranešimo trukmė</translation>
<translation id="7302043767260300182">Ekrano užrakto delsa, kai naudojama kintamosios srovės energija</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="7271085005502526897">Importuoti pagrindinį puslapį iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="6036523166753287175">Įgalinkite užkardos apėjimą iš nuotolinės prieigos prieglobos</translation>
<translation id="1096105751829466145">Numatytasis paieškos teikėjas</translation>
<translation id="7567380065339179813">Leisti papildinius šiose svetainėse</translation>
<translation id="1617235075406854669">Įgalinti naršyklės ištrynimą ir atsisiuntimo istoriją</translation>
<translation id="5290940294294002042">Nurodyti papildinių, kuriuos naudotojas gali įgalinti arba kurių gali neleisti, sąrašą</translation>
<translation id="3153348162326497318">Leidžiama nurodyti, kurių plėtinių naudotojas (-a) NEGALI įdiegti. Jau įdiegti plėtiniai bus pašalinti, jei jie įtraukti į juodąjį sąrašą.

          Juodojo sąrašo vertė „*“ reiškia, kad visi plėtiniai įtraukti į juodąjį sąrašą, nebent jie išskirtinai pateikti baltajame sąraše.

          Nenustačius šios politikos, naudotojas (-a) gali įdiegti bet kurį plėtinį „<ph name="PRODUCT_NAME"/>“.</translation>
<translation id="3067188277482006117">Jei nustatyta kaip „Tiesa“, naudotojas gali naudoti „Chrome“ įrenginių aparatinę įrangą, kad nuotoliniu būdu patvirtintų tapatybę privatumo CA per įmonės platformos klavišų API „chrome.enterprise.platformKeysPrivate.challengeUserKey()“.

Jei nustatyta kaip „Netiesa“ arba nenustatyta, kreipiantis į API įvyks klaida ir bus pateiktas jos kodas.</translation>
<translation id="5809728392451418079">Nustatyti įrenginio vietinių paskyrų pateikiamą pavadinimą</translation>
<translation id="1427655258943162134">Tarpinio serverio adresas arba URL</translation>
<translation id="1827523283178827583">Naudoti fiksuotus tarpinius serverius</translation>
<translation id="3021409116652377124">Neleisti papildinių ieškiklio</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="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="3288595667065905535">Išleidimo kanalas</translation>
<translation id="2785954641789149745">Įgalinama „<ph name="PRODUCT_NAME"/>“ saugaus naršymo funkcija ir naudotojams neleidžiama keisti šio nustatymo.

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

      Jei išjungsite šį nustatymą, Saugus naršymas neveiks.

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

      Jei ši politika nenustatyta, šis nustatymas bus įgalintas, bet naudotojas galės jį keisti.</translation>
<translation id="8369602308428138533">Ekrano išjungimo delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="6513756852541213407">Leidžiama nurodyti „ <ph name="PRODUCT_NAME"/>“ naudojamą įgaliotąjį serverį ir neleidžiama naudotojams keisti įgaliotojo serverio nustatymų.

          Jei pasirinksite niekada nenaudoti įgaliotojo serverio ir visada jungtis tiesiogiai, visų kitų parinkčių bus nepaisoma.

          Jei pasirinksite naudoti sistemos įgaliotojo serverio nustatymus arba įgaliotąjį serverį aptikti automatiškai, visų kitų parinkčių bus nepaisoma.

          Jei fiksuotą serverį paleisite veikti įgaliotojo serverio režimu, galėsite nurodyti ir kitas parinktis skiltyse „Įgaliotojo serverio adresas arba URL“ ir „Kableliais atskirtų įgaliotojo serverio apėjimo taisyklių sąrašas“.

          Jei pasirinksite naudoti .pac įgaliotojo serverio scenarijų, skiltyje „URL, siejantis su įgaliotojo serverio .pac failu“ turėsite nurodyti scenarijaus URL.

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

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

          Nenustačius šios politikos naudotojai galės patys pasirinkti įgaliotojo serverio nustatymus.</translation>
<translation id="7763311235717725977">Leidžiama nustatyti, ar svetainėse galima pateikti vaizdų. Vaizdų pateikimas gali būti leidžiamas arba neleidžiamas visose svetainėse.

          Nenustačius šios politikos, bus naudojama „Leisti vaizdus“ ir naudotojas (-a) galės tai pakeisti.</translation>
<translation id="5630352020869108293">Atkurti paskutinę sesiją</translation>
<translation id="4980635395568992380">Duomenų tipas:</translation>
<translation id="3096595567015595053">Įgalintų papildinių sąrašas</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="5912364507361265851">Leisti naudotojams rodyti slaptažodžius slaptažodžių tvarkytuvėje</translation>
<translation id="510186355068252378">Neleidžiamas duomenų sinchronizavimas „<ph name="PRODUCT_NAME"/>“ naudojant „Google“ priglobtas sinchronizavimo paslaugas ir neleidžiama naudotojams keisti šio nustatymo.

      Jei įgalinsite šį nustatymą, naudotojai negalės pakeisti ar panaikinti šio nustatymo „<ph name="PRODUCT_NAME"/>“.

      Nenustačius šios politikos, naudotojai galės pasirinkti, ar naudoti „Google“ sinchronizavimą.</translation>
<translation id="7953256619080733119">Tvarkomos naudotojo neautomatinių išimčių prieglobos</translation>
<translation id="7412982067535265896">Leidžiama nustatyti URL šablonų, kuriuose nurodomos svetainės, kurioms leidžiama nustatyti tik sesijų slapukus, sąrašas.

          Nenustačius šios politikos visose svetainėse naudojama visuotinė numatytoji vertė iš „Numatytųjų slapukų nustatymų“ politikos (jei ji nustatyta) arba naudotojo asmeninės konfigūracijos.

          Jei politika „Atkurti paleidžiant“ nustatyta atkurti URL iš ankstesnių sesijų, į šią politiką neatsižvelgiama ir šių svetainių slapukai saugomi visą laiką.</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="2231817271680715693">Importuoti naršymo istoriją iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="1353966721814789986">Paleisties puslapiai</translation>
<translation id="1841130111523795147">Naudotojui leidžiama prisijungti prie „<ph name="PRODUCT_NAME"/>“ ir neleidžiama keisti šio nustatymo.

      Jei nustatysite šią politiką, galėsite konfigūruoti, ar naudotojui leidžiama prisijungti prie „<ph name="PRODUCT_NAME"/>“, ar ne.</translation>
<translation id="5564962323737505851">Konfigūruojama slaptažodžių tvarkytuvė. Jei slaptažodžių tvarkytuvė įgalinta, galite pasirinkti įgalinti naudotojo galimybę pateikti saugomus slaptažodžius aiškiu tekstu arba neleisti naudotis šia galimybe.</translation>
<translation id="4668325077104657568">Numatytasis vaizdų nustatymas</translation>
<translation id="4492287494009043413">Neleisti kurti ekrano kopijų</translation>
<translation id="6368403635025849609">Leisti „JavaScript“ šiose svetainėse</translation>
<translation id="6074963268421707432">Neleisti jokioje svetainėje rodyti darbalaukio pranešimų</translation>
<translation id="8614804915612153606">Neleidžiamas automatinis naujinys</translation>
<translation id="382476126209906314">Konfigūruoti nuotolinės prieigos prieglobų „TalkGadget“ (Pokalbių programėlės) kodą</translation>
<translation id="6561396069801924653">Rodyti pasiekiamumo parinktis sistemos dėklo meniu</translation>
<translation id="8104962233214241919">Automatiškai pasirinkti šių svetainių kliento sertifikatus</translation>
<translation id="2906874737073861391">„Programų paketo“ plėtinių sąrašas</translation>
<translation id="3758249152301468420">Neleisti kūrėjo įrankių</translation>
<translation id="8665076741187546529">Konfigūruoti plėtinių, kuriuos įdiegti buvo privaloma, sąrašą</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="1675391920437889033">Valdoma, kuriuos plėtinių / programų tipus leidžiama įdiegti.

          Naudojant šį nustatymą į baltąjį sąrašą įtraukiami leistini „<ph name="PRODUCT_NAME"/>“ įdiegti plėtinių / programų tipai. Vertė yra eilučių sąrašas, kiekviena jų turi būti vienas iš šių elementų: „plėtinys“, „tema“, „naudotojo_scenarijus“, „priglobta_programa“, „pasenusi_supakuota_programa“, „platformos_programa“. Jei reikia daugiau informacijos apie šiuos tipus, žr. „Chrome“ plėtinių dokumentaciją.

          Atminkite, kad ši politika turi įtakos plėtiniams ir programoms, priverstinai diegiamoms naudojant plėtinių priverstinio diegimo sąrašą.

          Jei šis nustatymas sukonfigūruotas, sąraše nesančių tipų plėtiniai / programos nebus įdiegti.

          Jei šis nustatymas nesukonfigūruotas, nėra jokių diegiamų plėtinių / programų apribojimų.</translation>
<translation id="6378076389057087301">Nurodykite, ar garso įrašo veikla paveikia energijos valdymą</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="4899708173828500852">Įgalinti saugų naršymą</translation>
<translation id="4442582539341804154">Įgalinti užraktą, kai įrenginys nenaudojamas arba laikinai sustabdytas</translation>
<translation id="7719251660743813569">Valdoma, ar naudojimo metrikos ataskaitos teikiamos atgal „Google“. Jei nustatyta į „true“ (tiesa), „<ph name="PRODUCT_OS_NAME"/>“ teikiamos naudojimo metrikos ataskaitos. Jei nesukonfigūruota ar nustatyta į „false“ (netiesa), metrikos ataskaitų teikimas neleidžiamas.</translation>
<translation id="2372547058085956601">Viešos sesijos automatinio prisijungimo delsa.

      Jei nenustatyta |DeviceLocalAccountAutoLoginId| politika, ji negalioja. Kiti atvejai:

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

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

      Ši politika nurodoma milisekundėmis.</translation>
<translation id="7275334191706090484">Tvarkomos žymės</translation>
<translation id="3570008976476035109">Blokuoti papildinius šiose svetainėse</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="2884728160143956392">Leisti tik sesijų slapukus šiose svetainėse</translation>
<translation id="3021272743506189340">Neleidžiamas „Google“ disko sinchronizavimas „Chrome“ OS programoje „Failai“ naudojant mobilųjį ryšį, kai nustatyta kaip „Tiesa“. Tokiu atveju duomenys sinchronizuojami tik „Google“ diske, kai prisijungta naudojant „Wi-Fi“ arba eternetą.

          Jei nenustatyta arba nustatyta kaip „Netiesa“, naudotojai galės perkelti failus į „Google“ diską naudodami mobilųjį ryšį.</translation>
<translation id="4655130238810647237">Įgalinamas žymių redagavimas naudojant „<ph name="PRODUCT_NAME"/>“ arba neleidžiama to daryti.

      Jei įgalinsite šį nustatymą, bus galima pridėti žymių, jas pašalinti arba modifikuoti. Be to, tai numatytasis nustatymas, kai ši politika nenustatyta.

      Jei šio nustatymo neleisite, žymių nebus galima pridėti, pašalinti arba modifikuoti. Esamos žymės vis tiek bus pasiekiamos.</translation>
<translation id="3496296378755072552">Slaptažodžių tvarkytuvė</translation>
<translation id="2565967352111237512">Įgalinamas anoniminis naudojimo ir su strigtimis susijusių duomenų apie „ <ph name="PRODUCT_NAME"/>“ ataskaitų teikimas „Google“ ir neleidžiama naudotojams keisti šio nustatymo.

      Jei įgalinate šį nustatymą, anoniminės naudojimo ir su strigtimis susijusių duomenų ataskaitos siunčiamos „Google“.

      Jei neleidžiate šio nustatymo, anoniminės naudojimo ir su strigtimis susijusių duomenų ataskaitos niekada nesiunčiamos „Google“.

      Jei įgalinsite šį nustatymą arba jo neleisite, naudotojai negalės pakeisti ar panaikinti šio nustatymo  „<ph name="PRODUCT_NAME"/>“.

      Nenustačius šios politikos, bus taikomas tas nustatymas, kurį naudotojas (-a) pasirinko diegdamas (-a) / pirmą kartą paleisdamas (-a).</translation>
<translation id="6256787297633808491">Visos sistemos žymos, kurios bus taikomos paleidžiant „Chrome“</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="9135033364005346124">Įgalinti <ph name="CLOUD_PRINT_NAME"/> tarpinį serverį</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="6943577887654905793">„Mac“ / „Linux“ nuostatos pavadinimas:</translation>
<translation id="6925212669267783763">Konfigūruojamas katalogas, kurį „<ph name="PRODUCT_FRAME_NAME"/>“ naudos naudotojo duomenims saugoti.

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

      Apsilankykite šiuo adresu: http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables. Rasite galimų naudoti variantų sąrašą.

      Jei šis nustatymas nenustatomas, naudojamas numatytasis profilio katalogas.</translation>
<translation id="8906768759089290519">Įgalinti svečio režimą</translation>
<translation id="2168397434410358693">Neveikos delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="838870586332499308">Įgalinti duomenų tarptinklinį ryšį</translation>
<translation id="3234167886857176179">Tai politikos nuostatų, kurių „<ph name="PRODUCT_NAME"/>“ laikosi, sąrašas.

      Nereikia patiems keisti šių nustatymų! Galite atsisiųsti šablonų iš
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>, kuriuos lengva naudoti.

      Palaikomų politikos nuostatų sąrašas yra toks pat „Chromium“ ir „Google Chrome“.

      Ši politika skirta naudoti tik „Chrome“ atvejams jūsų organizacijos viduje konfigūruoti. Šios politikos naudojimas ne organizacijoje (pvz., viešai platinamoje programoje) laikomas kenkėjiška programa ir „Google“ bei antivirusinių paslaugų teikėjų tai žymima kenkėjiška programa.

      Pastaba: pradedant nuo „Chrome 28“ politikos nuostatos įkeliamos tiesiogiai iš grupinės politikos API „Windows“. Neautomatiškai registre įrašytų politikos nuostatų nebus paisoma. Jei reikia išsamios informacijos, žr. adresu http://crbug.com/259236.</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="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="254524874071906077">Nustatyti „Chrome“ kaip numatytąją naršyklę</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="5056708224511062314">Ekrano didinimas išjungtas</translation>
<translation id="4377599627073874279">Leisti visose svetainėse rodyti visus vaizdus</translation>
<translation id="7195064223823777550">Nurodykite veiksmą, kuris bus atliktas, kai naudotojas uždarys dangtelį.

          Kai ši politika nustatyta, ji nurodo veiksmą, kurį „<ph name="PRODUCT_OS_NAME"/>“ atliks, kai naudotojas uždarys įrenginio dangtelį.

          Kai ši politika nenustatyta, atliekamas numatytasis veiksmas – laikinas sustabdymas.

          Jei veiksmas yra laikinas sustabdymas, galima atskirai sukonfigūruoti „<ph name="PRODUCT_OS_NAME"/>“, kad prieš laikinai sustabdant ekranas būtų užrakinamas arba neužrakinamas.</translation>
<translation id="3915395663995367577">URL, siejantis su tarpinio serverio .pac failu</translation>
<translation id="1022361784792428773">Plėtinių, kurių diegti naudotojams turi būti neleidžiama (arba „*“, jei neleidžiama nė vieno), ID</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="7683777542468165012">Dinaminis politikos atnaujinimas</translation>
<translation id="1160939557934457296">Neleisti tęsti veiksmų iš Saugaus naršymo įspėjimo puslapio</translation>
<translation id="8987262643142408725">Neleisti SSL įrašų skaidymo</translation>
<translation id="4529945827292143461">Tinkinkite URL šablonų, kurie visada turėtų būti pateikti prieglobos naršyklės, sąrašą.

          Jei ši politika nebus nustatyta, numatytoji pateikimo programa bus naudojama visose svetainėse, kaip nurodyta politikos „Chrome“ rėmelių pateikimo programos nustatymai“.

          Jei reikia pavyzdinių šablonų, žr. šiuo adresu: http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Pranešti įrenginio operacinės sistemos paleidimo būseną</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="4047207703890139433">Nurodomas įrenginyje naudotinas laikrodžio formatas. Naudotojai gali perrašyti laikrodžio formatą dabartinei sesijai. Tačiau atsijungus vėl nustatoma nurodyta vertė. Jei pateikiama tuščia eilutė, naudojama įrenginio savininko nuostata.</translation>
<translation id="1942957375738056236">Čia galite nurodyti įgaliotojo serverio URL.

          Ši politika pradeda galioti, tik jei pasirinkote rankinius įgaliotojo serverio nustatymus skiltyje „Pasirinkti, kaip nurodyti įgaliotojo serverio nustatymus“.

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

          Jei reikia daugiau parinkčių ir išsamių pavyzdžių, apsilankykite šiuo adresu:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Neleisti montuoti išorinės atminties.

      Kai nustatytas šios politikos nustatymas „True“ (tiesa), išorinė atmintis nepasiekiama failų naršyklėje.

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

      Jei šis nustatymas neleidžiamas arba nesukonfigūruotas, naudotojai įrenginyje gali naudoti visų palaikomų tipų išorinę atmintį.</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="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="1426410128494586442">Taip</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="4962195944157514011">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 (-a) ieško.

          Š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="6009903244351574348">Leisti „<ph name="PRODUCT_FRAME_NAME"/>“ tvarkyti nurodytus turinio tipus.

          Nenustačius šios politikos, numatytoji pateikimo programa bus naudojama visose svetainėse, kaip nurodyta politikos „Chrome“ rėmelio pateikimo programos nustatymai“.</translation>
<translation id="3381968327636295719">Pagal numatytuosius nustatymus naudoti prieglobos naršyklę</translation>
<translation id="3627678165642179114">Įgalinti rašybos tikrinimo žiniatinklio paslaugą arba jos neleisti</translation>
<translation id="6520802717075138474">Importuoti paieškos variklius iš numatytosios naršyklės paleidžiant pirmą kartą</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 laukelyje.

          Į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 laukelyje.</translation>
<translation id="4946368175977216944">Nurodomos žymos, kurios turėtų būti pritaikytos, kai paleidžiama „Chrome“. Nurodytos žymos pritaikomos iki „Chrome“ paleidimo (net ir prisijungimo ekrane).</translation>
<translation id="7447786363267535722">Įgalinamas slaptažodžių išsaugojimas ir išsaugotų slaptažodžių naudojimas „<ph name="PRODUCT_NAME"/>“.

          Jei įgalinsite šį nustatymą, naudotojai galės nustatyti, kad „<ph name="PRODUCT_NAME"/>“ būtų įsimenami slaptažodžiai ir automatiškai pateikiami kitą kartą prisijungiant prie svetainės.

          Jei neleisite šio nustatymo, naudotojai negalės išsaugoti ar naudoti jau išsaugotų slaptažodžių.

          Jei įgalinsite šį nustatymą ar jo neleisite, naudotojai negalės 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="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="6368011194414932347">Konfigūruoti pagrindinio puslapio URL</translation>
<translation id="2877225735001246144">Neleisti CNAME paieškos vykdant „Kerberos“ tapatumo nustatymą</translation>
<translation id="9120299024216374976">Nurodoma įrenginyje naudojama laiko juosta. Naudotojai gali nepaisyti nurodytos dabartinės sesijos laiko juostos. Tačiau atsijungus vėl nustatoma nurodyta laiko juosta. Jei pateikiama netinkama vertė, politika vis tiek suaktyvinama naudojant GMT laiko juostą. Jei pateikta tuščia eilutė, politikos nepaisoma.

      Jei ši politika nenaudojama, bus naudojama šiuo metu suaktyvinta laiko juosta, bet naudotojai gali pakeisti laiko juostą ir šis pakeitimas bus nuolatinis. Todėl vieno naudotojo atliktas pakeitimas turi įtakos prisijungimo ekranui ir visiems kitiems naudotojams.

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

      Vertės formatai atitinka laiko juostas, pateiktas „IANA laiko juostų duomenyse“ (žr. adresu http://lt.wikipedia.org/wiki/List_of_tz_database_time). Daugelis laiko juostų pavadintos pagal „žemyną / didelį_miestą“ arba „vandenyną / didelį_miestą“.</translation>
<translation id="3646859102161347133">Nustatyti ekrano didinimo tipą</translation>
<translation id="3528000905991875314">Įgalinti kitus klaidų puslapius</translation>
<translation id="1283072268083088623">Nurodoma, kurios HTTP autentifikavimo schemos palaikomos „<ph name="PRODUCT_NAME"/>“.

          Galimos vertės: „pagrindinė“, „santrauka“, „ntlm“ ir „derybos“. Kelias vertes atskirkite kableliais.

          Nenustačius šios politikos, bus naudojamos visos keturios schemos.</translation>
<translation id="4914647484900375533">Į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ų „Chrome“ versijų.</translation>
<translation id="6114416803310251055">nepatvirtinta</translation>
<translation id="8493645415242333585">Neleisti išsaugoti naršyklės istorijos</translation>
<translation id="5319306267766543020">Konfigūruokite 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="2747783890942882652">Konfigūruojamas reikiamas prieglobos domeno pavadinimas, kuris bus nustatytas nuotolinės prieigos priegloboms, ir neleidžiama naudotojams jo keisti.

          Jei šis nustatymas įgalintas, prieglobas galima bendrinti tik naudojant nurodytu domeno pavadinimu užregistruotas paskyras.

          Jei šis nustatymas neleidžiamas arba nenustatytas, tada prieglobas galima bendrinti naudojant bet kurią paskyrą.</translation>
<translation id="6417861582779909667">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose neleidžiama nustatyti slapukų, sąrašą.

          Nenustačius šios politikos, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „Numatytasis slapukų nustatymas“ (jei nustatyta) ar naudotojo asmeninės konfigūracijos.</translation>
<translation id="5457296720557564923">Leidžiama puslapiams pasiekti „JavaScript“ atminties naudojimo statistiką. Dėl šio nustatymo tinklalapis gali pasiekti kūrėjo įrankių profilių skydo atminties statistiką.</translation>
<translation id="5776485039795852974">Paklausti kaskart, kai svetainėje norima rodyti darbalaukio pranešimus</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="6786747875388722282">Plėtiniai</translation>
<translation id="8947415621777543415">Pranešti įrenginio vietą</translation>
<translation id="1655229863189977773">Nustatyti disko talpyklos dydį baitais</translation>
<translation id="6376842084200599664">Leidžiama nurodyti plėtinių, kurie bus įdiegti be naudotojo veiksmų, sąrašą.

          Kiekvienas sąrašo elementas yra eilutė, kurioje pateiktas plėtinio ID ir naujinio URL, atskirti kabliataškiu (<ph name="SEMICOLON"/>). Plėtinio ID yra 32 raidžių eilutė, randama, pvz., <ph name="CHROME_EXTENSIONS_LINK"/>, kai įjungtas kūrėjo režimas. Naujinio URL turėtų nurodyti į naujinio aprašo XML dokumentą, kaip aprašyta šiuo adresu: <ph name="LINK_TO_EXTENSION_DOC1"/>. Atminkite, kad naujinio URL, nustatytas šioje politikoje, naudojamas tik atliekant pirminį diegimą. Kiti plėtinio naujiniai naudos naujinio URL, kuris nurodytas plėtinio apraše.

          Kiekviename elemente „<ph name="PRODUCT_NAME"/>“ pateiks plėtinį, nurodytą naujinio paslaugoje pateiktu naujinio URL esančiu plėtinio ID, ir jį įdiegs.

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

          Naudotojai negalės pašalinti šioje politikoje nurodytų plėtinių. Jei pašalinsite plėtinį iš šio sąrašo, „<ph name="PRODUCT_NAME"/>“ jį automatiškai pašalins. Šiame sąraše nurodyti plėtiniai taip pat automatiškai įtraukiami į baltąjį diegimo sąrašą. „ExtensionsInstallBlacklist“ neturi jiems įtakos.

          Jei ši politika nenustatyta, naudotojas gali pašalinti bet kurį „<ph name="PRODUCT_NAME"/>“ plėtinį.</translation>
<translation id="6899705656741990703">Automatiškai aptikti tarpinio serverio nustatymus</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="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="3236046242843493070">URL šablonai, kuriuos naudojant galima įdiegti plėtinį, programą ir naudotojo scenarijų iš</translation>
<translation id="2498238926436517902">Visada automatiškai paslėpti lentyną</translation>
<translation id="253135976343875019">Neveikos įspėjimo delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="6997592395211691850">Ar internetinės OCSP / CRL patikros reikalingos vietiniams patikimiems prieraišams</translation>
<translation id="152657506688053119">Alternatyvių numatytojo paieškos teikėjo URL sąrašas</translation>
<translation id="8992176907758534924">Neleisti jokioje svetainėje rodyti vaizdų</translation>
<translation id="262740370354162807">Įgalinti dokumentų pateikimą „<ph name="CLOUD_PRINT_NAME"/>“</translation>
<translation id="7717938661004793600">Konfigūruokite „<ph name="PRODUCT_OS_NAME"/>“ pasiekiamumo funkcijas.</translation>
<translation id="5182055907976889880">Konfigūruokite „Google“ diską „<ph name="PRODUCT_OS_NAME"/>“.</translation>
<translation id="8704831857353097849">Neleidžiamų papildinių sąrašas</translation>
<translation id="8391419598427733574">Pranešti užregistruotų įrenginių OS ir programinės aparatinės įrangos versiją.

      Jei šis nustatymas nustatytas į „Taip“, užregistruoti įrenginiai periodiškai praneš OS ir programinės aparatinės įrangos versiją. Jei nustatymas nenustatytas ar nustatytas į „Ne“, versijų informacija nebus pranešama.</translation>
<translation id="467449052039111439">Atidaryti URL sąrašą</translation>
<translation id="5883015257301027298">Numatytasis slapukų nustatymas</translation>
<translation id="5017500084427291117">Blokuojama prieiga prie sąraše pateiktų URL.

      Įgalinus šią politiką, naudotojas negali įkelti tinklalapių, kurie nurodyti juodajame URL sąraše.

      URL formatas – „scheme://host:port/path“.
      Pasirenkama schema gali būti HTTP, HTTPS ar FTP. Tik ši schema blokuojama. Jei schema nenurodyta, blokuojamos visos schemos.
      Priegloba – tai prieglobos serverio pavadinimas arba IP adresas. Prieglobos serverio pavadinimo padomeniai taip pat blokuojami. Jei nenorite, kad padomeniai būtų blokuojami, prieš prieglobos serverio pavadinimą įtraukite „.“. Įvedus specialų prieglobos serverio pavadinimą „*“, blokuojami visi domenai.
      Pasirenkamas prievadas – tai galiojantis prievado numeris nuo 1 iki 65 535. Jei numeris nenurodomas, blokuojami visi prievadai.
      Jei nurodomas pasirenkamas kelias, blokuojami tik keliai su tokiu kodu.

      Išimtis galima nurodyti URL baltojo sąrašo politikoje. Į politiką galima įtraukti iki 1 000 įrašų – į kitus nebus atsižvelgiama.

      Jei ši politika nenustatoma, joks URL nebus įtrauktas į juodąjį sąrašą naršyklėje.</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="8955719471735800169">Į pradžią</translation>
<translation id="2534584045044686957">Konfigūruojamas talpyklos dydis, kurią „<ph name="PRODUCT_NAME"/>“ naudos talpykloje esantiems medijos failams saugoti diske.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME"/>“ bus naudojama nurodyto dydžio talpykla, neatsižvelgiant į tai, ar naudotojas (-a) nurodė žymą „--media-cache-size“ (medijos talpyklos dydis).

      Jei šios politikos vertė 0, bus naudojama numatytojo dydžio talpykla, bet naudotojas (-a) negalės jos pakeisti.

      Nenustačius šios politikos bus naudojamas numatytasis dydis ir naudotojas (-a) galės pakeisti jį naudodamas (-a) žymą „--media-cache-size“ (medijos talpyklos dydis).</translation>
<translation id="3723474915949495925">Nurodomas papildinių, kuriuos naudotojas (-a) gali įgalinti arba kurių gali neleisti „<ph name="PRODUCT_NAME"/>“, sąrašas.

      Kad įrašai atitiktų atsitiktinių simbolių sekas, galima naudoti pakaitos simbolius „*“ ir „?“. „*“ atitinka atsitiktinį simbolių skaičių, o „?“ nurodo vieną pasirinktinį simbolį, t. y. atitinka nulio arba vieneto simbolį. Kaitos simbolis yra „\“, todėl, kad simboliai atitiktų faktinius „*“, „?“ arba „\“ simbolius, prieš juos galite įvesti „\“.

      Jei įgalinate šį nustatymą, nurodytas papildinių sąrašas gali būti naudojamas „<ph name="PRODUCT_NAME"/>“. Naudotojai gali įgalinti juos ar jų neleisti skiltyje „about:plugins“, net jei papildinys atitinka ir šabloną skiltyje „DisabledPlugins“ (neleidžiami papildiniai). Be to, naudotojai gali įgalinti papildinius, kurie neatitinka jokių šablonų skiltyse „DisabledPlugins“ (neleidžiami papildiniai), „DisabledPluginsExceptions“ (neleidžiamų papildinių išimtys) ir „EnabledPlugins“ (įgalinti papildiniai), arba jų neleisti.

      Ši politika skirta leisti griežtai įtraukti papildinius į juodąjį sąrašą, kai „DisabledPlugins“ (neleidžiami papildiniai) sąraše pateikiama pakaitos simbolių įrašų, pvz., neleisti visų papildinių „*“ arba neleisti visų „Java“ papildinių „*Java*“, bet administratorius nori įgalinti tam tikrą versiją, pvz., „IcedTea Java 2.3“. Šią konkrečią versiją galima nurodyti šioje politikoje.

      Nenustačius šios politikos, bet koks papildinys, kuris atitinka šablonus skiltyje „DisabledPlugins“ (neleidžiami papildiniai), bus užrakintas neleidžiamas ir naudotojas (-a) negalės jo įgalinti.</translation>
<translation id="546726650689747237">Ekrano pritemdymo delsa, kai naudojama kintamosios srovės energija</translation>
<translation id="4988291787868618635">Veiksmas, kuris bus atliktas, kai bus pasiektas neveikos delsos laikas</translation>
<translation id="5316405756476735914">Leidžiama nustatyti, ar svetainėse leidžiama nustatyti vietinius duomenis. Vietinių duomenų nustatymas gali būti leidžiamas arba draudžiamas visose svetainėse.

          Nenustačius šios politikos bus naudojama „Leisti slapukus“ ir naudotojas (-a) galės tai pakeisti.</translation>
<translation id="4250680216510889253">Ne</translation>
<translation id="1522425503138261032">Leisti svetainėse stebėti naudotojo buvimo vietą</translation>
<translation id="6467433935902485842">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose neleidžiama paleisti papildinių, sąrašą.

          Nenustačius šios politikos, visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „Numatytasis papildinių nustatymas“ (jei nustatyta) ar naudotojo asmeninės konfigūracijos.</translation>
<translation id="4423597592074154136">Pačiam nurodyti tarpinio serverio nustatymus</translation>
<translation id="209586405398070749">Stabilus kanalas</translation>
<translation id="8170878842291747619">Įgalinama integruota „Google“ vertėjo paslauga „<ph name="PRODUCT_NAME"/>“.

      Jei įgalinsite šį nustatymą, „<ph name="PRODUCT_NAME"/>“ bus rodoma integruota įrankių juosta, kurioje siūloma naudotojui išversti puslapį, kai tai galima.

      Jei neleisite šio nustatymo, naudotojai niekada nematys vertimo juostos.

      Jei įgalinsite šį nustatymą arba jo neleisite, naudotojai negalės jo pakeisti ar panaikinti „<ph name="PRODUCT_NAME"/>“.

      Nenustačius šio nustatymo, naudotojas (-a) galės nuspręsti, ar naudoti šią funkciją.</translation>
<translation id="9035964157729712237">Į juodąjį sąrašą neįtrauktinų plėtinių ID</translation>
<translation id="8244525275280476362">Maksimali gavimo delsa atšaukus politiką</translation>
<translation id="8587229956764455752">Leisti kurti naujų naudotojų paskyras</translation>
<translation id="7417972229667085380">Procentas, pagal kurį bus keičiamas neveikos delsos mastelis dirbant pristatymo režimu (nebenaudojama)</translation>
<translation id="3964909636571393861">Suteikiama prieiga prie URL sąrašo</translation>
<translation id="3450318623141983471">Pranešti įrenginio „Dev“ perjungimo būseną paleidžiant.

      Jei ši politika nenustatyta, ar nustatyta į „Ne“, nebus pranešta apie „Dev“ perjungimo būseną.</translation>
<translation id="1811270320106005269">Įgalinamas užraktas, kai „<ph name="PRODUCT_OS_NAME"/>“ įrenginiai yra neveikos būsenos arba sustabdyti.

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

      Jei neleisite šio nustatymo, naudotojų nebus prašoma pateikti slaptažodžio norint pažadinti įrenginį iš miego.

      Jei įgalinsite šį nustatymą arba jo neleisite, naudotojai negalės jo pakeisti ar panaikinti.

      Nenustačius politikos naudotojas galės pasirinkti, ar nori, kad būtų prašoma slaptažodžio atrakinant įrenginį.</translation>
<translation id="6022948604095165524">Veiksmai paleidžiant</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="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="1679420586049708690">Vieša automatinio prisijungimo sesija</translation>
<translation id="7625444193696794922">Nurodomas leidimo kanalas, su kuriuo šis įrenginys turėtų būti sujungtas.</translation>
<translation id="2552966063069741410">Laiko juosta</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="2529700525201305165">Riboti, kuriems naudotojams leidžiama prisijungti prie „<ph name="PRODUCT_NAME"/>“</translation>
<translation id="8971221018777092728">Viešos sesijos automatinio prisijungimo laikmatis</translation>
<translation id="8285435910062771358">Viso ekrano didinimas įgalintas</translation>
<translation id="5141670636904227950">Nustatyti numatytąjį ekrano didinimo tipą, kuris įgalintas prisijungimo ekrane</translation>
<translation id="3864818549971490907">Numatytasis papildinių nustatymas</translation>
<translation id="7151201297958662315">Nustatoma, ar „<ph name="PRODUCT_NAME"/>“ procesas pradedamas prisijungiant prie OS ir toliau vykdomas, kai paskutinis naršyklės langas uždaromas, leidžiant foninėms programoms likti aktyvioms. Vykdant fono procesą sistemos dėkle pateikiama piktograma ir jį visada galima čia uždaryti.

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

      Jei ši politika nustatyta į „False“ (netiesa), fono režimas neleidžiamas ir naudotojas negali jo valdyti naršyklės nustatymuose.

      Nenustačius šios politikos fono režimas iš pradžių neleidžiamas ir jį gali valdyti naudotojas naršyklės nustatymuose.</translation>
<translation id="4320376026953250541">„Microsoft Windows XP“ SP2 arba naujesnė versija</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="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="6394350458541421998">Ši politika nebenaudojama 29 ir naujesnėse „<ph name="PRODUCT_OS_NAME"/>“ versijose. Vietoje jos naudokite politiką „PresentationScreenDimDelayScale“.</translation>
<translation id="5770738360657678870">Kuriamas kanalas (gali būti nestabilus)</translation>
<translation id="2959898425599642200">Tarpinio serverio apėjimo 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="1098794473340446990">Pranešti įrenginio veiklos laiką.

      Jei šis nustatymas nustatytas į „Taip“, užregistruoti įrenginiai praneš to įrenginio naudotojo veiklos trukmę. Jei nustatymas nenustatytas ar nustatytas į „Ne“, įrenginio veiklos laikas nebus įrašomas ar pranešamas.</translation>
<translation id="7937766917976512374">Leisti arba blokuoti vaizdo įrašo fiksavimą</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="8818646462962777576">Šiame sąraše pateikti šablonai bus atitaikomi pagal
      užklausą pateikiančio URL kilmę. Jei bus rasta atitiktis, prieiga prie garsą
      fiksuojančių įrenginių bus suteikta be paraginimo.

      PASTABA: šiuo metu ši politika palaikoma, tik jei ji vykdoma viešojo terminalo režimu.</translation>
<translation id="489803897780524242">Parametras, valdantis numatytojo paieškos teikėjo paieškos termino paskirties vietą</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="6401669939808766804">Atjungti naudotoją</translation>
<translation id="4826326557828204741">Veiksmas, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas, veikiant iš akumuliatoriaus energijos</translation>
<translation id="7912255076272890813">Konfigūruoti leidžiamus programų / plėtinių tipus</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="4163644371169597382">Įmonės įrenginių IT administratoriai gali naudoti šią žymą, kad valdytų, ar leisti naudotojams pasinaudoti pasiūlymais vykdant „Chrome“ OS registraciją.

      Jei ši politika nustatyta kaip galiojanti arba nėra nustatyta, naudotojai galės pasinaudoti pasiūlymais vykdydami „Chrome“ OS registraciją.

      Jei ši politika negalioja, naudotojas negalės pasinaudoti pasiūlymais.</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="6177482277304066047">Nustatoma tikslinė automatinių naujinių versija.

      Nurodomas tikslinės versijos, pagal kurią turėtų būti atnaujintas „<ph name="PRODUCT_OS_NAME"/>“, kodas. Jei įrenginyje vykdoma ankstesnė nei nurodyto kodo versija, naudojant nurodytą kodą atnaujinama į naujausią versiją. Jei įrenginyje jau veikia naujesnė versija, tai neturi jokios įtakos (t. y. negrąžinama jokia ankstesnė versija) ir įrenginyje išlieka dabartinė versija. Kodo formatas veikia pagal komponentus, kaip nurodyta šiame pavyzdyje:

      &quot;&quot; (arba nesukonfigūruota): atnaujinti į naujausią pasiekiamą versiją.
      &quot;1412.&quot;: atnaujinti į šalutinę 1412 versiją (pvz., 1412.24.34 arba 1412.60.2)
      &quot;1412.2.&quot;: atnaujinti į šalutinę 1412.2 versiją (pvz., 1412.2.34 arba 1412.2.2)
      &quot;1412.24.34&quot;: atnaujinti tik į šią konkrečią versiją</translation>
<translation id="8102913158860568230">Numatytasis medijos srautinio perdavimo nustatymas</translation>
<translation id="6641981670621198190">Neleisti palaikyti trimatės grafikos API</translation>
<translation id="7929480864713075819">Puslapyje įgalinti ataskaitų teikimo atminties informaciją (JS masyvo dydžio)</translation>
<translation id="5703863730741917647">Nurodykite veiksmą, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas.

          Atminkite, kad ši politika nebenaudojama ir ateityje bus pašalinta.

          Šioje politikoje pateikiama atsarginė konkretesnių <ph name="IDLEACTIONAC_POLICY_NAME"/> ir <ph name="IDLEACTIONBATTERY_POLICY_NAME"/> politikos nuostatų vertė. Jei ši politika nustatyta, jos vertė naudojama, jei nenustatyta atitinkama konkretesnė politika.

          Kai ši politika nenustatyta, konkretesnės politikos veikimas lieka nepakitęs.</translation>
<translation id="5997543603646547632">Naudoti 24 val. laikrodį pagal numatytuosius nustatymus</translation>
<translation id="7003746348783715221">„<ph name="PRODUCT_NAME"/>“ nuostatos</translation>
<translation id="4723829699367336876">Įgalinti užkardos apėjimą iš nuotolinės prieigos kliento programos</translation>
<translation id="6367755442345892511">Ar naudotojui (-ai) turėtų būti leidžiama konfigūruoti paleidimo kanalą</translation>
<translation id="4035570660718398959">Leisti naudotojams pasinaudoti pasiūlymais atliekant „Chrome“ OS registraciją.</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="9096086085182305205">Tapatumo nustatymo serverio baltasis sąrašas</translation>
<translation id="4980301635509504364">Leisti fiksavimą arba jo neleisti.

      Jei ši politika įgalinta arba nesukonfigūruota (numatytasis nustatymas),
      naudotojas bus paragintas suteikti prieigą fiksavimo funkcijai, išskyrus
      sąraše „VideoCaptureAllowedUrls“ sukonfigūruotiems URL, kuriems prieiga bus suteikta be paraginimo.

      Kai ši politika išjungta, naudotojas niekada nebus raginamas, o vaizdo
      fiksavimo funkcija bus pasiekiama sąraše „VideoCaptureAllowedUrls“ sukonfigūruotiems URL.

      Ši politika turi įtakos visų tipų vaizdo įvestims, ne tik įdiegtam fotoaparatui.</translation>
<translation id="7063895219334505671">Leisti iššokančiuosius langus šiose svetainėse</translation>
<translation id="4052765007567912447">Valdoma, ar naudotojas (-a) gali rodyti aiškiai parašytus slaptažodžius slaptažodžių tvarkytuvėje.

          Jei neleisite šio nustatymo, slaptažodžių tvarkytuvės lange nebus leidžiama rodyti aiškiai parašytų išsaugotų slaptažodžių.

          Jei įgalinsite šią politiką arba jos nenustatysite, naudotojai galės peržiūrėti aiškiai parašytus slaptažodžius slaptažodžių tvarkytuvėje.</translation>
<translation id="5213629107215526747">URL, kuriems bus suteikta prieiga prie vaizdo fiksavimo įrenginių be paraginimo.</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="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="2824715612115726353">Įgalinti inkognito režimą</translation>
<translation id="1057535219415338480">Įgalinamas tinklo numatymas „<ph name="PRODUCT_NAME"/>“ ir naudotojams neleidžiama keisti šio nustatymo.

      Pagal šią politiką valdomas ne tik išankstinis DNS pateikimas, bet ir išankstinis TCP ir SSL ryšys bei tinklalapių pateikimas. Politikos pavadinime išankstinis DNS pateikimas įtrauktas dėl ankstesnių priežasčių.

      Jei įgalinsite ar išjungsite šį nustatymą, „<ph name="PRODUCT_NAME"/>“ naudotojai negalės jo pakeisti ar nepaisyti.

      Jei ši politika nenustatoma, ji bus įgalinta, bet naudotojas galės tai pakeisti.</translation>
<translation id="4541530620466526913">Vietinės įrenginio paskyros</translation>
<translation id="5815129011704381141">Po atnaujinimo automatiškai įkelti operacinę sistemą iš naujo</translation>
<translation id="1757688868319862958">„<ph name="PRODUCT_NAME"/>“ leidžiama paleisti papildinius, kuriuos naudojant reikalinga prieigos teisė. Jei įgalinsite šį nustatymą, visada bus paleidžiami nepasenę papildiniai. Jei šis nustatymas neleidžiamas arba nenustatytas, naudotojų bus prašoma suteikti leidimą paleisti papildinius, kuriuos naudojant reikalinga prieigos teisė. Šiais papildiniais gali būti pažeista sauga.</translation>
<translation id="6392973646875039351">Į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 sukonfigūruoti automatinio pildymo profilius ir savo nuožiūra įjungti arba išjungti automatinio pildymo funkciją.</translation>
<translation id="6157537876488211233">Kableliais atskirtų tarpinio serverio apėjimo taisyklių sąrašas</translation>
<translation id="7788511847830146438">Vienam profiliui</translation>
<translation id="2516525961735516234">Nurodoma, ar vaizdo įrašo veikla paveikia energijos valdymą.

          Jei politika yra galiojanti ar ji nenustatyta, laikoma, kad naudotojas neatlieka jokių veiksmų, kai paleistas vaizdo įrašas. Taip neleidžiama pasiekti neveikos delsos, ekrano pritemdymo delsos, ekrano išjungimo delsos ir ekrano užrakto delsos bei neleidžiama atlikti atitinkamų veiksmų.

          Jei ši politika negalioja, nepaisoma vaizdo įrašo veiklos ir naudotojas laikomas neveikiu.</translation>
<translation id="3965339130942650562">Skirtasis laikas, kol vykdomas neveikos būsenos naudotojo atjungimas</translation>
<translation id="5814301096961727113">Nustatyti numatytąją atsiliepimų žodžiu prisijungimo ekrane būklę</translation>
<translation id="9084985621503260744">Nurodykite, ar vaizdo įrašo veikla paveikia energijos valdymą</translation>
<translation id="7091198954851103976">Visada paleidžiami papildiniai, kuriuos naudojant reikalinga prieigos teisė</translation>
<translation id="1708496595873025510">Nustatykite variantų pirminės reikšmės pateikimo apribojimą</translation>
<translation id="8870318296973696995">Pagrindinis puslapis</translation>
<translation id="1240643596769627465">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ų.

          Į šią politiką atsižvelgiama, tik jei įgalinta politika „Numatytasis paieškos teikėjas įgalintas“.</translation>
<translation id="6693751878507293182">Jei įgalinsite šį nustatymą, automatinė paieška ir trūkstamų papildinių diegimas bus neleidžiami „<ph name="PRODUCT_NAME"/>“.

      Neleidus šios parinkties ar jos nenustačius papildinių paieškos priemonė bus aktyvi.</translation>
<translation id="2650049181907741121">Veiksmas, kuris bus atliktas, kai naudotojas uždarys dangtelį</translation>
<translation id="7880891067740158163">Leidžiama nurodyti URL šablonų, nurodančių svetaines, kurioms „<ph name="PRODUCT_NAME"/>“ turėtų automatiškai parinkti programų sertifikatus, jei svetainėje pateikiama sertifikato užklausa, sąrašą.

          Nenustačius šios politikos automatinis parinkimas neatliekamas jokioje svetainėje.</translation>
<translation id="3866249974567520381">Aprašas</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="2236488539271255289">Neleisti nė vienoje svetainėje nustatyti vietinių duomenų</translation>
<translation id="4467952432486360968">Blokuoti trečiosios šalies slapukus</translation>
<translation id="2041396837791669429">Blokuoti prieigą prie svetainių, neesančių turinio paketuose.</translation>
<translation id="1305864769064309495">Žodynų susiejimo URL, skirti loginiam bandymui, nurodantys, ar prieiga prie prieglobos turėtų būti leidžiama (tiesa) arba blokuojama (netiesa).

Ši politika skirta naudoti tik „Chrome“ viduje.</translation>
<translation id="5586942249556966598">Nieko nedaryti</translation>
<translation id="131353325527891113">Rodyti naudotojų vardus prisijungimo ekrane</translation>
<translation id="5317965872570843334">Įgalinamas STUN ir perdavimo 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="5365946944967967336">Rodyti įrankių juostoje pagrindinio puslapio mygtuką</translation>
<translation id="3709266154059827597">Konfigūruoti plėtinių diegimo juodąjį sąrašą</translation>
<translation id="8451988835943702790">Naudoti naujo skirtuko puslapį kaip pagrindinį puslapį</translation>
<translation id="8469342921412620373">Įgalinamas numatytojo paieškos teikėjo naudojimas.

          Jei įgalinsite šį nustatymą, naudotojui į „Omnibox“ vedant tekstą, kuris nėra URL, bus vykdoma numatytoji paieška.

          Nustatydami likusias numatytosios paieškos politikos parinktis galite nurodyti numatytąjį naudotiną paieškos teikėją. Jei jų nenustatysite, naudotojas (-a) galės pasirinkti numatytąjį teikėją.

          Jei šio nustatymo neleisite, naudotojui į „Omnibox“ vedant tekstą, kuris nėra URL, nebus vykdoma jokia paieška.

          Jei šį nustatymą įgalinsite arba jo neleisite, naudotojai negalės jo pakeisti ar panaikinti „<ph name="PRODUCT_NAME"/>“.

          Nenustačius šios politikos įgalinamas numatytasis paieškos teikėjas ir naudotojas (-a) gali nustatyti paieškos teikėjų sąrašą.</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="2633084400146331575">Įgalinti žodinius atsiliepimus</translation>
<translation id="7712008868843631413">Įgalinti prižiūrimus naudotojus.</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="2411919772666155530">Blokuoti pranešimus šiose svetainėse</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="4869787217450099946">Nurodoma, ar ekrano pažadinimo užraktai leidžiami. Ekrano pažadinimo užraktų užklausą gali pateikti plėtiniai, naudodami energijos tvarkymo plėtinio API.

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

          Jei ši politika nustatyta kaip „Netiesa“, ekrano pažadinimo užraktų užklausų nepaisoma.</translation>
<translation id="467236746355332046">Palaikomos funkcijos:</translation>
<translation id="7632724434767231364">GSSAPI bibliotekos pavadinimas</translation>
<translation id="3038323923255997294">Uždarius „<ph name="PRODUCT_NAME"/>“ toliau leisti fonines programas</translation>
<translation id="4652284479838524692">Įgalinti nuotolinį įrenginio patvirtinimą.</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="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="6244210204546589761">Paleidžiant atidaromi URL</translation>
<translation id="7468416082528382842">„Windows“ registro vieta:</translation>
<translation id="1808715480127969042">Blokuoti slapukus šiose svetainėse</translation>
<translation id="1908884158811109790">Neleidžiama „Google“ disko pasiekti „Chrome“ OS programoje „Failai“ naudojant mobilųjį ryšį</translation>
<translation id="7340034977315324840">Pranešti įrenginio veiklos laiką</translation>
<translation id="4928632305180102854">Valdoma, ar „<ph name="PRODUCT_OS_NAME"/>“ leidžiama kurti naujų naudotojų paskyrų. Jei ši politika nustatyta į „false“ (netiesa), paskyros dar neturintys naudotojai negali prisijungti.

      Jei ši politika nustatyta į „true“ (tiesa) arba nesukonfigūruota, leidžiama sukurti naujų naudotojų paskyrų, jei pagal „<ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/>“ leidžiama naudotojui prisijungti.</translation>
<translation id="4389091865841123886">Konfigūruojamas nuotolinis patvirtinimas naudojant TPM mechanizmą.</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="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="1349276916170108723">Neleidžiamas „Google“ disko sinchronizavimas „Chrome“ OS programoje „Failai“ naudojant mobilųjį ryšį, kai nustatyta kaip „Tiesa“. Tokiu atveju duomenys į „Google“ diską neįkeliami.

          Jei nenustatyta arba nustatyta kaip „Netiesa“, naudotojai galės perkelti failus į „Google“ diską.</translation>
<translation id="1964634611280150550">Inkognito režimas neleidžiamas</translation>
<translation id="5971128524642832825">Neleidžiamas Diskas „Chrome“ OS programoje „Failai“</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="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="538108065117008131">Leisti „<ph name="PRODUCT_FRAME_NAME"/>“ naudoti šio tipo turinį.</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="243972079416668391">Nurodykite veiksmą, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas, kai veikiama iš kintamosios srovės šaltinio.

          Kai ši politika nustatyta, ji nurodo veiksmą, kurį „<ph name="PRODUCT_OS_NAME"/>“ atlieka, kai naudotojas lieka neaktyvus neaktyvumo delsos nurodytą laikotarpį, kurį galima atskirai konfigūruoti.

          Kai ši politika nenustatyta, atliekamas nustatytasis veiksmas – laikinas sustabdymas.

          Jei veiksmas yra laikinas sustabdymas, „<ph name="PRODUCT_OS_NAME"/>“ gali būti atskirai sukonfigūruota užrakinti ekraną prieš laikiną sustabdymą arba jo neužrakinti.</translation>
<translation id="7750991880413385988">Naujo skirtuko puslapio atidarymas</translation>
<translation id="741903087521737762">Leidžiama nurodyti veiksmus, kurie turi būti atliekami paleidus naršyklę.

          Jei pasirinksite „Atidaryti naujo skirtuko puslapį“, paleidus „<ph name="PRODUCT_NAME"/>“ visada bus atidarytas naujo skirtuko puslapis.

          Jei pasirinksite „Atkurti paskutinę sesiją“, bus iš naujo atidaryti URL, kurie buvo atidaryti prieš paskutinį kartą uždarant „<ph name="PRODUCT_NAME"/>“, ir bus atkurta palikta naršymo sesija.
          Naudojant šią parinktį neleidžiami kai kurie nustatymai, kurie priklauso nuo sesijų arba kurie atlieka su išėjimu susijusius veiksmus (pvz., naršymo duomenų valymas išeinant ar tik per sesiją naudojami slapukai).

          Jei pasirinksite „Atidaryti URL sąrašą“, naudotojui paleidus „<ph name="PRODUCT_NAME"/>“ bus atidarytas sąrašas „URL, kuriuos reikia atidaryti paleidžiant“.

          Jei įgalinsite šį nustatymą, paleidę „<ph name="PRODUCT_NAME"/>“ naudotojai negalės jo pakeisti arba nepaisyti.

          Jei šio nustatymo neleisite, jis bus toks, kaip nesukonfigūruotas. Paleidęs „<ph name="PRODUCT_NAME"/>“ naudotojas vis tiek galės jį pakeisti.</translation>
<translation id="8161570238552664224">Leisti paleisti garsą.

      Jei politikos vertė nustatyta kaip „false“, garso išvestis nebus pasiekiama įrenginyje, kai naudotojas bus prisijungęs.

      Ši politika turi įtakos visiems garso išvesties tipams, ne tik įtaisytiesiems garsiakalbiams. Garso pasiekiamumo funkcijos taip pat apibrėžtos šioje politikoje. Neįgalinkite šios politikos, jei naudotojui reikalingas ekrano skaitytuvas.

      Jei šio nustatymo vertė yra „true“ arba jis nėra sukonfigūruotas, naudotojai gali matyti visas palaikomas garso išvestis įrenginyje.</translation>
<translation id="5761030451068906335">Bus sukonfigūruoti įgaliotojo serverio nustatymai, skirti „<ph name="PRODUCT_NAME"/>“.

      Ši politika dar neparuošta naudoti; nenaudokite jos.</translation>
<translation id="3006443857675504368">Rodyti „<ph name="PRODUCT_OS_NAME"/>“ pasiekiamumo parinktis sistemos meniu.

          Jei ši politika yra galiojanti, pasiekiamumo parinktys visada rodomos sistemos dėklo meniu.

          Jei ši politika negalioja, pasiekiamumo parinktys niekada nebus rodomos sistemos dėklo meniu.

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

          Jei ši politika nenustatoma, pasiekiamumo parinktys nebus rodomos sistemos dėklo meniu, bet naudotojas gali nustatyti, kad jos būtų rodomos apsilankęs „Nustatymų“ puslapyje.</translation>
<translation id="8344454543174932833">Importuoti žymes iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="1019101089073227242">Nustatyti naudotojo duomenų katalogą</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="2988031052053447965">Slėpti „Chrome“ internetinės parduotuvės programą ir poraštės nuorodą Naujo skirtuko puslapyje ir „Chrome“ OS 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="8401282319420373133">Plėtiniams leidžiama naudoti nuotolinio patvirtinimo API.</translation>
<translation id="5085647276663819155">Neleisti spaudinio peržiūros</translation>
<translation id="8672321184841719703">Taikomo automatinio naujinio versija</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="6699880231565102694">Įgalinti nuotolinės prieigos prieglobų autentifikavimą dviem veiksniais</translation>
<translation id="2030905906517501646">Numatytojo paieškos teikėjo raktinis žodis</translation>
<translation id="3072045631333522102">Naudotina prisijungimo ekrano užsklanda dirbant mažmeninės prekybos režimu</translation>
<translation id="4550478922814283243">Įgalinti autentifikavimą be PIN kodo arba jo neleisti</translation>
<translation id="7712109699186360774">Klausti kiekvieną kartą, kai svetainė nori pasiekti kamerą ir (arba) mikrofoną</translation>
<translation id="350797926066071931">Įgalinti vertimą</translation>
<translation id="3711895659073496551">Laikinai sustabdyti</translation>
<translation id="4010738624545340900">Leisti iškviesti failų pasirinkimo dialogo langus</translation>
<translation id="4518251772179446575">Paklausti kaskart, kai svetainėje bus norima stebėti naudotojo buvimo vietą</translation>
<translation id="402759845255257575">Neleisti jokioje svetainėje paleisti „JavaScript“</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="706669471845501145">Leisti svetainėse rodyti darbalaukio pranešimus</translation>
<translation id="7529144158022474049">Automatiškai atnaujinamas sklaidos veiksnys</translation>
<translation id="2188979373208322108">Įgalinama žymių juosta „<ph name="PRODUCT_NAME"/>“.

      Jei įgalinsite šį nustatymą, „<ph name="PRODUCT_NAME"/>“ bus rodoma žymių juosta.

      Jei neleisite šio nustatymo, naudotojai niekada nematys žymių juostos.

      Jei įgalinsite šį nustatymą ar jo neleisite, naudotojai negalės jo pakeisti ar panaikinti „<ph name="PRODUCT_NAME"/>“.

      Nenustačius šio nustatymo, naudotojas (-a) gali nuspręsti, ar naudoti šią funkciją.</translation>
<translation id="5475361623548884387">Įgalinti spausdinimą</translation>
<translation id="7287359148642300270">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, „Chrome“ bandys nustatyti, ar serveris yra intranete ir tik tada atsakys į IWA užklausas. Jei serveris aptinkamas internete, „Chrome“ nepaisys jo siunčiamų IWA užklausų.</translation>
<translation id="3653237928288822292">Numatytojo paieškos teikėjo piktograma</translation>
<translation id="2872961005593481000">Stabdyti</translation>
<translation id="4445684791305970001">Neleidžiami kūrėjo įrankiai ir „JavaScript“ konsolė.

      Jei įgalinsite šį nustatymą, daugiau nebus galima pasiekti kūrėjo įrankių ir patikrinti svetainės elementų. Bus neleidžiami visi spartieji klavišai ir meniu ar kontekstinių meniu įrašai, skirti kūrėjo įrankiams ar „JavaScript“ konsolei atidaryti.

      Neleidus šios parinkties ar jos nenustačius, naudotojas (-a) galės naudoti kūrėjo įrankius ir „JavaScript“ konsolę.</translation>
<translation id="9203071022800375458">Neleisti kurti ekrano kopijų.

      Jei įgalinta, ekrano kopijų negalima kurti naudojant sparčiuosius klavišus ar plėtinio API.

      Jei neleidžiama ar nenurodyta, leidžiama kurti ekrano kopijas.</translation>
<translation id="4632343302005518762">Leisti „<ph name="PRODUCT_FRAME_NAME"/>“ naudoti nurodytų tipų turinį</translation>
<translation id="13356285923490863">Politikos pavadinimas</translation>
<translation id="557658534286111200">Įgalinamas žymių redagavimas arba neleidžiama redaguoti žymių</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="2386362615870139244">Leisti ekrano pažadinimo užraktus</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="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="389421284571827139">Leidžiama nurodyti „<ph name="PRODUCT_NAME"/>“ naudojamą įgaliotąjį serverį ir neleidžiama naudotojams keisti įgaliotojo serverio nustatymų.

      Jei pasirinksite niekada nenaudoti įgaliotojo serverio ir visada jungtis tiesiogiai, visų kitų parinkčių bus nepaisoma.

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

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

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

      Nenustačius šios politikos, naudotojai galės patys pasirinkti įgaliotojo serverio nustatymus.</translation>
<translation id="681446116407619279">Palaikomos tapatumo nustatymo schemos</translation>
<translation id="4027608872760987929">Įgalinti numatytąjį paieškos teikėją</translation>
<translation id="2223598546285729819">Numatytasis pranešimų nustatymas</translation>
<translation id="6158324314836466367">Įmonės internetinės parduotuvės pavadinimas (nebenaudojama)</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="3793095274466276777">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 šio nustatymo neleisite, „<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.</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="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="6155936611791017817">Nustatyti numatytąją didelio žymeklio prisijungimo ekrane būklę</translation>
<translation id="1530812829012954197">Visada pateikti šiuos URL šablonus prieglobos naršyklėje</translation>
<translation id="9026000212339701596">Žodynų susiejimo prieglobos serverių pavadinimai, skirti loginiam bandymui, nurodantys, ar prieiga prie prieglobos turėtų būti leidžiama (tiesa) arba blokuojama (netiesa).

          Ši politika skirta naudoti tik „Chrome“ viduje.</translation>
<translation id="913195841488580904">Blokuoti prieigą prie URL sąrašo</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="6373222873250380826">Neleidžiami automatiniai naujiniai, kai nustatyta į „True“ (tiesa).

      „<ph name="PRODUCT_OS_NAME"/>“ įrenginiai automatiškai tikrina, ar yra naujinių, kai šis nustatymas nesukonfigūruotas ar nustatytas į „False“ (netiesa).</translation>
<translation id="6190022522129724693">Numatytasis iššokančiųjų langų nustatymas</translation>
<translation id="847472800012384958">Neleisti jokioje svetainėje rodyti iššokančiųjų langų</translation>
<translation id="4733471537137819387">Politika, susijusi su integruotuoju HTTP tapatumo nustatymu.</translation>
<translation id="8951350807133946005">Nustatyti disko talpyklos katalogą</translation>
<translation id="603410445099326293">Pasiūlymų URL parametrai, kuriuose naudojama POST</translation>
<translation id="2592091433672667839">Neveikos iki parodant ekrano užsklandą prisijungimo ekrane, dirbant mažmeninės prekybos režimu, trukmė</translation>
<translation id="166427968280387991">Tarpinis serveris</translation>
<translation id="2805707493867224476">Leisti visose svetainėse rodyti iššokančiuosius langus</translation>
<translation id="1727394138581151779">Blokuoti visus papildinius</translation>
<translation id="8118665053362250806">Nustatyti medijos disko talpyklos dydį</translation>
<translation id="7079519252486108041">Blokuoti iššokančiuosius langus šiose svetainėse</translation>
<translation id="1859633270756049523">Apriboti sesijos trukmę</translation>
<translation id="7433714841194914373">Įgalinti intuityviąją paiešką</translation>
<translation id="4983201894483989687">Leisti paleisti pasenusius papildinius</translation>
<translation id="443665821428652897">Išvalyti svetainės duomenis uždarant naršyklę (nebenaudojama)</translation>
<translation id="3823029528410252878">„<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.

      Jei šio nustatymo neleisite arba nenustatysite, naršymo istorija bus išsaugoma.</translation>
<translation id="3844092002200215574">Konfigūruojamas katalogas, kurį „<ph name="PRODUCT_NAME"/>“ naudos talpyklos failams diske saugoti.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME"/>“ naudos pateiktą katalogą, nesvarbu, ar naudotojas nurodė žymą „--disk-cache-dir“, ar ne.

      Apsilankykite šiuo adresu: http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables. Rasite galimų naudoti variantų sąrašą.


      Jei ši politika nenustatyta, bus naudojamas numatytasis talpyklos katalogas ir naudotojas galės nepaisyti jo naudodamas komandos eilutės žymą „--disk-cache-dir“.</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="193900697589383153">Pridedamas atsijungimo mygtukas sistemos dėkle.

      Jei įgalinta, kai sesija aktyvi ir ekranas neužrakintas, sistemos dėkle rodomas didelis, raudonas atsijungimo mygtukas.

      Jei neleidžiama arba nenurodyta, sistemos dėkle didelis, raudonas atsijungimo mygtukas nerodomas.</translation>
<translation id="5111573778467334951">Nurodykite veiksmą, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas, kai veikiama iš akumuliatoriaus energijos.

          Kai ši politika nustatyta, ji nurodo veiksmą, kurį „<ph name="PRODUCT_OS_NAME"/>“ atlieka, kai naudotojas lieka neaktyvus neaktyvumo delsos nurodytą laikotarpį, kurį galima atskirai konfigūruoti.

          Kai ši politika nenustatyta, atliekamas nustatytasis veiksmas – laikinas sustabdymas.

          Jei veiksmas yra laikinas sustabdymas, „<ph name="PRODUCT_OS_NAME"/>“ gali būti atskirai sukonfigūruota užrakinti ekraną prieš laikiną sustabdymą arba jo neužrakinti.</translation>
<translation id="3195451902035818945">Apibrėžiama, ar SSL įrašų skaidymas turi būti neleidžiamas. Įrašų skaidymas naudojamas SSL 3.0 ir TLS 1.0 trūkumams apeiti, bet kai kuriuose HTTPS ir įgaliotuosiuose serveriuose gali sukelti suderinamumo problemų.

      Jei ši politika nenustatyta ar nustatyta į „Ne“, įrašų skaidymas bus taikomas SSL / TLS ryšiams, kurie naudoja CBC šifro komplektus.</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="5868414965372171132">Naudotojo lygio tinklo konfigūracija</translation>
<translation id="8519264904050090490">Tvarkomi naudotojo neautomatinių išimčių URL</translation>
<translation id="4480694116501920047">Priverstinai vykdyti saugią paiešką</translation>
<translation id="465099050592230505">Įmonės internetinės parduotuvės URL (nebenaudojama)</translation>
<translation id="1221359380862872747">Įkelti nurodytus URL prisijungiant prie demonstracinės versijos</translation>
<translation id="2431811512983100641">Nurodoma, ar turėtų būti įgalintas TLS domeno apribotų sertifikatų plėtinys.

      Šis nustatymas naudojamas įgalinti TLS domeno apribotų sertifikatų plėtinio bandymą. Šis eksperimentinis nustatymas ateityje bus pašalintas.</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="5774856474228476867">Numatytojo paieškos teikėjo paieškos URL</translation>
<translation id="4650759511838826572">Neleisti URL protokolų schemų</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="8099880303030573137">Neveikos delsa, kai naudojama akumuliatoriaus energija</translation>
<translation id="2761483219396643566">Neveikos įspėjimo delsa, kai naudojama akumuliatoriaus energija</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="8580857153747395000">Įspėti, kai apsilankoma svetainėse, neesančiose turinio paketuose.</translation>
<translation id="350796261613621561">Įgalinti prižiūrimų naudotojų kūrimą.</translation>
<translation id="602728333950205286">Numatytojo paieškos teikėjo intuityviosios paieškos URL</translation>
<translation id="3030000825273123558">Įgalinti metrikos ataskaitų teikimą</translation>
<translation id="8465065632133292531">Intuityviosios paieškos URL parametrai, kuriuose naudojama POST</translation>
<translation id="6559057113164934677">Neleisti jokiai svetainei pasiekti kameros ir mikrofono</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="1675002386741412210">Palaikoma naudojant:</translation>
<translation id="3547954654003013442">Įgaliotojo serverio nustatymai</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="6897718480289510689">Leisti pasiekti svetaines, neesančias turinio paketuose.</translation>
<translation id="2518231489509538392">Leisti paleisti garsą</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="436581050240847513">Pateikti įrenginio tinklo sąsajų ataskaitą</translation>
<translation id="6282799760374509080">Leisti arba atmesti garso įrašo fiksavimą</translation>
<translation id="8864975621965365890">Nerodomas raginimas išjungti, kuris rodomas, kai svetainę pateikia „<ph name="PRODUCT_FRAME_NAME"/>“.</translation>
<translation id="3264793472749429012">Numatytojo paieškos teikėjo koduotės</translation>
<translation id="285480231336205327">Įgalinti didelio kontrasto būseną</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 tvarkyti prižiūrimus naudotojus.</translation>
<translation id="8101760444435022591">Atsiradus programiniam gedimui, prisijungus atliekami panaikinimo patikrinimai neužtikrina tinkamo saugumo, todėl jie pagal numatytuosius nustatymus neleidžiami 19 ir naujesnių versijų „<ph name="PRODUCT_NAME"/>“. Nustačius šią politiką į „true“ (tiesa), atkuriama ankstesnė elgsena ir atliekami OCSP / CRL patikrinimai prisijungus.

      Nenustačius politikos arba nustačius į „false“ (netiesa), „Chrome“ neatlieka panaikinimo patikrinimų prisijungus 19 ir naujesnių versijų „Chrome“.</translation>
<translation id="5469484020713359236">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 „Numatytasis slapukų nustatymas“ (jei nustatyta) arba naudotojo asmeninės konfigūracijos.</translation>
<translation id="1504431521196476721">Nuotolinis patvirtinimas</translation>
<translation id="1881299719020653447">Slėpti internetinę parduotuvę Naujo skirtuko puslapyje ir programų paleidimo priemonėje</translation>
<translation id="930930237275114205">Nustatyti „<ph name="PRODUCT_FRAME_NAME"/>“ naudotojo duomenų katalogą</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="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="7927140259706020912">URL, kuriems bus suteikta prieiga prie garso fiksavimo įrenginių be paraginimo.</translation>
<translation id="4600786265870346112">Įgalinti didelį žymeklį</translation>
<translation id="8592105098257899882">Konfigūruojamas talpyklos, kurią „<ph name="PRODUCT_NAME"/>“ naudos talpykloje esantiems failams saugoti diske, dydis.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME"/>“ bus naudojama pateikto dydžio talpykla, neatsižvelgiant, ar naudotojas nurodė žymą „--disk-cache-size“.

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

      Nenustačius šios politikos, bus naudojamas numatytasis dydis ir naudotojas (-a) galės jį pakeisti taikydamas (-a) žymą „--disk-cache-size“.</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="5765780083710877561">Aprašas:</translation>
<translation id="6915442654606973733">Įgalinti atsiliepimų žodžiu pasiekiamumo funkciją.

          Jei ši politika nustatyta, atsiliepimai žodžiu bus visada įgalinti.

          Jei ši politika nenustatyta, atsiliepimai žodžiu bus visada išjungti.

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

          Jei ši politika nenustatyta, atsiliepimai žodžiu bus išjungti, bet naudotojas galės bet kada ją įgalinti.</translation>
<translation id="7796141075993499320">Leidžiama nustatyti URL šablonų, nurodančių svetaines, kuriose leidžiama paleisti papildinius, sąrašą.

          Nenustačius šios politikos visose svetainėse bus naudojama visuotinė numatytoji vertė iš politikos „Numatytasis papildinių nustatymas“ (jei nustatyta) ar naudotojo asmeninės konfigūracijos.</translation>
<translation id="3809527282695568696">Jei kaip paleisties veiksmas pasirinkta „Atidaryti URL sąrašą“, galite nurodyti atidaromų URL sąrašą. Jei nenustatoma, paleisties metu neatidaromas joks URL.

          Ši politika veikia, tik jei politika „Atkurti paleisties metu“ nustatyta į „Atkurti paleisties metu URL“.</translation>
<translation id="649418342108050703">Neleidžiama palaikyti trimatės grafikos API.

      Jei įgalinsite šį nustatymą, per tinklalapius nebus galima pasiekti grafikos apdorojimo įrenginių (GPU). Įprastai per tinklalapius negalima pasiekti „WebGL“ API, o papildiniai negali naudoti „Pepper“ trimatės API.

      Jei šio nustatymo neleisite arba nenustatysite, tinklalapiuose bus galima naudoti „WebGL“ API, o papildiniai galės naudoti „Pepper“ trimatę API. Tačiau norint naudoti šias API pagal numatytuosius naršyklės nustatymus dar gali būti reikalaujama, kad būtų leidžiami komandų eilutės argumentai.</translation>
<translation id="2077273864382355561">Ekrano išjungimo delsa, kai naudojama akumuliatoriaus energija</translation>
<translation id="909184783177222836">Energijos valdymas</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="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="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="7258823566580374486">Įgalinti nuotolinės prieigos prieglobų slėpimą</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="944817693306670849">Nustatyti disko talpyklos dydį</translation>
<translation id="8544375438507658205">Numatytasis „<ph name="PRODUCT_FRAME_NAME"/>“ HTML teikėjas</translation>
<translation id="2371309782685318247">Nurodomas laikotarpis milisekundėmis, kuriuo įrenginio valdymo paslaugai pateikiama užklausa dėl naudotojo politikos informacijos.

       Nustačius šią politiką panaikinama numatytoji 3 valandų vertė. Galiojančios šios politikos vertės patenka į diapazoną nuo 1 800 000 (30 min.) iki 86 400 000 (1 d.). Bet kokioms į šį diapazoną nepatenkančioms vertėms bus taikomi atitinkami apribojimai.

      Nenustačius šios politikos „<ph name="PRODUCT_NAME"/>“ bus naudojama numatytoji 3 val. vertė.</translation>
<translation id="7424751532654212117">Neleidžiamų papildinių sąrašo išimčių sąrašas</translation>
<translation id="6233173491898450179">Nustatyti atsisiuntimo katalogą</translation>
<translation id="78524144210416006">Konfigūruokite energijos valdymą prisijungimo ekrane „<ph name="PRODUCT_OS_NAME"/>“.

      Naudodami šią politiką galite konfigūruoti „<ph name="PRODUCT_OS_NAME"/>“ veiksmus, kai naudotojas nėra aktyvus tam tikrą laikotarpį, kol rodomas prisijungimo ekranas. Politika valdo kelis nustatymus. Atskirą jų semantiką ir verčių diapazonus žr. atitinkamoje politikoje, kontroliuojančioje energijos valdymą per sesiją. Vieninteliai nukrypimai nuo šios politikos yra:
      * Veiksmai, kurie atliekami esant neaktyvumo būsenai ar uždarius dangtį, negali būti sesijos nutraukimas.
      * Numatytasis veiksmas, kuris atliekamas esant neaktyvumo būsenai, kai veikiama iš kintamosios srovės šaltinio, yra uždarymas.

      Politika turi būti nurodyta kaip eilutė, kurioje pateikiami atskiri nustatymai JSON formatu, atitinkanti nurodytą schemą:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;AC&quot;: {
            &quot;description&quot;: &quot;Energijos valdymo nustatymai taikomi tik veikiant iš kintamosios srovės šaltinio&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;Laikotarpis milisekundėmis, kurį naudotojas neatlieka veiksmų ir kuriam pasibaigus ekranas užtemdomas&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Laikotarpis milisekundėmis, kurį naudotojas neatlieka veiksmų ir kuriam pasibaigus ekranas išjungiamas&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Laikotarpis milisekundėmis, kurį naudotojas neatlieka veiksmų ir kuriam pasibaigus atliekamas neaktyvumo veiksmas&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Veiksmas, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;Battery&quot;: {
            &quot;description&quot;: &quot;Energijos valdymo nustatymai, taikomi tik veikiant iš akumuliatoriaus energijos&quot;,
            &quot;type&quot;: &quot;object&quot;,
            &quot;properties&quot;: {
              &quot;Delays&quot;: {
                &quot;type&quot;: &quot;object&quot;,
                &quot;properties&quot;: {
                  &quot;ScreenDim&quot;: {
                    &quot;description&quot;: &quot;Laikotarpis milisekundėmis, kurį naudotojas neatlieka veiksmų ir kuriam pasibaigus ekranas užtemdomas&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;Laikotarpis milisekundėmis, kurį naudotojas neatlieka veiksmų ir kuriam pasibaigus ekranas išjungiamas&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;Laikotarpis milisekundėmis, kurį naudotojas neatlieka veiksmų ir kuriam pasibaigus atliekamas neaktyvumo veiksmas&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Veiksmas, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;LidCloseAction&quot;: {
            &quot;description&quot;: &quot;Veiksmas, kuris bus atliktas, kai bus uždarytas dangtis&quot;,
            &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
          },
          &quot;UserActivityScreenDimDelayScale&quot;: {
            &quot;description&quot;: &quot;Procentinis dydis, pagal kurį skirstoma ekrano užtemdymo delsa, kai stebimas naudotojo aktyvumas, kol ekranas užtemdytas arba netrukus išjungus ekraną&quot;,
            &quot;type&quot;: &quot;integer&quot;,
            &quot;minimum&quot;: 100
          }
        }
      }

      Jei nustatymas nenurodomas, naudojama numatytoji vertė.

      Jei ši politika nenustatyta, visiems nustatymams naudojamos numatytosios vertės.</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="2299220924812062390">Nurodyti įgalintų papildinių sąrašą</translation>
<translation id="4325690621216251241">Pridėti atsijungimo mygtuką prie sistemos dėklo</translation>
<translation id="924557436754151212">Importuoti išsaugotus slaptažodžius iš numatytosios naršyklės paleidžiant pirmą kartą</translation>
<translation id="1465619815762735808">Paleisti spustelėjus</translation>
<translation id="7227967227357489766">Apibrėžiamas naudotojų, kuriems leidžiama prisijungti prie įrenginio, sąrašas. Įrašai yra tokios formos: <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, pvz., <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Jei norite leisti atsitiktinius naudotojus domene, naudokite tokios formos įrašus: <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Jei ši politika nesukonfigūruota, nėra apribojimų, kuriems naudotojams leidžiama prisijungti. Atminkite, kad kuriant naujus naudotojus vis tiek reikia atitinkamai sukonfigūruoti „<ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/>“ politiką.</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="1897365952389968758">Leisti visose svetainėse paleisti „JavaScript“</translation>
<translation id="5244714491205147861">Energijos valdymas prisijungimo ekrane</translation>
<translation id="922540222991413931">Konfigūruokite plėtinio, programos ir naudotojo scenarijaus įdiegimo šaltinius.</translation>
<translation id="7323896582714668701">Papildomi „<ph name="PRODUCT_NAME"/>“ komandinės eilutės parametrai</translation>
<translation id="6931242315485576290">Neleisti sinchronizuoti duomenų su „Google“</translation>
<translation id="7006788746334555276">Turinio nustatymai</translation>
<translation id="5142301680741828703">„<ph name="PRODUCT_FRAME_NAME"/>“ visada pateikti šiuos URL šablonus</translation>
<translation id="4625915093043961294">Konfigūruoti plėtinių diegimo baltąjį sąrašą</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="4507081891926866240">Tinkinkite URL šablonų, kurie visada turėtų būti pateikti „<ph name="PRODUCT_FRAME_NAME"/>“, sąrašą.

          Nenustačius šios politikos, visose svetainėse bus naudojama numatytoji pateikimo programa kaip nurodyta pagal politiką „Chrome“ rėmelio pateikimo programos nustatymai“.

          Jei reikia pavyzdinių šablonų, žr. šiuo adresu: http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Pasirinkti, kaip nurodyti tarpinio serverio nustatymus</translation>
<translation id="1803646570632580723">Paleidimo priemonėje prisegtų rodomų programų sąrašas</translation>
<translation id="7774768074957326919">Naudoti sistemos tarpinio serverio nustatymus</translation>
<translation id="3891357445869647828">Įgalinti „JavaScript“</translation>
<translation id="868187325500643455">Leisti visose svetainėse automatiškai paleisti papildinius</translation>
<translation id="7421483919690710988">Nustatyti medijos disko talpyklos dydį baitais</translation>
<translation id="5226033722357981948">Nurodyti, ar turi būti neleidžiamas papildinių ieškiklis</translation>
<translation id="4890209226533226410">Nustatyti įgalinto ekrano didinimo tipą.

          Jei ši politika nustatyta, pagal ją nustatomas įgalintas ekrano didinimas. Nustačius politiką į „Joks“, ekrano didinimas išjungiamas.

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

          Jei ši politika nenustatyta, ekrano didinimas bus išjungtas, bet naudotojas galės jį bet kada įgalinti.</translation>
<translation id="3428247105888806363">Įgalinti tinklo prognozę</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="2757054304033424106">Leidžiami įdiegti plėtinių / programų tipai</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="5757829681942414015">Konfigūruojamas katalogas, kurį „<ph name="PRODUCT_NAME"/>“ naudos naudotojo duomenims saugoti.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME"/>“ naudos pateiktą katalogą, nesvarbu, ar naudotojas nurodė žymą „--user-data-dir“, ar ne.

      Apsilankykite šiuo adresu: http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables. Rasite galimų naudoti variantų sąrašą.

      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="5067143124345820993">Prisijungusių naudotojų baltasis sąrašas</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="7194407337890404814">Numatytojo paieškos teikėjo pavadinimas</translation>
<translation id="1843117931376765605">Atnaujinti naudotojo politikos reitingą</translation>
<translation id="5535973522252703021">„Kerberos“ nukreipimo serverio baltasis sąrašas</translation>
<translation id="4578030379102330182">Įgalinti nuotolinį naudotojo patvirtinimą.</translation>
<translation id="9187743794267626640">Neleisti montuoti išorinės atminties</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="5307432759655324440">Inkognito režimo pasiekiamumas</translation>
<translation id="4056910949759281379">Neleisti SPDY protokolo</translation>
<translation id="3808945828600697669">Nurodyti neleidžiamų papildinių sąrašą</translation>
<translation id="4525521128313814366">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 „Numatytasis vaizdų nustatymas“ (jei nustatyta) ar naudotojo asmeninės konfigūracijos.</translation>
<translation id="8499172469244085141">Numatytieji nustatymai (naudotojai gali nepaisyti)</translation>
<translation id="8693243869659262736">Naudoti integruotą DNS kliento programą</translation>
<translation id="3072847235228302527">Nustatyti vietinės įrenginio paskyros paslaugų teikimo sąlygas</translation>
<translation id="5523812257194833591">Vieša sesija, skirta automatiškai prijungti po delsos.

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

      Jei ši politika nenustatyta, nebus automatiškai prijungiama.</translation>
<translation id="5983708779415553259">Numatytoji elgsena, skirta svetainėms, neesančioms turinio paketuose</translation>
<translation id="3866530186104388232">Jei ši politika nustatyta į „true“ (tiesa) arba nesukonfigūruota, „<ph name="PRODUCT_OS_NAME"/>“ rodomi esami naudotojai prisijungimo ekrane ir leidžiama juos pasirinkti. Jei ši politika nustatyta į „false“ (netiesa), „<ph name="PRODUCT_OS_NAME"/>“ prisijungiant naudojamas naudotojo vardo / slaptažodžio raginimas.</translation>
<translation id="2098658257603918882">Įgalinti naudojimo ir su strigtimis susijusių duomenų ataskaitų kūrimą</translation>
<translation id="2324547593752594014">Leidžiama prisijungti prie „Chrome“</translation>
<translation id="172374442286684480">Leisti visose svetainėse nustatyti vietinius duomenis</translation>
<translation id="1151353063931113432">Leisti vaizdus šiose svetainėse</translation>
<translation id="1297182715641689552">Naudoti .pac tarpinio serverio scenarijų</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="8631434304112909927">iki <ph name="UNTIL_VERSION"/> versijos</translation>
<translation id="7469554574977894907">Įgalinti paieškos pasiūlymus</translation>
<translation id="4906194810004762807">Atnaujinti įrenginio politikos reitingą</translation>
<translation id="8922668182412426494">Serveriai, į kuriuos „<ph name="PRODUCT_NAME"/>“ gali pervesti.

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

          Jei nenustatysite šios politikos, „Chrome“ neperves naudotojo kredencialų, net jei aptinkama, kad serveris yra intranete.</translation>
<translation id="1398889361882383850">Leidžiama nustatyti, ar svetainėms leidžiama automatiškai paleisti papildinius. Galima leisti visoms svetainėms automatiškai paleisti papildinius arba neleisti to padaryti.

          Paleidimas spustelėjus – galima paleisti papildinius, bet naudotojas turi spustelėti juos, kad jie būtų vykdomi.

          Jei ši politika nenustatoma, bus naudojama komanda „Leisti papildinius“ ir naudotojas galės ją pakeisti.</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="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="5511702823008968136">Įgalinti žymių juostą</translation>
<translation id="5105313908130842249">Ekrano užrakto delsa, kai naudojama akumuliatoriaus energija</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="7736666549200541892">Įgalinti TLS domeno apribotų sertifikatų plėtinį</translation>
<translation id="1796466452925192872">Galima nurodyti, iš kurių URL galima įdiegti plėtinius, programas ir temas.

          21 versijos „Chrome“ sudėtingiau įdiegti plėtinius, programas ir naudotojo (-os) scenarijus ne iš „Chrome“ internetinės parduotuvės. Anksčiau naudotojai galėjo spustelėti *.crx failo nuorodą ir „Chrome“ buvo leidžiama įdiegti failą po kelių įspėjimų. Naujesnės nei 21 versijos „Chrome“ tokius failus reikia atsisiųsti ir nuvilkti į „Chrome“ nustatymų puslapį. Naudojant šį nustatymą galima iš konkrečių URL įdiegti senu, lengvesniu įdiegimo metodu.

          Kiekvienas šio sąrašo elementas yra plėtinio stiliaus atitikmens šablonas (žr. http://code.google.com/chrome/extensions/match_patterns.html). Naudotojai galės paprastai įdiegti elementus iš bet kurio URL, atitinkančio šio sąrašo elementą. Šių šablonų turi būti leidžiama *.crx failo vieta ir puslapis, iš kurio pradedamas atsisiuntimas (pvz., persiuntėjo).

          Į „ExtensionInstallBlacklist“ (plėtinių diegimo juodąjį sąrašą) įtrauktiems plėtiniams ši politika negalioja. T. y. juodajame sąraše esantis plėtinys įdiegtas nebus, net jei tai atliekama iš šio sąrašo svetainės.</translation>
<translation id="2113068765175018713">Apriboti įrenginio veiksenos laiką automatiškai įkeliant operacinę sistemą iš naujo</translation>
<translation id="7848840259379156480">Įdiegus „<ph name="PRODUCT_FRAME_NAME"/>“ leidžiama sukonfigūruoti numatytąjį HTML teikėją.
      Pagal numatytuosius nustatymus teikti leidžiama prieglobos naršyklei, bet jūs savo nuožiūra šios nuostatos galite nepaisyti ir nustatyti, kad pagal numatytuosius nustatymus „<ph name="PRODUCT_FRAME_NAME"/>“ pateiktų HTML puslapius.</translation>
<translation id="186719019195685253">Veiksmas, kuris bus atliktas, kai bus pasiektas neaktyvumo delsos laikas, veikiant iš kintamosios srovės šaltinio</translation>
<translation id="7890264460280019664">Pateikite tinklo sąsajų sąrašo su jų tipais ir aparatinės įrangos adresais ataskaitą serveriui.

      Jei politika nenustatyta arba nustatyta „Ne“, nebus pateikta sąsajų sąrašo ataskaita.</translation>
<translation id="4121350739760194865">Neleisti rodyti programų reklamų naujo skirtuko puslapyje</translation>
<translation id="2127599828444728326">Leisti pranešimus šiose svetainėse</translation>
<translation id="3973371701361892765">Niekada automatiškai neslėpti lentynos</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="2948087343485265211">Nurodo, ar garso įrašo veikla paveikia energijos valdymą.

          Jei politika yra galiojanti ar ji nenustatyta, laikoma, kad naudotojas neatlieka jokių veiksmų, kai paleistas garso įrašas. Tai neleidžia pasiekti skirtojo neveikos laiko ir neleidžia atlikti neveikos veiksmų. Tačiau ekrano pritemdymas, išjungimas ir užrakinimas bus atlikti pasibaigus sukonfigūruotam skirtajam laikui, neatsižvelgiant į garso įrašo veiklą.

          Jei ši politika negalioja, nepaisoma garso įrašo veiklos ir naudotojas laikomas neveikiu.</translation>
<translation id="7842869978353666042">„Google“ disko parinkčių konfigūravimas</translation>
<translation id="718956142899066210">Leistini ryšio tipai naujinant</translation>
<translation id="1734716591049455502">Konfigūruoti nuotolinės prieigos parinktis</translation>
<translation id="7336878834592315572">Išsaugoti slapukus vykstant sesijai</translation>
<translation id="7715711044277116530">Procentas, pagal kurį bus keičiamas ekrano užtemdymo delsos mastelis dirbant pristatymo režimu</translation>
<translation id="8777120694819070607">Leidžiama „<ph name="PRODUCT_NAME"/>“ paleisti pasenusius papildinius.

      Jei įgalinsite šį nustatymą, pasenę papildiniai bus naudojami kaip įprasti.

      Jei šio nustatymo neleisite, pasenę papildiniai nebus naudojami, o naudotojų nebus prašoma suteikti leidimo juos paleisti.

      Nenustačius šio nustatymo, naudotojų bus prašoma suteikti leidimą paleisti pasenusius papildinius.</translation>
<translation id="2629448496147630947">Konfigūruoti nuotolinės prieigos parinktis <ph name="PRODUCT_NAME"/>.

      Šių funkcijų nepaisoma, jei neįdiegta Nuotolinės prieigos žiniatinklio programa.</translation>
<translation id="1310699457130669094">Čia galite nurodyti URL, siejantį su įgaliotojo serverio .pac failu.

          Ši politika galioja, tik jei skiltyje „Pasirinkti, kaip nurodyti įgaliotojo serverio nustatymus“ pasirinkote rankinius įgaliotojo serverio nustatymus.

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

          Jei reikia išsamių pavyzdžių, apsilankykite šiuo adresu:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="1509692106376861764">Ši politika nebenaudojama 29 ir naujesnėse „<ph name="PRODUCT_NAME"/>“ versijose.</translation>
<translation id="5464816904705580310">Konfigūruojami tvarkomų naudotojų paskyrų nustatymai.</translation>
<translation id="3219421230122020860">Inkognito režimas pasiekiamas</translation>
<translation id="7690740696284155549">Konfigūruojamas katalogas, kurį „<ph name="PRODUCT_NAME"/>“ naudos failams atsisiųsti.

      Jei nustatysite šią politiką, „<ph name="PRODUCT_NAME"/>“ pateiktą katalogą naudos, nesvarbu, ar naudotojas nurodė arba įgalino paraginimo kiekvieną kartą atsisiuntimo vietos žymą.

      Apsilankykite šiuo adresu: http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables. Rasite galimų naudoti variantų sąrašą.

      Jei ši politika nenustatyta, bus naudojamas numatytasis atsisiuntimo katalogas ir naudotojas galės jį pakeisti.</translation>
<translation id="7381326101471547614">SPDY protokolas bus neleidžiamas naudoti „<ph name="PRODUCT_NAME"/>“.

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

      Nustačius, kad ši politika neleidžiama, bus galima naudoti SPDY.

      Jei politika palikta nenustatyta, SPDY bus galima naudoti.</translation>
<translation id="2208976000652006649">Paieškos URL parametrai, kuriuose naudojama POST</translation>
<translation id="1583248206450240930">Naudoti „<ph name="PRODUCT_FRAME_NAME"/>“ pagal numatytuosius nustatymus</translation>
<translation id="1047128214168693844">Neleisti jokioje svetainėje stebėti naudotojo buvimo vietos</translation>
<translation id="4101778963403261403">Konfigūruojamas numatytojo pagrindinio puslapio tipas „<ph name="PRODUCT_NAME"/>“ ir neleidžiama naudotojams keisti pagrindinio puslapio nuostatų. Pagrindinis puslapis gali būti URL, kurį nurodote, arba naujo skirtuko puslapis.

          Jei įgalinsite šį nustatymą, kaip pagrindinis puslapis visada bus naudojamas naujo skirtuko puslapis, o pagrindinio puslapio URL vietos bus nepaisoma.

          Jei neleisite šio nustatymo, naudotojo pagrindinis puslapis niekada nebus naujo skirtuko puslapis, nebent jo URL bus nustatytas kaip „chrome://newtab“.

          Jei įgalinsite šį nustatymą arba jo neleisite, naudotojai negalės pakeisti pagrindinio puslapio tipo „<ph name="PRODUCT_NAME"/>“.

          Nenustačius šios politikos, naudotojas (-a) galės pats (-i) pasirinkti, ar naujo skirtuko puslapis bus pagrindinis puslapis.</translation>
<translation id="8970205333161758602">Nerodyti „<ph name="PRODUCT_FRAME_NAME"/>“ išjungimo paraginimo</translation>
<translation id="3273221114520206906">Numatytasis „JavaScript“ nustatymas</translation>
<translation id="4025586928523884733">Blokuojami trečiųjų šalių slapukai.

      Įgalinus šį nustatymą tinklalapio elementai, kurie nėra iš domeno, nurodyto naršyklės adreso juostoje, negalės nustatyti slapukų.

      Neleidus šio nustatymo tinklalapio elementai, kurie nėra iš domeno, nurodyto naršyklės adreso juostoje, galės nustatyti slapukus ir naudotojai negalės pakeisti šio nustatymo.

      Nenustačius šios politikos, trečiųjų šalių slapukai bus įgalinti, bet naudotojas (-a) galės tai pakeisti.</translation>
<translation id="6810445994095397827">Blokuoti „JavaScript“ šiose svetainėse</translation>
<translation id="6672934768721876104">Ši politika nepatvirtinta, todėl geriau naudokite įgaliotojo serverio režimą.

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

          Jei pasirinksite niekada nenaudoti įgaliotojo serverio ir visada jungtis tiesiogiai, visų kitų parinkčių bus nepaisoma.

          Jei pasirinksite naudoti sistemos įgaliotojo serverio nustatymus arba įgaliotąjį serverį aptikti automatiškai, visų kitų parinkčių bus nepaisoma.

          Jei pasirinksite rankinius įgaliotojo serverio nustatymus, galėsite nurodyti ir kitas parinktis skiltyse „Įgaliotojo serverio adresas arba URL“, „URL, siejantis su įgaliotojo serverio .pac failu“ ir „Kableliais atskirtų įgaliotojo serverio apėjimo taisyklių sąrašas“.

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

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

          Nenustačius šios politikos, naudotojai galės patys pasirinkti įgaliotojo serverio nustatymus.</translation>
<translation id="3780152581321609624">Įtraukti nestandartinį prievadą į „Kerberos“ SPN</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="2660846099862559570">Niekada nenaudoti tarpinio serverio</translation>
<translation id="1435659902881071157">Įrenginio lygio tinklo konfigūracija</translation>
<translation id="2131902621292742709">Ekrano pritemdymo delsa, kai naudojama akumuliatoriaus energija</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="5512418063782665071">Pagrindinio puslapio URL</translation>
<translation id="2948381198510798695">„<ph name="PRODUCT_NAME"/>“ apeis bet kokį įgaliotąjį serverį iš čia pateikto prieglobų sąrašo.

          Ši politika galioja, tik jei pasirinkote rankinius įgaliotojo serverio nustatymus skiltyje „Pasirinkti, kaip nurodyti įgaliotojo serverio nustatymus“.

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

          Jei reikia išsamesnių pavyzdžių, apsilankykite šiuo adresu:
          <ph name="PROXY_HELP_URL"/></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="523505283826916779">Pasiekiamumo nustatymai</translation>
<translation id="1948757837129151165">HTTP tapatumo nustatymo politika</translation>
<translation id="5946082169633555022">Beta versijos kanalas</translation>
<translation id="7187256234726597551">Jei ši politika nustatyta, 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="5242696907817524533">Konfigūruojamas tvarkomų žymių sąrašas

      Politika yra žymių sąrašas, o kiekviena žymė yra žodynas, kuriame yra žymė „name“ ir taikymas „url“.

      Šios žymės pateiktos tvarkomų žymių aplanke žymėse mobiliesiems. Šių žymių naudotojas negali keisti.

      Kai ši politika nustatyta, tvarkomos žymės yra numatytasis atidarytas aplankas, kai „Chrome“ atidaryta žymių peržiūra.

      Tvarkomos žymės nėra sinchronizuojamos su naudotojo paskyra.</translation>
<translation id="8303314579975657113">Nurodoma, kurią GSSAPI biblioteką reikia naudoti, nustatant HTTP autentifikavimą. Galima nustatyti vien tik bibliotekos pavadinimą arba visą kelią.

          Nustatymų nepateikus „<ph name="PRODUCT_NAME"/>“ naudos atsarginį numatytąjį bibliotekos pavadinimą.</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="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="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="5645779841392247734">Leisti slapukus šiose svetainėse</translation>
<translation id="4043912146394966243"> 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="6652197835259177259">Vietoje tvarkomų naudotojų paskyrų nustatymai</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="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="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="4088589230932595924">Įjungtas inkognito režimas</translation>
<translation id="5862253018042179045">Nustatyti numatytąją atsiliepimų žodžiu būklę prisijungimo ekrane.

          Jei ši politika nustatyta, atsiliepimai žodžiu bus įgalinti, kai bus rodomas prisijungimo ekranas.

          Jei ši politika nenustatyta, atsiliepimai žodžiu bus išjungti, kai bus rodomas prisijungimo ekranas.

          Jei nustatysite šią politiką, naudotojai galės laikinai nepaisyti jos įgalinę arba išjungę atsiliepimus žodžiu. 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, atsiliepimai žodžiu bus išjungti, kai pirmą kartą bus rodomas prisijungimo ekranas. Naudotojai galės bet kada įgalinti arba išjungti atsiliepimus žodžiu, o jų būsena prisijungimo ekrane bus vienoda skirtingiems naudotojams.</translation>
<translation id="8197918588508433925">Šioje politikoje nustatomi plėtiniai, kuriems leidžiama naudoti įmonės platformos raktų API „chrome.enterprise.platformKeysPrivate.challengeUserKey()“ patvirtinant nuotoliniu būdu. Plėtiniai turi būti pridėti prie šio sąrašo, kad galėtų naudoti API.

Jei plėtinio nėra sąraše arba sąrašas nenustatytas, kreipiantis į API įvyks klaida ir bus pateiktas jos kodas.</translation>
<translation id="7649638372654023172">Konfigūruojamas numatytasis pagrindinio puslapio URL „<ph name="PRODUCT_NAME"/>“ ir neleidžiama naudotojams jo keisti.

          Pagrindinis puslapis – tai tas puslapis, kuris atidaromas spustelėjus pagrindinio puslapio mygtuką. Kokie puslapiai atidaromi paleidžiant, nustatoma pagal politiką „Atkurti paleidžiant“.

          Pagrindinio puslapio tipas gali būti siunčiamas čia nurodytu URL arba nustatytas kaip Naujo skirtuko puslapis. Jei pasirinksite Naujo skirtuko puslapį, ši politika neįsigalios.

          Jei įgalinsite šį nustatymą, naudotojai negalės pakeisti pagrindinio puslapio URL „<ph name="PRODUCT_NAME"/>“, bet vis tiek galės pasirinkti Naujo skirtuko puslapį kaip pagrindinį.

          Nenustačius šios politikos, naudotojas galės pats pasirinkti pagrindinį puslapį, jei nebus nustatyta ir „Pagrindinis puslapis yra Naujo skirtuko puslapis“.</translation>
</translationbundle>