<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="et">
<translation id="1503959756075098984">Taustal installitavate laienduste ID-d ja värskenduste URL-id</translation>
<translation id="2463365186486772703">Rakenduse lokaat</translation>
<translation id="1397855852561539316">Vaikeotsingupakkuja soovitatud URL</translation>
<translation id="3347897589415241400">Mitte ühessegi sisupaketti kuuluvate saitide vaikekäitumine.

          Reegel kehtib Chrome'ile sisekasutamiseks.</translation>
<translation id="7040229947030068419">Näidisväärtus:</translation>
<translation id="1213523811751486361">Määrab otsingumootori URL-i, mida kasutatakse otsingusoovituste näitamiseks. URL peab hõlmama stringi „<ph name="SEARCH_TERM_MARKER"/>”, mis asendatakse päringu esitamisel kasutaja sisestatud tekstiga.

          See reegel on valikuline. Kui see jäetakse määramata, siis soovituse URL-i ei kasutata.

          Reegel on jõus vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="6106630674659980926">Luba paroolihaldur</translation>
<translation id="7109916642577279530">Heli jäädvustamise lubamine või keelamine.

      Kui reegel on lubatud või pole seadistatud (vaikimisi), küsitakse kasutajalt
      heli jäädvustamiseks juurdepääsu, v.a loendis AudioCaptureAllowedUrls
      seadistatud URL-ide puhul, millele antakse juurdepääs ilma küsimata.

      Kui reegel on keelatud, ei küsita kasutajalt kunagi ning heli
      jäädvustamine on saadaval ainult loendis AudioCaptureAllowedUrls seadistatud URL-ide puhul.

      Reegel mõjutab igat tüüpi helisisendeid, mitte ainult sisseehitatud mikrofone.</translation>
<translation id="9150416707757015439">Reegel on aegunud. Kasutage selle asemel reeglit IncognitoModeAvailability.
      Lubab inkognito režiimi rakenduses <ph name="PRODUCT_NAME"/>.

      Kui seade on lubatud või seadistamata, siis saavad kasutajad avada veebilehti inkognito režiimis.

      Kui seade on keelatud, siis ei saa kasutajad veebilehti inkognito režiimis avada.

      Kui reeglit ei määrata, siis need lubatakse ja inkognito režiimi on võimalik kasutada.</translation>
<translation id="4203389617541558220">Seadme tööaja piiramine, ajastades automaatsed taaskäivitused.

      Reegel määratleb seadme tööaja kestuse, mille järel tehakse automaatne taaskäivitus.

      Kui reegel on määramata, on seadme tööaeg piiramata.

      Kui määrate reegli, ei saa kasutajad seda muuta ega alistada.

      Automaatne taaskäivitus ajastatakse valitud ajale, kuid võib seadmes kuni 24 tundi viibida, kui kasutaja seadet parajasti kasutab.

      Märkus. Praegu on automaatsed taaskäivitused lubatud ainult siis, kui kuvatakse sisselogimisekraan või kioskirakenduse seanss on pooleli. Tulevikus see muutub ja reeglid rakenduvad alati, olenemata sellest, kas mingit tüüpi seanss on pooleli või mitte.

      Reegli väärtus tuleb määratleda sekundites. Väärtused kinnitatakse alates 3600 sekundist (ühest tunnist..</translation>
<translation id="5304269353650269372">Määrab aja, pärast mida kuvatakse akutoite kasutamisel hoiatusdialoog, kui kasutaja pole midagi sisestanud.

          Kui see reegel on määratud, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui teenus <ph name="PRODUCT_OS_NAME"/> kuvab hoiatusdialoogi, teavitades kasutajat tegevusetu oleku peatsest toimingust.

          Kui seda reeglit pole määratud, siis hoiatusdialoogi ei kuvata.

          Reegli väärtus tuleb määrata millisekundites. Väärtus peab olema tegevusetuse viivitusest väiksem või sellega võrdne.</translation>
<translation id="7818131573217430250">Määrab sisselogimisekraanil kõrge kontrastsusega režiimi vaikeoleku</translation>
<translation id="7614663184588396421">Keelatud protokolliskeemide loend</translation>
<translation id="2309390639296060546">Geograafilise asukoha vaikeseade</translation>
<translation id="1313457536529613143">Määratleb ekraani tumenduse viivituse skaleerimismäära protsentides, kui täheldatakse kasutaja tegevust ekraani tumendamise ajal või peagi pärast ekraani väljalülitumist.

          Reegel määratleb ekraani tumenduse viivituse skaleerimismäära protsentides, kui täheldatakse kasutaja tegevust ekraani tumendamise ajal või peagi pärast ekraani väljalülitumist. Tumenduse viivituse skaleerimisel reguleeritakse ekraani väljalülitumise, ekraaniluku ja tegevusetu oleku viivitusi, et säilitada ekraanitumenduse viivitusest samu kaugusi mis algselt seadistatud.

          Kui reegel ei ole määratud, kasutatakse skaleerimise vaiketegurit.

          Skaleerimistegur peab olema vähemalt 100%.</translation>
<translation id="7443616896860707393">Erineva päritoluga HTTP Basic Authi viibad</translation>
<translation id="2337466621458842053">Võimaldab teil määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud kujutisi kuvada.

          Kui reeglit ei määrata, siis kasutatakse kõikide saitide puhul reegli „DefaultImagesSetting” globaalset vaikeväärtust, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="4680961954980851756">Luba automaatne täitmine</translation>
<translation id="5183383917553127163">Võimaldab määrata, millised laiendused ei kuulu musta nimekirja. Musta nimekirja väärtus * tähendab, et kõik laiendused on mustas nimekirjas ja kasutajad saavad installida vaid lubatud nimekirjas olevaid laiendusi. Vaikimisi on kõik laiendused lubatud nimekirjas, kuid kui kõik laiendused on reegliga musta nimekirja kantud, saab lubatud nimekirjaga seda reeglit alistada.</translation>
<translation id="5921888683953999946">Sisselogimisekraanil suure kursori hõlbustusfunktsiooni vaikeoleku määramine.

          Kui reegel on seatud väärtusele Tõene, lubatakse sisselogimisekraani kuvamisel suur kursor.

          Kui reegel on seatud väärtusele Väär, keelatakse sisselogimisekraani kuvamisel suur kursor.

          Kui määrate reegli, saavad kasutajad selle ajutiselt alistada, lubades või keelates suure kursori. Kasutaja valik pole siiski püsiv ja vaikeväärtus taastatakse, kui kuvatakse uuesti sisselogimisekraan või kui kasutaja jääb sisselogimisekraanile minutiks tegevuseta olekusse.

          Kui jätate reegli määramata, on suur kursor sisselogimisekraani esmakuvamisel keelatud. Kasutajad võivad suure kursori igal ajal lubada või keelata ja selle olek on sisselogimisekraanil kasutajati püsiv.</translation>
<translation id="3185009703220253572">alates versioonist <ph name="SINCE_VERSION"/></translation>
<translation id="2204753382813641270">Seadista hoidla automaatne peitmine</translation>
<translation id="3816312845600780067">Pääsu klaviatuuri otsetee lubamine automaatseks sisselogimiseks</translation>
<translation id="3214164532079860003">Kui see reegel on lubatud, siis imporditakse avaleht praegusest vaikebrauserist. Kui reegel on keelatud, siis avalehte ei impordita. Kui reegel ei ole määratud, siis võidakse avaleht automaatselt importida või kasutajalt küsida, kas ta soovib selle importida.</translation>
<translation id="5330684698007383292">Pistikprogrammil <ph name="PRODUCT_FRAME_NAME"/> järgmiste sisutüüpide töötlemise lubamine</translation>
<translation id="6647965994887675196">Kui väärtuseks on seatud valik Tõene, saab luua ja kasutada järelevalvega kasutajaid.

          Kui väärtuseks on seatud valik Väär või Seadistamata, siis on järelevalvega kasutajate loomine ja sisselogimine keelatud. Kõik olemasolevad järelevalvega kasutajad peidetakse.

          MÄRKUS. Tavatarbijatele ja ettevõtetele mõeldud seadmete vaikekäitumine on erinev: tarbijate seadmetes on järelevalvega kasutajad vaikimisi lubatud, kuid ettevõtete seadmetes vaikimisi keelatud.</translation>
<translation id="69525503251220566">Parameeter otsingu vaikepakkujale pildi järgi otsimise funktsiooni pakkumiseks</translation>
<translation id="5469825884154817306">Blokeeri kujutised nendel saitidel</translation>
<translation id="8412312801707973447">Kontrolli võrgus OCSP-d/CRL-i</translation>
<translation id="6649397154027560979">Selle reegli tugi on katkestatud, kasutage selle asemel üksust URLBlacklist.

      Keelab loetletud protokolliskeemid teenuses <ph name="PRODUCT_NAME"/>.

      Selle loendi skeeme kasutavaid URL-e ei laadita ja neile ei saa navigeerida.

      Kui jätate reegli määramata või loendi tühjaks, on kõik skeemid teenuses <ph name="PRODUCT_NAME"/> juurdepääsetavad.</translation>
<translation id="3213821784736959823">Määrab, kas rakenduses <ph name="PRODUCT_NAME"/> kasutatakse sisseehitatud DNS-i klienti.

      Kui reegel on lubatud, kasutatakse võimalusel sisseehitatud DNS-i klienti.

      Kui reegel on keelatud, siis ei kasutata sisseehitatud DNS-i klienti kunagi.

      Kui reegel on määramata, saavad kasutad otsustada, kas rakendus kasutab sisseehitatud DNS-i klienti, muutes atribuuti chrome://flags või määrates käsurea lipu.</translation>
<translation id="2908277604670530363">Puhverserveri samaaegsete ühenduste maksimaalne arv</translation>
<translation id="556941986578702361">Seadistage hoidla <ph name="PRODUCT_OS_NAME"/> automaatne peitmine.

      Kui reegel on seatud väärtusele „AlwaysAutoHideShelf”, peidetakse hoidla alati automaatselt.

      Kui reegel on seatud väärtusele „NeverAutoHideShelf”, ei peideta hoidlat kunagi automaatselt.

      Kui määrate reegli, ei saa kasutajad seda alistada.

      Kui jätate reegli määramata, saavad kasutajad valida, kas hoidla peidetakse automaatselt.</translation>
<translation id="4838572175671839397">Sisaldab regulaaravaldist, mis määrab, millised kasutajad saavad teenusesse <ph name="PRODUCT_NAME"/> sisse logida.

      Kui kasutaja üritab sisse logida kasutajanimega, mis ei kattu mustriga, kuvatakse vastav veasõnum.

      Kui jätate eeskirjad määramata või tühjaks, siis saavad kõik kasutajad teenusesse <ph name="PRODUCT_NAME"/> sisse logida.</translation>
<translation id="2892225385726009373">Kui see seade on lubatud, siis teeb <ph name="PRODUCT_NAME"/> alati tühistamise kontrolli serveri sertifikaatide puhul, mis on valideeritud ja allkirjastatud kohalikult installitud CA-sertifikaatidega.

      Kui tootel <ph name="PRODUCT_NAME"/> ei õnnestu tühistamise oleku teavet hankida, siis käideldakse selliseid sertifikaate tühistatutena („hard-fail”).

      Kui seda reeglit pole määratud või see on määratud olekule Väär, siis kasutab Chrome olemasolevaid tühistamise kontrollimise veebiseadeid.</translation>
<translation id="1438955478865681012">Seadistab laiendustega seotud reeglid. Kasutajatel ei ole lubatud mustas nimekirjas olevaid laiendusi installida, kui need ei ole kantud lubatud nimekirja. Võite sundida rakendust <ph name="PRODUCT_NAME"/> automaatselt laiendusi installima, määrates need reeglis <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Must nimekiri on sunnitud laienduste loendi suhtes ülimuslik.</translation>
<translation id="3516856976222674451">Piirake kasutajaseansi maksimumpikkust.

      Kui reegel on seadistatud, määrab see ajavahemiku, mille möödudes logitakse kasutaja automaatselt välja ja seanss lõpetatakse. Süsteemisalves olev taimer näitab kasutajale järelejäänud aega.

      Kui reegel on määramata, ei ole seansi pikkus piiratud.

      Kui määrate reegli, ei saa kasutajad seda muuta ega alistada.

      Reegli väärtus tuleb määrata millisekundites. Väärtus peab olema vahemikus 30 sekundit kuni 24 tundi.</translation>
<translation id="9200828125069750521">Parameetrid POST-meetodit kasutava kujutise URL-i jaoks</translation>
<translation id="2769952903507981510">Kaugjuurdepääsu hostidele nõutava domeeninime seadistamine</translation>
<translation id="3478024346823118645">Kustuta kasutaja andmed väljalogimisel</translation>
<translation id="8668394701842594241">Määrab pistikprogrammide loendi, mis on rakenduses <ph name="PRODUCT_NAME"/> lubatud, ja takistab kasutajatel selle seade muutmist.

      Metamärke „*” ja „?” saab kasutada määramata märgijadade vastendamiseks. Metamärk „*” vastendab suvalise arvu märke ja metamärk „?” määrab valikulise üksiku tähemärgi, st see vastab ühele või mitte ühelegi tähemärgile. Paomärk on „\”, seetõttu saate märkide „*”, „?” ja „\” vastendamiseks lisada nende ette paomärgi „\”.

      Määratud pistikprogramme kasutatakse alati rakenduses <ph name="PRODUCT_NAME"/>, kui need on installitud. Pistikprogrammid on jaotises „about:plugins” lubatuks märgitud ja kasutajad ei saa neid keelata.

      Pidage meeles, et need see reegel alistab reeglid DisabledPlugins ja DisabledPluginsExceptions.

      Kui reeglit ei määrata, siis saab kasutaja keelata kõik süsteemi installitud pistikprogrammid.</translation>
<translation id="653608967792832033">Määrab aja, pärast mida lukustatakse ekraan akutoitel töötamisel, kui kasutaja pole midagi sisestanud.

          Kui selle reegli väärtuseks määratakse arv, mis on suurem kui null, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui <ph name="PRODUCT_OS_NAME"/> ekraani lukustab.

          Kui selle reegli väärtuseks määratakse null, ei lukusta <ph name="PRODUCT_OS_NAME"/> ekraani, kui kasutaja on tegevusetu.

          Kui jätate selle reegli määramata, kasutatakse vaikeaega.

          Soovitatav on ekraan jõudeolekus lukustada nii, et ekraan lukustatakse seadme peatamisel ja <ph name="PRODUCT_OS_NAME"/> peatub pärast jõudeoleku viiteaja möödumist. Seda reeglit tuleks kasutada vaid siis, kui ekraani lukustamine peab toimuma tükk aega enne seadme peatamist või seadme peatamist jõudeolekus üldse ei soovita.

          Reegli väärtus tuleb määrata millisekundites. Väärtused tuleb kinnitada väiksematena kui jõudeoleku viiteaeg.</translation>
<translation id="4157003184375321727">OS-ist ja püsivara versioonist teavitamine</translation>
<translation id="4752214355598028025">Kui kasutajad satuvad navigeerides saitidele, mis on märgistatud kui potentsiaalselt pahatahtlikud, siis kuvab teenus Google'i ohutu sirvimine hoiatuslehe. Selle seade lubamine takistab kasutajatel hoiatuslehelt pahatahtlikule saidile edasi liikuda.

      Kui seade on keelatud või pole seadistatud, siis saavad kasutajad pärast hoiatuse kuvamist teha valiku edasiminekuks märgistatud saidile.</translation>
<translation id="5255162913209987122">Võib soovitada</translation>
<translation id="1861037019115362154">Määrab rakenduses <ph name="PRODUCT_NAME"/> keelatud pistikprogrammide loendi ja takistab kasutajatel selle seade muutmist.

      Metamärke „*” ja „?” saab kasutada määramata märgijadade vastendamiseks. Metamärk „*” vastendab suvalise arvu märke ja metamärk „?” määrab valikulise üksiku tähemärgi, st see vastab ühele või mitte ühelegi tähemärgile. Paomärk on „\”, seetõttu saate märkide „*”, „?” ja „\” vastendamiseks lisada nende ette paomärgi „\”.

      Seade lubamisel ei kasutata rakenduses <ph name="PRODUCT_NAME"/> kunagi loendis olevaid pistikprogramme. Pistikprogrammid on jaotises „about:plugins” märgitud keelatuks ja kasutajad ei saa neid lubada.

      Pidage meeles, et seda reeglit saab alistada reeglitega „EnabledPlugins” ja „DisabledPluginsExceptions”.

      Kui jätate selle reegli määramata, siis on võimalik kasutada kõiki süsteemi installitud pistikprogramme, v.a püsiprogrammeeritud ühildumatud, aegunud ja ohtlikud pistikprogrammid.</translation>
<translation id="9197740283131855199">Ekraani tumenduse viivituse skaleerimise määr protsentides, kui kasutaja muutub pärast tumendamist aktiivseks.</translation>
<translation id="1492145937778428165">Määrab millisekundites ajavahemiku, mille jooksul saadetakse seadmehaldusteenusesse päring seadme reeglite teabe kohta.

      Selle reegli määramisel alistatakse vaikeväärtus (3 tundi). Reegli sobilikud väärtused on vahemikus 1 800 000 (30 minutit) kuni 86 400 000 (1 päev). Vahemikust välja jäävad väärtused kohandatakse nendesse piiridesse.

      Kui jätate selle reegli määramata, siis kasutab <ph name="PRODUCT_OS_NAME"/> vaikeväärtust 3 tundi.</translation>
<translation id="3765260570442823273">Jõudeolekus väljalogimise hoiatussõnumi kestus</translation>
<translation id="7302043767260300182">Ekraani lukustamise viiteaeg võrgutoite kasutamisel</translation>
<translation id="7331962793961469250">Kui valite „Tõene”, siis ei ilmu Chrome'i veebipoe rakenduste reklaamid uuel vahelehel.

      Kui valite „Väär” või jätate seade määramata, siis ilmuvad uuel vahelehel Chrome'i veebipoe rakenduste reklaamid</translation>
<translation id="7271085005502526897">Kodulehe importimine vaikebrauseri esimesel käitamisel</translation>
<translation id="6036523166753287175">Luba tulemüüri läbimine kaugjuurdepääsu hostist</translation>
<translation id="1096105751829466145">Vaikeotsingupakkuja</translation>
<translation id="7567380065339179813">Luba pistikprogrammid nendel saitidel</translation>
<translation id="1617235075406854669">Brauseri ja allalaadimiste ajaloo kustutamise lubamine</translation>
<translation id="5290940294294002042">Määrake pistikprogrammide loend, mida kasutaja saab lubada või keelata</translation>
<translation id="3153348162326497318">Võimaldab määrata, milliseid laiendusi kasutajad EI saa installida. Juba installitud rakendused eemaldatakse, kui need on mustas nimekirjas. Kui mustas nimekirjas on väärtus „*”, siis kantakse kõik laiendused musta nimekirja, kui need ei ole eraldi lisatud lubatud nimekirja. Kui reeglit ei määrata, siis saab kasutaja rakenduses <ph name="PRODUCT_NAME"/> installida kõik laiendused.</translation>
<translation id="3067188277482006117">Kui selle väärtuseks on seatud Tõene, saab kasutaja kasutada Chrome'i seadmete riistvara, et tõendada enda isikut distantsilt privaatsuse CA abil Enterprise Platform Keys API chrome.enterprise.platformKeysPrivate.challengeUserKey() kaudu.

          Kui selle väärtuseks on seatud Väär või kui väärtus on seadmata, siis kutse esitamine API-le ebaõnnestub ja saate vastuseks veakoodi.</translation>
<translation id="5809728392451418079">Määra seadmepõhiste kontode kuvatav nimi</translation>
<translation id="1427655258943162134">Puhverserveri aadress või URL</translation>
<translation id="1827523283178827583">Kasuta fikseeritud puhverservereid</translation>
<translation id="3021409116652377124">Keela pistikprogrammide leidja</translation>
<translation id="7236775576470542603">Sisselogimisekraanil lubatud ekraaniluubi vaiketüübi määramine.

          Kui reegel kehtib, määrab see sisselogimisekraani kuvamise ajal lubatud ekraaniluubi tüübi. Reegli seadmine väärtusele Puudub keelab ekraaniluubi.

          Kui määrate reegli, saavad kasutajad selle ajutiselt alistada, lubades või keelates ekraaniluubi. Kasutaja valik pole siiski püsiv ja vaikeväärtus taastatakse, kui kuvatakse uuesti sisselogimisekraan või kui kasutaja jääb sisselogimisekraanile minutiks tegevuseta olekusse.

          Kui jätate reegli määramata, on ekraaniluup sisselogimisekraani esmakuvamisel keelatud. Kasutajad võivad ekraaniluubi igal ajal lubada või keelata ja selle olek on sisselogimisekraanil kasutajati püsiv.</translation>
<translation id="5423001109873148185">Kui see reegel on lubatud, siis imporditakse otsingumootorid praegusest vaikebrauserist. Reegli lubamine mõjutab ka importimisdialoogi.

      Kui reegel on keelatud, siis vaikeotsingumootorit ei impordita.

      Kui reeglit ei määrata, siis võidakse automaatselt importida või kasutajalt küsida, kas ta soovib importida.</translation>
<translation id="3288595667065905535">Väljastuskanal</translation>
<translation id="2785954641789149745">Lubab teenuse <ph name="PRODUCT_NAME"/> ohutu sirvimise funktsiooni ja takistab kasutajatel seda seadet muuta.

      Kui lubate seade, on ohutu sirvimine alati aktiivne.

      Kui keelate seade, pole ohutu sirvimine alati aktiivne.

      Kui lubate või keelate seade, ei saa kasutajad teenuses <ph name="PRODUCT_NAME"/> seadet „Luba andmepüügi ja pahavara kaitse” muuta ega alistada.

      Kui reegel jäetakse kehtestamata, on see lubatud, kuid kasutaja saab seda muuta.</translation>
<translation id="8369602308428138533">Ekraani väljalülitamise viiteaeg võrgutoite kasutamisel</translation>
<translation id="6513756852541213407">Võimaldab teil määrata rakenduse <ph name="PRODUCT_NAME"/> kasutatava puhverserveri ja takistab kasutajatel puhverserveri seadete muutmist.

          Kui otsustate puhverserverit mitte kasutada ja alati vahetult ühenduse luua, siis ignoreeritakse kõiki muid valikuid.

          Kui otsustate kasutada süsteemi puhverserveri seadeid või tuvastada puhverserveri automaatselt, siis ignoreeritakse kõiki muid valikuid.

          Kui valite fikseeritud serveri puhverrežiimi, siis saate valikuid täpsustada jaotistes „Puhverserveri aadress või URL” ja „Puhverserverist möödumise reeglite komaeraldusega loend”.

          Kui otsustate kasutada puhverserveri skripti pac-faili, siis tuleb teil määrata skripti URL jaotises „Puhverserveri pac-faili URL”.

          Vaadake üksikasjalikke näiteid:
          <ph name="PROXY_HELP_URL"/>

          Seade lubamisel ignoreerib rakendus <ph name="PRODUCT_NAME"/> kõiki käsureal määratud puhverserveriga seotud valikuid.

          Kui see reegel jäetakse määramata, siis saavad kasutajad ise puhverserveri seaded valida.</translation>
<translation id="7763311235717725977">Võimaldab määrata, kas veebisaitidel on lubatud kujutisi kuvada. Kujutiste kuvamise võib kõikidel veebisaitidel lubada või keelata. Kui seda reeglit ei määrata, siis kasutatakse parameetrit „AllowImages” ja kasutaja saab seda muuta.</translation>
<translation id="5630352020869108293">Viimase seansi taastamine</translation>
<translation id="4980635395568992380">Andmetüüp:</translation>
<translation id="3096595567015595053">Lubatud pistikprogrammide loend</translation>
<translation id="3048744057455266684">Kui see reegel määratakse ja omnikastikeses olev otsingu URL sisaldab seda parameetrit päringustringis või fragmendi identifikaatoris, siis kuvatakse soovituses otsinguterminid ja otsingupakkuja, mitte ainult otsingu URL.

          See reegel on valikuline. Kui seda ei määrata, siis otsinguterminit ei asendata.

          See reegel kehtib vaid siis, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="5912364507361265851">Luba kasutajatel paroolihalduris paroolide näitamine</translation>
<translation id="510186355068252378">Keelab rakenduses <ph name="PRODUCT_NAME"/> andmete sünkroonimise Google'i hostitud sünkroonimisteenuste abil ja takistab kasutajatel seade muutmist.

      Seade lubamisel ei saa kasutajad seadet teenuses <ph name="PRODUCT_NAME"/> muuta ega alistada.

      Kui seda reeglit ei määrata, siis saavad kasutajad otsustada, kas nad soovivad Google Synci kasutada.</translation>
<translation id="7953256619080733119">Kasutaja käsitsi sisestatavate hostide erandite haldamine</translation>
<translation id="7412982067535265896">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud lisada seansiküpsiseid.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust reeglist „DefaultCookiesSetting”, kui see on määratud, või kasutaja isiklikust seadistusest.

          Kui reegel „RestoreOnStartup” on määratud taastama eelmise seansi URL-id, siis ei järgita reeglit ja nende saitide küpsised talletatakse jäädavalt.</translation>
<translation id="8828766846428537606">Seadistage rakenduse <ph name="PRODUCT_NAME"/> vaikeavaleht ja takistage kasutajaid seda muutmast. Kasutaja avalehe seaded on täielikult lukustatud vaid juhul, kui valite avaleheks uue vahelehe või seate selle URL-iks ja määrate avalehel URL-i. Kui te ei määra avalehe URL-i, saab kasutaja määrata avaleheks uue vahelehe käsuga chrome://newtab.</translation>
<translation id="2231817271680715693">Sirvimisajaloo importimine vaikebrauserist esimesel käitamisel</translation>
<translation id="1353966721814789986">Käivitamisel avatavad lehed</translation>
<translation id="1841130111523795147">Lubab kasutajal teenusesse <ph name="PRODUCT_NAME"/> sisse logida ega luba kasutajatel seda seadet muuta.

      Selle reegli määramisel saate seadistada, kas kasutajal lubatakse teenusesse <ph name="PRODUCT_NAME"/> sisse logida või mitte.</translation>
<translation id="5564962323737505851">Seadistab paroolihalduri. Kui paroolihaldur on lubatud, siis võite kasutajatel lubada või keelata talletatud paroolide näitamise tavatekstina.</translation>
<translation id="4668325077104657568">Kujutiste vaikeseaded</translation>
<translation id="4492287494009043413">Keela ekraanipiltide tegemine</translation>
<translation id="6368403635025849609">Luba JavaScript nendel saitidel</translation>
<translation id="6074963268421707432">Keela kõigil saitidel töölauateatiste näitamine</translation>
<translation id="8614804915612153606">Keelab automaatvärskenduse</translation>
<translation id="382476126209906314">TalkGadgeti eesliite seadistamine kaugjuurdepääsu hostidele</translation>
<translation id="6561396069801924653">Juurdepääsuvalikute kuvamine süsteemisalve menüüs</translation>
<translation id="8104962233214241919">Valige automaatselt kliendi sertifikaadid nendele saitidele</translation>
<translation id="2906874737073861391">AppPacki laienduste loend</translation>
<translation id="3758249152301468420">Keela arendaja tööriistad</translation>
<translation id="8665076741187546529">Sunnitult installitud laienduste loendi seadistamine</translation>
<translation id="410478022164847452">Määrab aja, pärast mida lülitatakse võrgutoite kasutamisel sisse jõudeolek, kui kasutaja pole midagi sisestanud.

          Kui see reegel määratakse, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui <ph name="PRODUCT_OS_NAME"/> jõudeoleku sisse lülitab (selle saab seadistada eraldi).

          Kui jätate selle reegli määramata, kasutatakse vaikeaega.

          Reegli väärtus tuleb määrata millisekundites.</translation>
<translation id="1675391920437889033">Määrab, millist tüüpi rakendusi/laiendusi tohib installida.

          Seade loob lubatud loendi kõikidest laiendustest/rakendustest, mida tohib rakendusse <ph name="PRODUCT_NAME"/> installida. Väärtus on loend stringidest, mis peavad olema järgmisel kujul: „extension”, „theme”, „user_script”, „hosted_app”, „legacy_packaged_app”, „platform_app”. Vaadake tüüpide kohta lisateavet Chrome'i laienduste dokumentidest.

          Pange tähele, et reegel mõjutab ka atribuudi ExtensionInstallForcelist kaudu sundinstallitavaid laiendusi ja rakendusi.

          Kui seade on määratud, siis ei installita laiendusi/rakendusi, mille tüüp loendist puudub.

          Kui jätate seade määramata, ei rakendata laienduste/rakenduste tüüpidele piiranguid.</translation>
<translation id="6378076389057087301">Määrake, kas helitoimingud mõjutavad toitehaldust</translation>
<translation id="8818173863808665831">Esitab seadme geograafilise asukoha.

      Kui jätate eeskirjad määramata või keelate need, siis asukohta ei esitata.</translation>
<translation id="4899708173828500852">Luba ohutu sirvimine</translation>
<translation id="4442582539341804154">Luba lukustamine, kui seade on ootel või peatatud</translation>
<translation id="7719251660743813569">Määrab, kas kasutusmõõdikute tulemused saadetakse Google'ile. Selle reegli lubamisel teatab <ph name="PRODUCT_OS_NAME"/> kasutusmõõdikute tulemusi. Kui jätate selle reegli seadistamata või keelate, siis keelatakse mõõdikute aruandlus.</translation>
<translation id="2372547058085956601">Avaliku seansi automaatse sisselogimise viivitus.

      Kui reeglit |DeviceLocalAccountAutoLoginId| ei määrata, ei ole sellel mingit mõju. Muidu on mõju järgmine.

      Kui selle reegli määrate, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui logitakse automaatselt sisse reegli |DeviceLocalAccountAutoLoginId| määratud avalikku seanssi.

      Kui seda reeglit ei määrata, on ajalimiidi väärtuseks 0 millisekundit.

      See reegel on määratud millisekundites.</translation>
<translation id="7275334191706090484">Hallatud järjehoidjad</translation>
<translation id="3570008976476035109">Blokeeri pistikprogrammid nendel saitidel</translation>
<translation id="8749370016497832113">Lubab rakenduses <ph name="PRODUCT_NAME"/> kustutada brauseri ja allalaadimiste ajaloo ega luba kasutajatel seda seadet muuta.

      Pange tähele, et isegi kui see reegel on keelatud, ei garanteerita sirvimise ja allalaadimiste ajaloo säilitamist: kasutajatel võib olla võimalik ajaloo andmebaasi faile muuta või kustutada otse ja brauser ise võib mis tahes ajal aeguda või arhiveerida mõned või kõik ajaloo üksused.

      Kui see seade on lubatud või määramata, saab sirvimise ja allalaadimiste ajaloo kustutada.

      Kui see seade on keelatud, siis sirvimise ja allalaadimiste ajalugu kustutada ei saa.</translation>
<translation id="2884728160143956392">Luba nendel saitidel vaid seansi küpsised</translation>
<translation id="3021272743506189340">Kui väärtuseks on seatud Tõene, keelab see mobiiliühenduse kasutamisel Google Drive'i sünkroonimise Chrome OS-i rakenduses Failid. Sellisel juhul sünkroonitakse andmed Google Drive'iga ainult WiFi- või Etherneti-ühenduse korral.

          Kui väärtus on seadmata või on väärtuseks seatud Väär, saavad kasutajad faile Google Drive'i edastada mobiiliühenduse kaudu.</translation>
<translation id="4655130238810647237">Lubab või keelab rakenduses <ph name="PRODUCT_NAME"/> järjehoidjate muutmise.

      Seade lubamisel saab järjehoidjaid lisada, eemaldada või muuta. See on vaikeseade ka juhul, kui reegel ei ole määratud.

      Seade keelamisel ei saa järjehoidjaid lisada, eemaldada ega muuta. Olemasolevad järjehoidjad on siiski saadaval.</translation>
<translation id="3496296378755072552">Paroolihaldur</translation>
<translation id="2565967352111237512">Võimaldab edastada Google'ile anonüümset teavet rakenduse <ph name="PRODUCT_NAME"/> kasutamise ja krahhide kohta ning takistab kasutajatel seade muutmist.

      Seade lubamisel saadetakse Google'ile anonüümset teavet kasutamise ja krahhide kohta.

      Seade keelamisel ei saadeta Google'ile kunagi anonüümset teavet kasutamise ja krahhide kohta.

      Seade lubamisel või keelamisel ei saa kasutajad seda seadet rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistad.

      Kui seda reeglit ei määrata, siis kasutatakse seadet, mille kasutaja valis installimisel või esmakordsel käitamisel.</translation>
<translation id="6256787297633808491">Süsteemiülesed märgised, mis rakendatakse Chrome'i käivitamisel</translation>
<translation id="2516600974234263142">Lubab printimise rakenduses <ph name="PRODUCT_NAME"/> ja takistab kasutajaid seadet muutmast.

      Kui seade on lubatud või seadistamata, saavad kasutajad printida.

      Kui seade on keelatud, ei saa kasutajad rakendusest <ph name="PRODUCT_NAME"/> printida. Printimine on keelatud mutrivõtmemenüüs, laiendustes, JavaScripti rakendustes ja mujal. Siiski on võimalik printida pistikprogrammides, mis lähevad printimiseks rakendusest <ph name="PRODUCT_NAME"/> mööda. Näiteks on teatud Flash-rakenduste kontekstimenüüs printimisvalik, mida see reegel ei mõjuta.</translation>
<translation id="9135033364005346124">Teenuse <ph name="CLOUD_PRINT_NAME"/> puhverserveri lubamine</translation>
<translation id="4519046672992331730">Lubab otsingusoovitused rakenduse <ph name="PRODUCT_NAME"/> omnikastikeses ja takistab kasutajatel seade muutmist.

      Seade lubamisel kasutatakse otsingusoovitusi.

      Seade keelamisel ei kasutata otsingusoovitusi.

      Seade lubamisel või keelamisel ei saa kasutajad seda rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistada.

      Kui jätate selle reegli määramata, siis see lubatakse, kuid kasutaja saab seda muuta.</translation>
<translation id="6943577887654905793">Maci/Linuxi eelistuse nimi:</translation>
<translation id="6925212669267783763">Seadistab kataloogi, mida <ph name="PRODUCT_FRAME_NAME"/> kasutab kasutajate andmete salvestamiseks.

      Kui selle reegli määrate, kasutab teenus <ph name="PRODUCT_FRAME_NAME"/> antud kataloogi.

      Saidilt http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables leiate loendi muutujatest, mida saate kasutada.

      Kui seda seadet ei määrata, kasutatakse profiili vaikekataloogi.</translation>
<translation id="8906768759089290519">Luba külastajarežiim</translation>
<translation id="2168397434410358693">Jõudeoleku viiteaeg võrgutoite kasutamisel</translation>
<translation id="838870586332499308">Luba andmeside rändlusteenus</translation>
<translation id="3234167886857176179">See on loetelu reeglitest, mida <ph name="PRODUCT_NAME"/> järgib.

      Te ei pea neid seadeid käsitsi muutma. Saate laadida alla lihtsalt kasutatavad mallid aadressilt
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>.

      Toetatud reeglite loend on Chromiumi ja Google Chrome'i puhul sama.

      Need reeglid on mõeldud ainult teie organisatsiooni Chrome'i eksemplaride seadistamiseks. Nende reeglite kasutamist väljaspool teie organisatsiooni (nt avalikult levitatud programmis) loetakse pahavara kasutamiseks ning Google ja viirusetõrjeteenuste pakkujad loevad selle tõenäoliselt pahavaraks.

      Märkus: Chrome 28-st alates laaditakse reeglid Windowsis otse Group Policy API kaudu. Registrisse käsitsi lisatud reegleid eiratakse. Üksikasju vaadake aadressilt http://crbug.com/259236.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME"/> saab kasutada Google'i veebiteenust, et aidata parandada õigekirjavigu. Kui seade on lubatud, siis kasutatakse teenust alati. Kui seade on keelatud, siis ei kasutata teenust kunagi.

      Õigekirjakontrolli saab siiski teha, kasutades selleks allalaaditud sõnastikku. Reegel haldab ainult veebiteenuse kasutamist.

      Kui seade pole seadistatud, siis saavad kasutajad valida, kas kasutada õigekirjakontrolli teenust või mitte.</translation>
<translation id="8782750230688364867">Määrab ekraani tumenduse viivituse skaleerimismäära protsentides, kui seade on esitlusrežiimis.

          Kui reegel kehtib, määratleb see ekraani tumenduse viivituse skaleerimismäära protsentides, kui seade on esitlusrežiimis. Ekraani tumenduse viivituse skaleerimisel reguleeritakse ekraani väljalülitumise, ekraaniluku ja tegevusetu oleku viivitusi, et säilitada ekraanitumenduse viivitusest samu kaugusi mis algselt seadistatud

          Kui reegel ei ole määratud, kasutatakse skaleerimise vaiketegurit.

          Skaleerimistegur peab olema vähemalt 100%. Väärtused, mis võivad teha ekraani tumenduse viivituse esitlusrežiimis lühemaks kui tavaline ekraani tumenduse viivitus, pole lubatud.</translation>
<translation id="254524874071906077">Sea Chrome vaikebrauseriks</translation>
<translation id="8764119899999036911">Määrab, kas loodud Kerberose SPN põhineb tavapärasel DNS-i nimel või sisestatud algsel nimel.

          Seade lubamisel jäetakse CNAME-i otsimine vahele ja serveri nime kasutatakse sisestatud kujul.

          Kui keelate seade või jätate selle määramata, siis määratakse serveri tavapärane nimi CNAME-i abil.</translation>
<translation id="5056708224511062314">Ekraaniluup on keelatud</translation>
<translation id="4377599627073874279">Luba kõikidel saitidel kõikide kujutiste kuvamine</translation>
<translation id="7195064223823777550">Määrake toiming, mis kaane sulgemisel tehakse.

          Kui see reegel on määratud, määrab see süsteemi <ph name="PRODUCT_OS_NAME"/> toimingu, kui kasutaja seadme kaane sulgeb.

          Kui jätate selle reegli määramata, tehakse vaiketoiming (peatamine).

          Kui toiming on peatamine, saab süsteemi <ph name="PRODUCT_OS_NAME"/> eraldi seadistada enne peatamist ekraani lukustama või seda mitte tegema.</translation>
<translation id="3915395663995367577">Puhverserveri pac-faili URL</translation>
<translation id="1022361784792428773">Laienduste ID-d, mida kasutajatel ei ole lubatud installida (märk * keelab kõik)</translation>
<translation id="5499375345075963939">Reegel on aktiivne ainult jaerežiimis.

      Kui reegli väärtus on määratud ja see ei ole 0, siis logitakse parasjagu sisselogitud demoversiooni kasutaja automaatselt välja pärast seda, kui määratud pikkusega mitteaktiivsuse perioodi lõpeb.

      Reegli väärtus peab olema määratud millisekundites.</translation>
<translation id="7683777542468165012">Dünaamiline reeglivärskendus</translation>
<translation id="1160939557934457296">Keela turvalise sirvimise hoiatuslehest edasiliikumine</translation>
<translation id="8987262643142408725">Keela SSL-kirje jagamine</translation>
<translation id="4529945827292143461">Kohandage URL-i mustrite loend, mille peab alati renderdama hostbrauser.

          Kui seda reeglit ei määrata, siis kasutatakse kõikide saitide puhul vaikerenderdajat, mis on määratud reegliga „ChromeFrameRendererSettings”.

          Vaadake näidismustreid aadressilt http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8044493735196713914">Teabe saatmine seadme käivitusrežiimi kohta</translation>
<translation id="2746016768603629042">Selle reegli tugi on katkestatud, kasutage selle asemel reeglit DefaultJavaScriptSetting.

      Seda saab kasutada JavaScripti keelamiseks tootes <ph name="PRODUCT_NAME"/>.

      Kui see seade keelatakse, ei saa veebilehed JavaScripti kasutada ja kasutaja ei saa seda seadet muuta.

      Kui see seade on lubatud või määramata, saavad veebilehed JavaScripti kasutada, kuid kasutajad saavad seda seadet muuta.</translation>
<translation id="4047207703890139433">Määrab seadme kellaaja vormingu. Kasutajad saavad tühistada praeguse seansi kellaaja vormingu, kuid väljalogimisel määratakse see tagasi seadistatud väärtusele. Kui edastatakse tühi string, siis kasutatakse seadme omaniku eelistust.</translation>
<translation id="1942957375738056236">Siin saate määrata puhverserveri URL-i.

          See reegel jõustub vaid juhul, kui valisite jaotises „Valige puhverserveri seadete määramise viis” puhverserveri käsitsi seadistamise.

          Jätke see reegel määramata, kui valisite puhverserveri reeglite määramiseks muu režiimi.

          Vaadake lisavalikuid ja üksikasjalikke näiteid aadressilt:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="6076008833763548615">Keelab ühendada välismäluseadmeid.

      Kui reegli olekuks on seatud True, siis ei ole välismäluseade failibrauseris saadaval.

      Reegel kehtib kõigile salvestusseadmete tüüpidele, näiteks USB välkmäludraivid, välised kõvakettad, SD-kaardid jm mälukaardid, optilised salvestusseadmed jne. See ei kehti sisemälu kohta, mistõttu kausta Allalaadimised salvestatud failidele on juurdepääs olemas. Reegel ei kehti ka Google Drive'ile.

      Kui seade on keelatud või pole seadistatud, siis saab seadmes kasutada kõiki toetatavaid välismälu tüüpe.</translation>
<translation id="6936894225179401731">Määrab puhverserveri samaaegsete ühenduste maksimumarvu.

      Mõned puhverserverid ei suuda töödelda suurt samaaegsete ühenduste arvu, mis pärinevad samalt kliendilt. Selle lahendamiseks seadke reeglis madalam väärtus.

      Reegli väärtus peab olema väiksem kui 100 ja suurem kui 6. Vaikeväärtus on 32.

      Mõned veebirakendused kasutavad hanguvate GET-de tõttu suurt ühenduste arvu. Seetõttu võib 32-st väiksema väärtuse kasutamisel brauser hanguda, kui on avatud palju veebirakendusi. Vaikeseadest väiksemat väärtust võite kasutada omal vastutusel.

      Kui reegel on määramata, siis kasutatakse vaikeväärtust 32.</translation>
<translation id="5395271912574071439">Võimaldab ühenduse ajal varjata kaugjuurdepääsu hoste.

          Kui see seade on lubatud, siis on hostide füüsilised sisend- ja väljundseadmed kaugühenduse ajal keelatud.

          Kui see seade on keelatud või määramata, saavad hostiga suhelda nii kohalikud kui ka kaugkasutajad, kui seda jagatakse.</translation>
<translation id="1426410128494586442">Jah</translation>
<translation id="4897928009230106190">Täpsustab parameetri, mida kasutatakse POST-meetodiga soovituse otsingu tegemisel. See koosneb komaga eraldatud nime/väärtuse paaridest. Kui väärtus on malliparameeter, nt {searchTerms} ülalolevas näites, siis asendatakse see otsingutermini andmetega.

          See reegel on valikuline. Kui see pole määratud, siis saadetakse soovituse otsingu taotlus GET-meetodiga.

          Reeglit järgitakse ainult siis, kui lubatud on reegel „DefaultSearchProviderEnabled”.</translation>
<translation id="4962195944157514011">Määrab vaikeotsingu puhul kasutatava otsingumootori URL-i. URL peab sisaldama stringi „<ph name="SEARCH_TERM_MARKER"/>”, mis asendatakse päringu ajal kasutaja sisestatud terminitega.

          Valik tuleb määrata ja seda rakendatakse vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="6009903244351574348">Lubage rakendusel <ph name="PRODUCT_FRAME_NAME"/> käsitleda loetletud sisutüüpe.

          Kui see reegel on määramata, kasutatakse kõikide saitide puhul vaikerenderdajat, mis on määratud reegliga „ChromeFrameRendererSettings”.</translation>
<translation id="3381968327636295719">Kasuta vaikimisi hostbrauserit</translation>
<translation id="3627678165642179114">Õigekirjakontrolli veebiteenuse lubamine või keelamine</translation>
<translation id="6520802717075138474">Impordi otsingumootorid vaikebrauserist esimesel käitamisel</translation>
<translation id="4039085364173654945">Juhib, kas lehel olev kolmanda osapoole alamsisu võib HTTP Basic Authi hüpikdialoogina avaneda.

          Tavaliselt on see andmepüügi eest kaitsmiseks keelatud. Kui see reegel ei ole määratud, siis see keelatakse ja kolmanda osapoole alamsisu ei saa HTTP Basic Authi hüpikdialoogina avaneda.</translation>
<translation id="4946368175977216944">Määrab märgised, mis tuleb Chrome'ile selle käivitamisel lisada. Määratud märgised lisatakse enne Chrome'i käivitamist isegi sisselogimisekraanil.</translation>
<translation id="7447786363267535722">Lubab paroolide salvestamise ja salvestatud paroolide kasutamise rakenduses <ph name="PRODUCT_NAME"/>.

          Seade lubamisel võivad kasutajad lasta rakendusel <ph name="PRODUCT_NAME"/> paroolid meelde jätta ja need järgmisel korral saitidele sisse logides automaatselt sisestada.

          Seade keelamisel ei saa kasutajad paroole salvestada ega varem salvestatud paroole kasutada.

          Seade lubamisel või keelamisel ei saa kasutajad seda rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistada.

          Kui jätate selle reegli määramata, siis see lubatakse, kuid kasutaja saab seda muuta.</translation>
<translation id="1138294736309071213">See reegel on aktiivne vaid jaemüügirežiimis.

      Määrab vahemiku, mille möödudes kuvatakse jaemüügirežiimis seadmete sisselogimiskuval ekraanisäästja.

      Määrake reegli väärtus millisekundites.</translation>
<translation id="6368011194414932347">Avalehe URL-i seadistamine</translation>
<translation id="2877225735001246144">Keela CNAME-i otsing Kerberose autentimise läbirääkimisel</translation>
<translation id="9120299024216374976">Määrab seadmes kasutatava ajavööndi. Kasutajad saavad käimasoleva seansi puhul määratud ajavööndi alistada. Väljalogimisel aga määratakse see tagasi määratud ajavööndile. Kui esitatakse kehtetu väärtus, aktiveeritakse reegel siiski „GMT” abil. Kui esitatakse tühi string, eiratakse reeglit.

      Kui seda reeglit ei kasutata, jääb kasutusse praegu aktiivne ajavöönd, kuid kasutajad saavad seda muuta ja muudatus jääb kehtima. Seega mõjutab ühe kasutaja tehtud muudatus sisselogimisekraani ja kõiki teisi kasutajaid.

      Uute seadmete puhul on ajavööndiks „USA / Vaikse ookeani aeg”.

      Väärtuse vorming järgneb ajavööndite nimedele loendis „IANA ajavööndite andmebaas” (vt saiti „http://en.wikipedia.org/wiki/List_of_tz_database_time”). Täpsemalt saab enamikule ajavöönditele viidata märksõnadega „kontinent/suur_linn” või „ookean/suur_linn&quot;.</translation>
<translation id="3646859102161347133">Ekraaniluubi tüübi määramine</translation>
<translation id="3528000905991875314">Luba alternatiivsed vealehed</translation>
<translation id="1283072268083088623">Määrab, milliseid HTTP-autentimisskeeme rakendus <ph name="PRODUCT_NAME"/> toetab.

          Võimalikud väärtused on „basic”, „digest”, „ntlm” ja „negotiate”. Eraldage väärtused komadega.

          Kui jätate selle reegli määramata, siis kasutatakse kõiki nelja skeemi.</translation>
<translation id="4914647484900375533">Lubab teenuse <ph name="PRODUCT_NAME"/> funktsiooni Instant ja takistab kasutajatel seda seadet muuta.

      Kui lubate selle seade, on <ph name="PRODUCT_NAME"/> Instant lubatud.

      Kui keelate selle seade, on <ph name="PRODUCT_NAME"/> Instant keelatud.

      Kui lubate või keelate seade, ei saa kasutajad seda muuta ega alistada.

      Kui jätate seade määramata, saavad kasutajad otsustada, kas seda funktsiooni kasutada või mitte.

      Chrome 29-st ja uuematest versioonidest on see seade eemaldatud.</translation>
<translation id="6114416803310251055">iganenud</translation>
<translation id="8493645415242333585">Keela brauseri ajaloo salvestamine</translation>
<translation id="5319306267766543020">Seadistage rakenduse <ph name="PRODUCT_OS_NAME"/> toitehaldus.

      Need reeglid võimaldavad teil seadistada, kuidas rakendus <ph name="PRODUCT_OS_NAME"/> käitub, kui kasutaja on teatud aja vältel tegevusetu.</translation>
<translation id="2747783890942882652">Seadistab nõutud domeeninime kaugjuurdepääsu hostidele ja takistab kasutajatel seda muuta.

          Kui seade on lubatud, siis saab hoste jagada ainult täpselt määratud domeeninimele registreeritud kontodelt.

          Kui seade on keelatud või pole määratud, siis saab hoste jagada mis tahes kontolt.</translation>
<translation id="6417861582779909667">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel ei ole lubatud küpsiseid määrata.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultCookiesSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="5457296720557564923">Võimaldab lehtedel hankida juurdepääsu JavaScripti mälu kasutusstatistikale.

      See seade muudab arendaja tööriistade profiilide paneeli mälustatistika veebilehele kättesaadavaks.</translation>
<translation id="5776485039795852974">Küsi iga kord, kui sait tahab näidata töölauateatisi</translation>
<translation id="5052081091120171147">Selle reegli lubamisel imporditakse sirvimisajalugu praegusest vaikebrauserist. Lubamisel mõjutab reegel ka importimisdialoogi.

      Reegli keelamisel sirvimisajalugu ei impordita.

      Kui jätate reegli määramata, siis võib importimine toimuda automaatselt või kasutajalt võidakse küsida, kas ta soovib importida.</translation>
<translation id="6786747875388722282">Laiendused</translation>
<translation id="8947415621777543415">Esita seadme asukoht</translation>
<translation id="1655229863189977773">Määrake ketta vahemälu suurus baitides</translation>
<translation id="6376842084200599664">Võimaldab teil määrata erandite loendi, mis installitakse taustal kasutajalt luba küsimata.

          Iga üksus selles loendis on string, mis sisaldab laienduse ID-d ja värskenduse URL-i, mis on eraldatud semikooloniga (<ph name="SEMICOLON"/>). Laienduse ID on 32-täheline string, mille leiab nt lehelt <ph name="CHROME_EXTENSIONS_LINK"/>, kui olete arendaja režiimis. Värskenduse URL peaks osutama värskenduse manifesti XML-dokumendile, mida kirjeldatakse dokumendis <ph name="LINK_TO_EXTENSION_DOC1"/>. Pidage meeles, et selles reeglis määratud värskenduse URL-i kasutatakse ainult esialgsel installimisel; laienduse järgmised värskendused kasutavad värskenduse URL-i, mis on antud laienduse manifestis.

          Iga üksuse puhul toob <ph name="PRODUCT_NAME"/> värskenduse teenusest (määratud värskenduse URL-ilt) laienduse ID poolt määratud laienduse ja installib selle taustal.

          Näiteks installib reegel <ph name="EXTENSION_POLICY_EXAMPLE"/> laienduse <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME"/> standardselt Chrome'i veebipoe värskenduse URL-ilt. Lisateavet laienduste hostimise kohta leiate dokumendist <ph name="LINK_TO_EXTENSION_DOC2"/>.

          Kasutajad ei saa desinstallida laiendusi, mis on selle reegliga määratud. Kui eemaldate sellest loendist laienduse, desinstallib <ph name="PRODUCT_NAME"/> selle automaatselt. Selles loendis määratud laiendused lisatakse installimiseks ka automaatselt lubatud loendisse; reegel ExtensionsInstallBlacklist neid ei mõjuta.

          Kui seda reeglit ei määrata, saab kasutaja tootes <ph name="PRODUCT_NAME"/> desinstallida iga laienduse.</translation>
<translation id="6899705656741990703">Tuvasta puhverserveri seaded automaatselt</translation>
<translation id="7003334574344702284">Reegli lubamisel imporditakse salvestatud paroolid eelmisest vaikebrauserist. Lubamisel mõjutab reegel ka importimisdialoogi.

      Reegli keelamisel salvestatud paroole ei impordita.

      Kui jätate selle reegli määramata, siis võib importimine toimuda automaatselt või kasutajalt võidakse küsida, kas ta soovib importida.</translation>
<translation id="6258193603492867656">Määrab, kas Kerberose SPN peab hõlmama ebastandardset porti.

          Seade lubamisel ja ebastandardse pordi sisestamisel (nt muu port kui 80 või 443) lisatakse see loodud Kerberose SPN-i.

          Seade keelamisel või määramata jätmisel ei hõlma loodud Kerberose SPN ühtki porti.</translation>
<translation id="3236046242843493070">URL-ide mustrid, millelt on lubatud installida laiendusi, rakendusi ja kasutaja skripte</translation>
<translation id="2498238926436517902">Peida hoidla alati automaatselt</translation>
<translation id="253135976343875019">Tegevusetuse hoiatuse viivitus vahelduvvoolutoite kasutamisel</translation>
<translation id="6997592395211691850">Kas OCSP/CRL-i onlain-kontroll on vajalikud kohalike usaldusvõtmete puhul või mitte</translation>
<translation id="152657506688053119">Asendus-URL-ide loend vaikeotsingupakkujale</translation>
<translation id="8992176907758534924">Keela kõigil saitidel kujutiste näitamine</translation>
<translation id="262740370354162807">Luba dokumentide saatmine teenusesse <ph name="CLOUD_PRINT_NAME"/></translation>
<translation id="7717938661004793600">Seadistage teenuse <ph name="PRODUCT_OS_NAME"/> juurdepääsufunktsioonid.</translation>
<translation id="5182055907976889880">Google Drive'i seadistamine teenuses <ph name="PRODUCT_OS_NAME"/>.</translation>
<translation id="8704831857353097849">Keelatud pistikprogrammide loend</translation>
<translation id="8391419598427733574">Saadab registreeritud seadmete operatsioonisüsteemi ja püsivara versiooni.
Seade lubamisel saadavad registreeritud seadmed regulaarselt teavet operatsioonisüsteemi ja püsivara versiooni kohta. Kui jätate seade määramata või keelate selle, siis ei saadeta versiooniteavet.</translation>
<translation id="467449052039111439">Ava URL-ide loend</translation>
<translation id="5883015257301027298">Küpsiste vaikeseade</translation>
<translation id="5017500084427291117">Blokeerib juurdepääsu loetletud URL-idele.

      See reegel takistab kasutajaid laadimast veebilehti, mille URL-id on mustas loendis.

      URL-i vorming on „scheme://host:port/path”.
      Valikuline skeem võib olla http, https või ftp. Blokeeritakse ainult see skeem. Kui ühtki skeemi ei määrata, siis blokeeritakse kõik skeemid.
      Host võib olla hosti nimi või IP-aadress. Hosti nime alamdomeenid blokeeritakse samuti. Alamdomeenide blokeerimise vältimiseks lisage hosti nime ette punkt (.). Spetsiaalne hosti nimi „*” blokeerib kõik domeenid.
      Valikuline port on kehtiv port vahemikus 1 kuni 65 535. Kui porti ei määrata, siis blokeeritakse kõik pordid.
      Valikulise tee määramisel blokeeritakse vaid selle eesliitega teed.

      Erandeid saab määrata lubatud URL-ide loendi reeglis. Reeglis võib olla kuni 1000 kirjet, ülejäänud kirjeid eiratakse.

      Kui seda reeglit ei määrata, siis ei lisata brauseris ühtki URL-i musta loendisse.</translation>
<translation id="2762164719979766599">Määrab loendi seadmepõhistest kontodest, mis ilmuvad sisselogimiskuval.

      Loendi iga kirje määrab identifikaatori, mida kasutatakse seesmiselt seadmepõhiste kontode eristamiseks.</translation>
<translation id="8955719471735800169">Tagasi üles</translation>
<translation id="2534584045044686957">Seadistab vahemälu suuruse, mida <ph name="PRODUCT_NAME"/> kasutab vahemällu pandud meediafailide salvestamiseks kettale.

      Kui määrate selle reegli, kasutab <ph name="PRODUCT_NAME"/> olemasolevat vahemälu suurust sõltumata sellest, kas kasutaja on märgistuse „--media-cache-size” määranud või mitte.

      Kui reegli väärtus on 0, siis kasutatakse vahemälu vaikesuurust, kuid kasutaja ei saa seda muuta.

      Kui reegel pole määratud, siis kasutatakse vaikemahtu ja kasutaja saab selle alistada märgistusega „--media-cache-size”.</translation>
<translation id="3723474915949495925">Määrab pistikprogrammide loendi, mida kasutaja saab rakenduses <ph name="PRODUCT_NAME"/> lubada või keelata.

      Metamärke „*” ja „?” saab kasutada määramata märgijadade vastendamiseks. Metamärk „*” vastendab suvalise arvu märke ja metamärk „?” määrab valikulise üksiku märgi, st see vastab ühele või mitte ühelegi märgile. Paomärk on „\”, seetõttu saate märkide „*”, „?” ja „\” vastendamiseks lisada nende ette paomärgi „\”.

     Seade lubamisel saab loendis olevaid pistikprogramme kasutada rakenduses <ph name="PRODUCT_NAME"/>. Kasutajad saavad need jaotises „about:plugins” lubada või keelata ka juhul, kui pistikprogrammile leidub reegli DisabledPlugins mustrite hulgas mõni vaste. Samuti saavad kasutajad lubada või keelata pistikprogramme, millele reeglite DisabledPlugins, DisabledPluginsExceptions ja EnabledPlugins mustrite hulgast ühtegi vastet ei leita.

      Reegel võimaldab koostada pistikprogrammide täpse musta nimekirja, kus loend „DisabledPlugins” sisaldab metamärke, nt kõigi pistikprogrammide keelamise märki „*” või kõigi Java pistikprogrammide keelamise märki „*Java”, kuid mille puhul administraator soovib lubada mõnd kindlat versiooni, nt „IcedTea Java 2.3”. Selles reeglis saab niisugused konkreetsed versioonid määrata.

      Kui reegel on jäetud määramata, siis lukustatakse ja keelatakse kõik pistikprogrammid, millele leidub reegli „DisabledPlugins” mustrite hulgas vaste, ning kasutaja ei saa neid lubada.</translation>
<translation id="546726650689747237">Ekraani hämardamise viiteaeg võrgutoite kasutamisel</translation>
<translation id="4988291787868618635">Tehtav toiming, kui möödub jõudeoleku viiteaeg</translation>
<translation id="5316405756476735914">Võimaldab määrata, kas veebisaitidel on lubatud määrata kohalikke andmeid. Kohalike andmete määramine võib olla kõikidel veebisaitidel lubatud või keelatud. Kui jätate selle reegli määramata, siis kasutatakse reeglit „AllowCookies” ja kasutaja saab seda muuta.</translation>
<translation id="4250680216510889253">Ei</translation>
<translation id="1522425503138261032">Luba saitidel kasutaja füüsilist asukohta jälgida</translation>
<translation id="6467433935902485842">Võimaldab teil määrata URL-i mustrite loendi, mis määravad saidid, millel ei ole lubatud pistikprogramme käitada.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust reeglist „DefaultPluginsSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="4423597592074154136">Puhverserveri seadete määramine käsitsi</translation>
<translation id="209586405398070749">Stabiilne kanal</translation>
<translation id="8170878842291747619">Lubab integreeritud Google'i tõlketeenuse rakenduses <ph name="PRODUCT_NAME"/>.

      Kui lubate seade, siis kuvab rakendus <ph name="PRODUCT_NAME"/> integreeritud tööriistariba, mille abil saab kasutaja võimaluse korral lehe tõlkida.

      Seade keelamisel ei kuvata kasutajatele tõlkeriba.

      Seade lubamisel või keelamisel ei saa kasutajad seadet rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistada.

      Kui jätate seade määramata, siis saavad kasutajad otsustada, kas nad soovivad funktsiooni kasutada.</translation>
<translation id="9035964157729712237">Mustast nimekirjast välistatud laienduste ID-d</translation>
<translation id="8244525275280476362">Maksimaalne toomisviivitus pärast reegli kehtetuks tunnistamist</translation>
<translation id="8587229956764455752">Luba uute kasutajakontode loomine</translation>
<translation id="7417972229667085380">Esitlusrežiimis tegevusetu oleku viivituse skaleerimise määr protsentides (tugi on katkestatud)</translation>
<translation id="3964909636571393861">Võimaldab juurdepääsu URL-ide loendile</translation>
<translation id="3450318623141983471">Saadab teavet seadme arendaja lüliti oleku kohta käivitamisel. Kui jätate selle reegli määramata või keelate selle, siis ei saadeta teavet arendaja lüliti kohta.</translation>
<translation id="1811270320106005269">Lubab lukustuse, kui teenuse <ph name="PRODUCT_OS_NAME"/> seadmed on peatatud või jõudeolekus.

      Kui lubate seade, siis palutakse kasutajal seadme äratamiseks sisestada parool.

      Seade keelamisel ei paluta kasutajal seadme äratamiseks parooli sisestada.

      Kui lubate või keelate selle seade, ei saa kasutajad seda muuta ega alistada.

      Kui jätate selle reegli määramata, siis saab kasutaja valida, kas ta soovib seadme äratamisel parooli sisestada.</translation>
<translation id="6022948604095165524">Toiming käivitamisel</translation>
<translation id="9042911395677044526">Võimaldab võrguseadistuse kasutajapõhiselt teenuse <ph name="PRODUCT_OS_NAME"/> seadmes jõustada. Võrguseadistus on JSON-i vormingus string, mille määratleb Open Network Configuration vorming, mida kirjeldatakse aadressil <ph name="ONC_SPEC_URL"/></translation>
<translation id="7128918109610518786">Loetleb rakenduste identifikaatorid, mida <ph name="PRODUCT_OS_NAME"/> näitab käivitusribal kinnitatud rakendustena.

      Kui eeskiri on seadistatud, on rakenduste kogum fikseeritud ja kasutaja ei saa seda muuta.

      Kui jätate eeskirja määramata, siis võib kasutaja käivitis kinnitatud rakenduste loendit muuta.</translation>
<translation id="1679420586049708690">Avalik seanss automaatseks sisselogimiseks</translation>
<translation id="7625444193696794922">Määrab väljalaskekanali, millele seade tuleks lukustada.</translation>
<translation id="2552966063069741410">Ajavöönd</translation>
<translation id="2240879329269430151">Võimaldab määrata, kas veebisaitidel on lubatud kuvada hüpikaknaid. Hüpikaknad võib kõikide veebisaitide puhul lubada või keelata.

          Kui jätate reegli määramata, siis kasutatakse reeglit „BlockPopups” ja kasutaja saab seda muuta.</translation>
<translation id="2529700525201305165">Piira kasutajaid, kes saavad logida sisse rakendusse <ph name="PRODUCT_NAME"/></translation>
<translation id="8971221018777092728">Avaliku seansi automaatse sisselogimise ajasti</translation>
<translation id="8285435910062771358">Täisekraani luup on lubatud</translation>
<translation id="5141670636904227950">Lubage ekraaniluubi vaiketüüp sisselogimisekraanil</translation>
<translation id="3864818549971490907">Pistikprogrammide vaikeseade</translation>
<translation id="7151201297958662315">Määrab, kas operatsioonisüsteemi sisselogimisel käivitub teenuse <ph name="PRODUCT_NAME"/> toiming ja jätkab töötamist pärast viimase brauseriakna sulgemist. See võimaldab taustarakendustel töötamist jätkata. Taustatoiming kuvab süsteemisalves ikooni, mis võimaldab selle igal ajal sulgeda.

      Kui see reegel on lubatud, siis lubatakse taustarežiim ja kasutaja ei saa seda brauseri seadetes muuta.

      Kui see reegel on keelatud, siis keelatakse taustarežiim ja kasutaja ei saa seda brauseri seadetes muuta.

      Kui jätate selle reegli määramata, siis on taustarežiim esmalt keelatud ja kasutaja saab seda brauseri seadetes muuta.</translation>
<translation id="4320376026953250541">Microsoft Windows XP SP2 või uuem</translation>
<translation id="5148753489738115745">Võimaldab teil määrata täiendavad parameetrid, mida kasutatakse siis, kui <ph name="PRODUCT_FRAME_NAME"/> käivitab rakenduse <ph name="PRODUCT_NAME"/>.

          Kui jätate eeskirjad määramata, siis kasutatakse vaikekäsurida.</translation>
<translation id="2646290749315461919">Võimaldab määrata, kas veebisaitidel on lubatud jälgida kasutajate füüsilist asukohta. Kasutajate füüsilise asukoha jälgimine võib olla vaikimisi lubatud või keelatud või kasutajalt võidakse luba küsida iga kord, kui veebisait taotleb füüsilise asukoha jälgimist.

          Kui jätate selle reegli määramata, siis kasutatakse reeglit „AskGeolocation” ja kasutaja saab seda muuta.</translation>
<translation id="6394350458541421998">Reegel on alates rakenduse <ph name="PRODUCT_OS_NAME"/> versioonist 29 kasutusest kõrvaldatud. Kasutage selle asemel reeglit PresentationScreenDimDelayScale.</translation>
<translation id="5770738360657678870">Arendaja kanal (võib olla ebastabiilne)</translation>
<translation id="2959898425599642200">Puhverserveri möödumisreeglid</translation>
<translation id="228659285074633994">Määrab aja, pärast mida kuvatakse vahelduvvoolutoite kasutamisel hoiatusdialoog, kui kasutaja pole midagi sisestanud.

          Kui see reegel on määratud, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui teenus <ph name="PRODUCT_OS_NAME"/> kuvab hoiatusdialoogi, teavitades kasutajat tegevusetu oleku peatsest toimingust.

          Kui seda reeglit pole määratud, siis hoiatusdialoogi ei kuvata.

          Reegli väärtus tuleb määrata millisekundites. Väärtus peab olema tegevusetuse viivitusest väiksem või sellega võrdne.</translation>
<translation id="1098794473340446990">Saadab teavet seadme aktiivsuse aja kohta.
Seade lubamisel saadavad registreeritud seadmed teavet ajaperioodide kohta, mil kasutaja seadet kasutab. Kui jätate seade määramata või keelate selle, siis ei talletata ega saadeta teavet seadme aktiivsuse aja kohta.</translation>
<translation id="7937766917976512374">Video jäädvustamise lubamine või keelamine</translation>
<translation id="427632463972968153">Täpsustab parameetri, mida kasutatakse POST-meetodiga soovituse otsingu tegemisel. See koosneb komaga eraldatud nime/väärtuse paaridest. Kui väärtus on malliparameeter, nt {imageThumbnail} ülalolevas näites, siis asendatakse see pisipildi andmetega.

          See reegel on valikuline. Kui see pole määratud, siis saadetakse soovituse otsingu taotlus GET-meetodiga.

          Reeglit järgitakse ainult siis, kui lubatud on reegel „DefaultSearchProviderEnabled”.</translation>
<translation id="8818646462962777576">Selles loendis olevaid mustreid võrreldakse taotleva URL-i
      algse turvalisusega. Vaste leidmisel antakse juurdepääs
      helijäädvustusseadmetele ilma küsimata.

      MÄRKUS. Reeglit toetatakse praegu ainult kioskirežiimis.</translation>
<translation id="489803897780524242">Parameeter, mis juhib otsingutermini paigutust vaikeotsingupakkuja puhul</translation>
<translation id="316778957754360075">See seade on alates rakenduse <ph name="PRODUCT_NAME"/> versioonist 29 kasutusest kõrvaldatud. Organisatsiooni majutatud laienduse-/rakendusekogude seadistamiseks on soovitatav kaasata sait, mis hostib üksuses ExtensionInstallSources CRX-pakette ja paneb pakettide allalaadimise otselingid veebilehele. Selle veebilehe käivitaja saab luua reegliga ExtensionInstallForcelist.</translation>
<translation id="6401669939808766804">Kasutaja väljalogimine</translation>
<translation id="4826326557828204741">Toiming, mis rakendub siis, kui tegevusetuse viivitusaeg saab täis akutoite kasutamise ajal</translation>
<translation id="7912255076272890813">Seadista lubatud rakenduste/laienduste tüübid</translation>
<translation id="817455428376641507">Lubab juurdepääsu loendis olevatele URL-idele, mis on URL-ide mustas loendis olevate erandid.

      Vaadake URL-ide musta loendi reegli kirjeldust, kust leiate selle loendi kirjete vormingu.

      Selle reegliga saab avada piiravate mustade loendite erandid. Näiteks saab kõigi päringute blokeerimiseks musta loendisse lisada märgi „*” ja selle reegliga saab lubada juurdepääsu URL-ide piiratud loendile. Sellega saab avada teatud teede, teiste domeenide alamdomeenide, portide või konkreetsete teede erandid.

      Kõige konkreetsem filter määrab, kas URL blokeeritakse või lubatakse. Lubatute üksuste loend on tähtsam kui must loend.

      Reeglis võib olla kuni 1000 kirjet, ülejäänud kirjeid eiratakse.

      Kui seda reeglit ei määrata, siis ei ole reegli „URLBlacklist” mustas loendis erandeid.</translation>
<translation id="4163644371169597382">Ettevõtte seadmete IT-administraatorid saavad selle märgistuse abil juhtida, kas lubada kasutajatel pakkumisi lunastada Chrome OS-i registreerimise abil.

      Kui see reegel määratakse tõeseks või seda ei määrata, saavad kasutajad pakkumisi lunastada Chrome OS-i registreerimise abil.

      Kui see reegel määratakse valeks, ei saa kasutajad pakkumisi lunastada.</translation>
<translation id="8148901634826284024">Suure kontrastsusega režiimi hõlbustusfunktsiooni lubamine.

          Kui reegel on seatud väärtusele Tõene, on suure kontrastsusega režiim alati lubatud.

          Kui reegel on seatud väärtusele Väär, on suure kontrastsusega režiim alati keelatud.

          Kui määrate reegli, ei saa kasutajad seda muuta ega alistada.

          Kui jätate reegli määramata, on suure kontrastsusega režiim algselt keelatud, kuid kasutaja võib selle igal ajal lubada.</translation>
<translation id="6177482277304066047">Määrab sihtversiooni automaatsete värskenduste jaoks.

      Määrab eesliite sihtversioonile, millele <ph name="PRODUCT_OS_NAME"/> peab värskendama. Kui seade käitab versiooni, mis eelneb määratud eesliitele, värskendatakse see antud eesliite uusimale versioonile. Kui seade kasutab juba uuemat versiooni, siis sellel mõju pole (st ei toimu üleminekut vanemale versioonile) ja seade jääb praegusele versioonile. Eesliite vorming töötab komponendipõhiselt, nagu näha järgmises näites.

      &quot;&quot; (või seadistamata): saadaval värskendus uusimale versioonile.
      &quot;1412.&quot;: värskendus mis tahes 1412 uuemale versioonile (nt 1412.24.34 või 1412.60.2)
      &quot;1412.2.&quot;: värskendus mis tahes 1412.2 uuemale versioonile (nt 1412.2.34 või 1412.2.2)
      &quot;1412.24.34&quot;: värskendus ainult sellele konkreetsele versioonile</translation>
<translation id="8102913158860568230">Meediavoo vaikeseade</translation>
<translation id="6641981670621198190">Keela 3D-graafika API-liideste tugi</translation>
<translation id="7929480864713075819">Mäluandmete (JS kuhja maht) aruandluse lubamine lehele</translation>
<translation id="5703863730741917647">Määrab toimingu, mis rakendub tegevusetuse viivitusaja täitumisel.

          Pange tähele, et seda reeglit enam ei toetata ja see eemaldatakse tulevikus.

          See reegel pakub varuväärtust täpsematele reeglitele <ph name="IDLEACTIONAC_POLICY_NAME"/> ja <ph name="IDLEACTIONBATTERY_POLICY_NAME"/>. Kui määrate selle reegli, siis kasutatakse selle väärtusi juhul, kui vastavaid täpsemaid reegleid pole määratud.

          Kui reegel on määramata, siis ei mõjuta see täpsemate reeglite toimimist.</translation>
<translation id="5997543603646547632">Vaikimisi 24-tunnise kella kasutamine</translation>
<translation id="7003746348783715221">Rakenduse <ph name="PRODUCT_NAME"/> eelistused</translation>
<translation id="4723829699367336876">Luba tulemüüri läbimine kaugjuurdepääsu kliendist</translation>
<translation id="6367755442345892511">Määramine, kas kasutajal on võimalik versiooni kanalit seadistada</translation>
<translation id="4035570660718398959">Lubage kasutajatel pakkumisi lunastada Chrome OS-i registreerimise abil.</translation>
<translation id="3868347814555911633">Reegel on aktiivne ainult jaerežiimis.

      Loetleb laiendused, mis laaditakse automaatselt demo kasutajale jaerežiimis seadmete jaoks. Laiendused salvestatakse seadmesse ja need saab hiljem installida võrguühenduseta.

      Iga loendi kirje sisaldab sõnastikku, mis peab väljal „extension-id” sisaldama laienduse ID-d ja väljal „update-url” värskenduse URL-i.</translation>
<translation id="9096086085182305205">Autentimisserveri lubatud nimekiri</translation>
<translation id="4980301635509504364">Video jäädvustamise lubamine või keelamine.

      Kui reegel on lubatud või seadistamata (vaikeseade), küsitakse kasutajalt
      video jäädvustamiseks juurdepääsu, v.a loendis VideoCaptureAllowedUrls 
      seadistatud URL-ide puhul, millele antakse juurdepääs ilma küsimata.

      Kui reegel on keelatud, ei küsita kasutajalt kunagi ja video jäädvustamine
      on saadaval ainult loendis VideoCaptureAllowedUrls seadistatud URL-idele.

      Reegel mõjutab igat tüüpi videosisendeid, mitte ainult sisseehitatud kaamerat.</translation>
<translation id="7063895219334505671">Luba hüpikaknad nendel saitidel</translation>
<translation id="4052765007567912447">Juhib, kas kasutaja võib paroolihalduses paroole tavatekstina vaadata.

          Seade keelamisel ei luba paroolihaldur salvestatud paroole paroolihalduri aknas tavatekstina kuvada.

          Kui lubate reegli või jätate selle määramata, siis saavad kasutajad paroolihalduris paroole tavatekstina vaadata.</translation>
<translation id="5213629107215526747">URL-id, millele antakse juurdepääs videojäädvustusseadmetele ilma küsimata.</translation>
<translation id="5936622343001856595">Sunnib Google'i veebiotsingute tegemisel kasutama SafeSearchi ja takistab kasutajaid seadet muutmast.

      Seade lubamisel on Google'i otsingu funktsioon SafeSearch alati aktiivne.

      Kui keelate seade või ei määra väärtust, ei jõustata Google'i otsingus SafeSearchi kasutamist.</translation>
<translation id="6017568866726630990">Kuvab printimise eelvaate asemel süsteemi printimisdialoogi.

      Kui seade on lubatud ja kasutaja soovib lehte printida, avab <ph name="PRODUCT_NAME"/> süsteemi printimisdialoogi, mitte sisseehitatud printimise eelvaate.

      Kui reegel on määramata või keelatud, ilmub printimiskäsu sisestamisel printimise eelvaate kuva.</translation>
<translation id="2824715612115726353">Luba inkognitorežiim</translation>
<translation id="1057535219415338480">Lubab tootes <ph name="PRODUCT_NAME"/> võrguprognoosid ja keelab kasutajatel selle seade muutmise.

      See ei juhi mitte ainult DNS-i eeltoomist, vaid ka veebilehtede TCP ja SSL-i eelühendamist ning eelrenderdust. See reegli nimi viitab ajaloolistel põhjustel DNS-i eeltoomisele.

      Kui selle seade lubate või keelate, ei saa kasutajad seda seadet tootes <ph name="PRODUCT_NAME"/> muuta ega alistada.

      Kui see reegel jäetakse määramata, on see lubatud, kuid kasutaja saab seda muuta.</translation>
<translation id="4541530620466526913">Seadmepõhised kontod</translation>
<translation id="5815129011704381141">Automaatne taaskäivitamine pärast värskendamist</translation>
<translation id="1757688868319862958">Võimaldab tootel <ph name="PRODUCT_NAME"/> käitada pistikprogramme, mille jaoks on vajalik volitamine. Kui lubate selle seade, töötavad pistikprogrammid, mis ei ole aegunud, alati. Kui see seade on keelatud või pole määratud, palutakse kasutajatelt volitust vajavate pistikprogrammide käitamiseks luba. Need on pistikprogrammid, mis võivad turvalisust ohustada.</translation>
<translation id="6392973646875039351">Lubab rakenduse <ph name="PRODUCT_NAME"/> automaatse täitmise funktsiooni ja võimaldab kasutajatel varem talletatud teabe, näiteks aadressi ja krediitkaardi andmete, alusel veebivorme automaatselt täita.

      Seade keelamisel ei saa automaatset täitmist kasutada.

      Kui lubate seade või ei määra väärtust, siis saab kasutaja automaatset täitmist juhtida. See võimaldab neil seadistada automaatse täitmise profiile ning automaatse täitmise soovi korral sisse või välja lülitada.</translation>
<translation id="6157537876488211233">Puhverserveri möödumisreeglite komadega eraldatud loend</translation>
<translation id="7788511847830146438">Profiilipõhine</translation>
<translation id="2516525961735516234">Määrab, kas videotoimingud mõjutavad toitehaldust.

          Kui reegel määratakse tõeseks või jäetakse määramata, ei peeta kasutajat video esitamise ajal tegevusetuks. Nii ei jõuta tegevusetuse viivituseni, ekraani hämardamise viivituseni, ekraani väljalülitamise viivituseni ega ekraani lukustamise viivituseni ning vastavaid toiminguid ei tehta.

          Kui reegel määratakse valeks, ei mõjuta videotoimingud kasutaja tegevusetuse määramist.</translation>
<translation id="3965339130942650562">Ajalõpp kuni jõudeolekus kasutaja väljalogimiseni</translation>
<translation id="5814301096961727113">Sisselogimisekraanil suulise tagasiside vaikeoleku määramine</translation>
<translation id="9084985621503260744">Määrake, kas videotoimingud mõjutavad toitehaldust</translation>
<translation id="7091198954851103976">Käitab alati pistikprogrammid, mis vajavad volitamist</translation>
<translation id="1708496595873025510">Piirangu määramine variatsioonide lähteväärtuse toomisele</translation>
<translation id="8870318296973696995">Avaleht</translation>
<translation id="1240643596769627465">Määrab otsingumootori URL-i, mida kasutatakse vahetute (instant) otsingutulemuste esitamiseks. URL peab sisaldama stringi <ph name="SEARCH_TERM_MARKER"/>, mis asendatakse päringu tegemisel kasutaja sisestatud tekstiga.

          Reegel on valikuline. Kui jätate selle määramata, siis ei esitata vahetuid otsingutulemusi.

          See reegel kehtib vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="6693751878507293182">Seade lubamisel keelatakse rakenduses <ph name="PRODUCT_NAME"/> automaatne otsing ja puuduvate pistikprogrammide installimine.

      Kui keelate valiku või jätate selle määramata, siis on pistikprogrammide leidja aktiivne.</translation>
<translation id="2650049181907741121">Tehtav toiming, kui kasutaja kaane sulgeb</translation>
<translation id="7880891067740158163">Võimaldab luua URL-i mustrite loendi, mis määrab saidid, mille puhul peab <ph name="PRODUCT_NAME"/> automaatselt valima kliendi sertifikaadi, kui sait taotleb sertifikaati.

          Kui jätate selle reegli määramata, siis ei toimu automaatset valimist ühegi saidi puhul.</translation>
<translation id="3866249974567520381">Kirjeldus</translation>
<translation id="5192837635164433517">Lubab alternatiivsed vealehed, mis on rakendusse <ph name="PRODUCT_NAME"/> sisse ehitatud (näiteks teade „lehte ei leitud”), ja takistab kasutajatel seade muutmist.

      Seade lubamisel kasutatakse alternatiivseid vealehti.

      Seade keelamisel ei kasutata kunagi alternatiivseid vealehti.

      Seade lubamisel või keelamisel ei saa kasutajad seda rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistada.

      Kui jätate selle reegli määramata, siis see lubatakse, kuid kasutaja saab seda muuta.</translation>
<translation id="2236488539271255289">Keela kõigil saitidel kohalike andmete seadmine</translation>
<translation id="4467952432486360968">Blokeeri kolmanda osapoole küpsised</translation>
<translation id="2041396837791669429">Blokeeri juurdepääs sisupaketivälistele saitidele.</translation>
<translation id="1305864769064309495">Sõnastik, mis kaardistab URL-e kahendmuutuja märgisega ja määrab, kas hostile tuleb juurdepääs lubada (tõene) või blokeerida (väär).

          Reegel on mõeldud Chrome'ile sisekasutuseks.</translation>
<translation id="5586942249556966598">Ära tee midagi</translation>
<translation id="131353325527891113">Kuva kasutajanimed sisselogimiskuval</translation>
<translation id="5317965872570843334">Lubab STUN-i ja vaheserverite kasutamise, kui kaugkliendid proovivad luua ühenduse selle seadmega.

          Seade lubamisel saavad kaugkliendid seadme leida ja sellega ühenduse luua isegi juhul, kui neid eraldab tulemüür.

          Kui seade on keelatud ja tulemüür filtreerib väljuvad UDP-ühendused, siis lubab masin klientmasinatest tulevaid ühendusi vaid kohalikus võrgus.

          Kui jätate selle reegli määramata, siis seade lubatakse.</translation>
<translation id="5365946944967967336">Kuva tööriistaribal nuppu Avaleht</translation>
<translation id="3709266154059827597">Laienduste installimise musta nimekirja seadistamine</translation>
<translation id="8451988835943702790">Kasuta avalehena Uut vahelehte</translation>
<translation id="8469342921412620373">Lubab vaikeotsingupakkuja kasutamise.

          Seade lubamisel tehakse vaikeotsing, kui kasutaja sisestab omnikastikesse teksti, mis ei ole URL.

          Võite valida kasutatava vaikeotsingupakkuja, määrates muud vaikeotsingu reeglid. Kui need jäetakse tühjaks, siis saab kasutaja valida vaikeotsingupakkuja.

          Seade keelamisel ei toimu otsingut, kui kasutaja sisestab omnikastikesse teksti, mis ei ole URL.

          Seade lubamisel või keelamisel ei saa kasutajad seda seadet rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistada.

          Kui jätate selle reegli määramata, siis lubatakse vaikeotsingupakkuja ja kasutaja saab määrata otsingupakkujate loendi.</translation>
<translation id="4791031774429044540">Suure kursori hõlbustusfunktsiooni lubamine.

          Kui reegel on seatud väärtusele Tõene, on suur kursor alati lubatud.

          Kui reegel on seatud väärtusele Väär, on suur kursor alati keelatud.

          Kui määrate reegli, ei saa kasutajad seda muuta ega alistada.

          Kui jätate reegli määramata, on suur kursor algselt keelatud, kuid kasutaja võib selle igal ajal lubada.</translation>
<translation id="2633084400146331575">Luba suuline tagasiside</translation>
<translation id="7712008868843631413">Valvatavate kasutajate lubamine.</translation>
<translation id="8731693562790917685">Sisu seaded võimaldavad teil määrata, kuidas kindlat tüüpi sisu (näiteks küpsiseid, kujutisi või JavaScripti) käsitletakse.</translation>
<translation id="2411919772666155530">Blokeerige märguanded nendel saitidel</translation>
<translation id="6923366716660828830">Määrab vaikeotsingupakkuja nime. Kui see jäetakse tühjaks või määramata, siis kasutatakse otsingu URL-i määratud hosti nime.

          See reegel kehtib vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="4869787217450099946">Määrab, kas ekraani aktiveerimise lukustamine on lubatud. Ekraani aktiveerimise lukustamist saab taotleda laiendustega energiahalduse laienduse API kaudu.

          Kui see reegli väärtuseks on seatud Tõene või on väärtus seadmata, kasutatakse energiahalduseks ekraani aktiveerimise lukustamist.

          Kui reegli väärtuseks on seatud Väär, siis ekraani aktiveerimise lukustamise taotlust eiratakse.</translation>
<translation id="467236746355332046">Toetatud funktsioonid:</translation>
<translation id="7632724434767231364">GSSAPI-teegi nimi</translation>
<translation id="3038323923255997294">Jätka taustarakenduste käitamist pärast rakenduse <ph name="PRODUCT_NAME"/> sulgemist</translation>
<translation id="4652284479838524692">Seadme kaugkinnituse lubamine.</translation>
<translation id="8909280293285028130">Määrab aja, pärast mida lukustatakse võrgutoitega töötamisel ekraan, kui kasutaja pole midagi sisestanud.

          Kui selle reegli väärtuseks määratakse arv, mis on suurem kui null, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui <ph name="PRODUCT_OS_NAME"/> ekraani lukustab.

          Kui reegli väärtuseks on määratud null, ei lukusta <ph name="PRODUCT_OS_NAME"/> ekraani, kui kasutaja on tegevusetu.

          Kui jätate selle reegli määramata, kasutatakse vaikeaega.

          Soovitatav on ekraan jõudeolekus lukustada nii, et ekraan lukustatakse seadme peatamisel ja <ph name="PRODUCT_OS_NAME"/> peatub pärast jõudeoleku viiteaega. Seda reeglit tuleks kasutada vaid siis, kui ekraani lukustamine peab toimuma tükk aega enne seadme peatamist või seadme peatamist jõudeolekus üldse ei soovita.

          Reegli väärtus tuleb määrata millisekundites. Väärtused tuleb kinnitada väiksematena kui jõudeoleku viiteaeg.</translation>
<translation id="7651739109954974365">Määrab, kas seadmes on andmeside rändlusteenus lubatud. Selle reegli aktiveerimisel on andmeside rändlusteenus lubatud. Kui jätate selle reegli seadistamata või keelate, siis ei ole andmeside rändlusteenus saadaval.</translation>
<translation id="6244210204546589761">Käivitamisel avatavad URL-id</translation>
<translation id="7468416082528382842">Windowsi registri asukoht:</translation>
<translation id="1808715480127969042">Blokeeri nende saitide küpsised</translation>
<translation id="1908884158811109790">Keelab Google Drive'i sünkroonimise mobiiliühenduse kaudu Chrome OS-i rakenduses Failid</translation>
<translation id="7340034977315324840">Saada teavet seadme aktiivsuse aja kohta</translation>
<translation id="4928632305180102854">Määrab, kas <ph name="PRODUCT_OS_NAME"/> lubab luua uusi kasutajakontosid. Selle reegli keelamisel ei saa kontota kasutajad sisse logida.

      Kui lubate selle reegli või jätate määramata, siis on uute kasutajakontode loomine lubatud eeldusel, et <ph name="DEVICEUSERWHITELISTPROTO_POLICY_NAME"/> ei takista kasutajal sisse logida.</translation>
<translation id="4389091865841123886">Kaugatesteerimine konfigureeritakse TPM-mehhanismi abil.</translation>
<translation id="8256688113167012935">Juhib konto nime, mida <ph name="PRODUCT_OS_NAME"/> sisselogimiskuval vastava seadmepõhise konto jaoks näitab.

      Reegli määramisel kasutatakse pildipõhisel sisselogimiskuval vastava seadmepõhise konto jaoks määratud stringi.

      Kui jätate reegli määramata, kasutab <ph name="PRODUCT_OS_NAME"/> sisselogimiskuval seadmepõhise konto meilikonto ID-d kuvatava nimena.

      Tavapäraste kasutajakontode puhul eiratakse seda reeglit.</translation>
<translation id="267596348720209223">Määrab tähemärkide kodeeringu, mida otsingupakkuja toetab. Kodeeringud on koodilehtede nimed, näiteks UTF-8, GB2312 või ISO-8859-1. Neid proovitakse sisestatud järjestuses.

          See reegel on valikuline. Kui jätate selle määramata, siis kasutatakse vaikeseadet UTF-8.

          See reegel kehtivad vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="1349276916170108723">Väärtuse Tõene korral keelab Google Drive'i sünkroonimise Chrome OS-i rakenduses Failid. Sellisel juhul ei laadita Google Drive'i üles mingeid andmeid.

          Kui väärtus on seadmata või väärtuseks on seatud Väär, saavad kasutajad faile Google Drive'i edastada.</translation>
<translation id="1964634611280150550">Inkognito režiim on keelatud</translation>
<translation id="5971128524642832825">Drive'i keelamine Chrome OS-i rakenduses Failid</translation>
<translation id="1847960418907100918">Täpsustab parameetri, mida kasutatakse POST-meetodiga Instant-otsingu tegemisel. See koosneb komaga eraldatud nime/väärtuse paaridest. Kui väärtus on malliparameeter, nt {searchTerms} ülalolevas näites, siis asendatakse see otsingutermini andmetega.

          See reegel on valikuline. Kui see pole määratud, siis saadetakse soovituse otsingu taotlus GET-meetodiga.

          Reeglit järgitakse ainult siis, kui lubatud on reegel „DefaultSearchProviderEnabled”.</translation>
<translation id="1454846751303307294">Võimaldab teil määrata URL-i mustrite loendi, mis määrab saidid, millel on keelatud JavaScripti käitada.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultJavaScriptSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="538108065117008131">Teenusel <ph name="PRODUCT_FRAME_NAME"/> järgmist tüüpi sisu käsitsemise lubamine.</translation>
<translation id="2312134445771258233">Võimaldab seadistada käivitamisel avatavad lehed. Loendi „Käivitamisel avatavad URL-id” sisu eiratakse, kui te ei vali jaotises „Toiming käivitamisel” käsku „Ava URL-ide loend”.</translation>
<translation id="243972079416668391">Määrab toimingu, mis rakendub siis, kui tegevusetuse viivitusaeg täitub võrgutoite kasutamisel.

          Kui see reegel on määratud, siis täpsustab see, milline toiming rakendub operatsioonisüsteemis <ph name="PRODUCT_OS_NAME"/>, kui kasutaja on tegevusetu tegevusetuse viivitusajaga määratud perioodi jooksul (selle saab seadistada eraldi).

          Kui reegel on määramata, siis rakendub vaiketoiming, milleks on peatamine.

          Kui toiminguks on peatamine, saab operatsioonisüsteemi <ph name="PRODUCT_OS_NAME"/> seadistada ekraani enne peatamist lukustama või mitte lukustama.</translation>
<translation id="7750991880413385988">Ava uus vaheleht</translation>
<translation id="741903087521737762">Võimaldab määrata käitumise käivitamisel.

          Kui valite käsu „Ava uus vaheleht”, siis avaneb rakenduse <ph name="PRODUCT_NAME"/> käivitamisel alati uus vaheleht.

          Kui valite käsu „Taasta eelmine seanss”, siis avatakse uuesti vahelehed, mis olid avatud rakenduse <ph name="PRODUCT_NAME"/> sulgemisel, ja sirvimisseanss taastatakse samal kujul.
          See valik keelab mõned seaded, mis tuginevad seanssidel või teevad väljumisel toiminguid (näiteks sirvimisandmete tühjendamine väljumisel või seansipõhised küpsised).

          Kui valite käsu „Ava URL-ide loend”, siis avaneb rakenduse <ph name="PRODUCT_NAME"/> käivitamisel loend „Käivitamisel avatavad URL-id”.

          Seade lubamisel ei saa kasutajad seda rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistada.

          Seade keelamine on samaväärne selle seadistamata jätmisega. Kasutaja saab seda rakenduses <ph name="PRODUCT_NAME"/> muuta.</translation>
<translation id="8161570238552664224">Heli esitamise lubamine.

      Kui see reegel on määratud valeks, ei saa seadmest heli väljastada, kui kasutaja on sisse logitud.

      See reegel mõjutab iga tüüpi heli väljastamist, mitte ainult sisseehitatud kõlareid. See reegel keelab ka heli juurdepääsetavuse funktsioonid. Ärge lubage seda reeglit, kui kasutajal on tarvis ekraanilugejat.

      Kui see seade on määratud õigeks või on seadistamata, saavad kasutajad kasutada kõiki oma seadmes toetatud heliväljundeid.</translation>
<translation id="5761030451068906335">Seadistab rakenduse <ph name="PRODUCT_NAME"/> puhverserveri seaded. See reegel ei ole veel valmis, seetõttu ärge kasutage seda.</translation>
<translation id="3006443857675504368">Kuva teenuse <ph name="PRODUCT_OS_NAME"/> juurdepääsuvalikud süsteemimenüüs.

          Kui see reegel määratakse tõeseks, kuvatakse juurdepääsuvalikud alati süsteemisalve menüüs.

          Kui see reegel määratakse valeks, ei kuvata juurdepääsuvalikuid süsteemisalve menüüs kunagi.

          Kui määrate selle reegli, ei saa kasutajad seda muuta ega alistada.

          Kui jätate selle reegli määramata, siis juurdepääsuvalikuid süsteemisalve menüüs ei kuvata, kuid kasutaja saab juurdepääsuvalikud kuvada lehe Seaded kaudu.</translation>
<translation id="8344454543174932833">Impordi järjehoidjad vaikebrauserist esmakordsel käitamisel</translation>
<translation id="1019101089073227242">Kasutaja andmete kataloogi määramine</translation>
<translation id="5826047473100157858">Määrab, kas kasutaja saab rakenduses <ph name="PRODUCT_NAME"/> avada lehti inkognito režiimis.

      Kui valite seade „Lubatud” või jätate reegli määramata, siis saab lehti inkognito režiimis avada.

      Kui valite seade „Keelatud”, siis ei saa lehti inkognito režiimis avada.

      Kui valite seade „Jõustatud”, siis saab lehti avada AINULT inkognito režiimis.</translation>
<translation id="2988031052053447965">Peitke Chrome'i veebipoe rakendus ja jaluse link uuel vahelehel ja Chrome OS-i rakenduse käivitajas.

      Kui see reegel määratakse tõeseks, siis ikoonid peidetakse.

      Kui see reegel määratakse valeks või jäetakse seadistamata, on ikoonid nähtaval.</translation>
<translation id="8401282319420373133">Kaugatesteerimise API kasutamiseks lubatud laiendused.</translation>
<translation id="5085647276663819155">Printimise eelvaate keelamine</translation>
<translation id="8672321184841719703">Automaatse värskendamise sihtversioon</translation>
<translation id="1689963000958717134">Võimaldab jõustada võrgu konfigureerimise kõigile <ph name="PRODUCT_OS_NAME"/> seadme kasutajatele. Võrgu konfigureerimine on JSON-i vormingus string, mille määrab aadressil <ph name="ONC_SPEC_URL"/> kirjeldatud vorming Open Network Configuration</translation>
<translation id="6699880231565102694">Kahetasandilise autentimise lubamine kaugjuurdepääsu hostidele</translation>
<translation id="2030905906517501646">Vaikeotsingupakkuja märksõna</translation>
<translation id="3072045631333522102">Ekraanisäästja, mida kasutatakse jaemüügirežiimis sisselogimiskuval</translation>
<translation id="4550478922814283243">PIN-koodita autentimise lubamine või keelamine</translation>
<translation id="7712109699186360774">Küsi iga kord, kui sait soovib pääseda kaamera ja/või mikrofoni juurde</translation>
<translation id="350797926066071931">Luba Tõlge</translation>
<translation id="3711895659073496551">Peata</translation>
<translation id="4010738624545340900">Failivalimisdialoogide avamise lubamine</translation>
<translation id="4518251772179446575">Küsi iga kord, kui sait tahab jälgida kasutajate füüsilist asukohta</translation>
<translation id="402759845255257575">Keela kõigil saitidel JavaScripti käitamine</translation>
<translation id="5457924070961220141">Võimaldab <ph name="PRODUCT_FRAME_NAME"/> installimisel seadistada HTML-i vaikerenderdaja.
          Kui jätate selle reegli määramata, siis lubatakse vaikeseadena hostbrauseril renderdada, kuid võite selle alistada ja lasta rakendusel <ph name="PRODUCT_FRAME_NAME"/> vaikimisi HTML-lehti renderdada.</translation>
<translation id="706669471845501145">Luba saitidel töölauateatiste näitamine</translation>
<translation id="7529144158022474049">Hajutusteguri automaatne värskendamine</translation>
<translation id="2188979373208322108">Lubab järjehoidjariba rakenduses <ph name="PRODUCT_NAME"/>.

      Seade lubamisel kuvab <ph name="PRODUCT_NAME"/> järjehoidjariba.

      Seade keelamisel ei näe kasutajad järjehoidjariba.

      Seade lubamisel või keelamisel ei saa kasutajad seda rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistada.

      Kui jätate seade määramata, siis saab kasutaja otsustada, kas ta soovib funktsiooni kasutada.</translation>
<translation id="5475361623548884387">Luba printimine</translation>
<translation id="7287359148642300270">Määrab, millised serverid tuleb integreeritud autentimiseks lisada lubatud üksuste loendisse. Integreeritud autentimine on saadaval vaid siis, kui teenus <ph name="PRODUCT_NAME"/> saab puhverserverilt või serverilt, mis on selles lubatud üksuste loendis, autentimise väljakutse.

          Eraldage serveri nimed komadega. Metamärgid (*) on lubatud.

          Kui jätate selle reegli määramata, üritab Chrome tuvastada, kas server on intranetis, ja alles siis vastab IWA taotlustele. Kui server tuvastatakse Internetis, siis eirab Chrome sealt tulevaid IWA taotlusi.</translation>
<translation id="3653237928288822292">Vaikeotsingupakkuja ikoon</translation>
<translation id="2872961005593481000">Lülita välja</translation>
<translation id="4445684791305970001">Keelab arendaja tööriistad ja JavaScripti konsooli.

      Seade lubamisel ei saa arendaja tööriistu kasutada ega veebisaitide elemente uurida. Kõik klaviatuuri otseteed ning arendaja tööriistade ja JavaScripti konsooli avamise käsud menüüdes ja kontekstimenüüdes keelatakse.

      Kui keelate valiku või jätate selle määramata, siis saab arendaja tööriistu ja JavaScripti konsooli kasutada.</translation>
<translation id="9203071022800375458">Keelab ekraanipiltide tegemise.

      Kui seade on lubatud, siis ei saa ekraanipiltide tegemiseks kasutada klaviatuuri otseteid ega laienduse API-sid.

      Kui seade on keelatud või pole määratud, siis saab ekraanipilte teha.</translation>
<translation id="4632343302005518762">Pistikprogrammil <ph name="PRODUCT_FRAME_NAME"/> loetletud sisutüüpide töötlemise lubamine</translation>
<translation id="13356285923490863">Reegli nimi</translation>
<translation id="557658534286111200">Lubab või keelab järjehoidjate muutmise</translation>
<translation id="5378985487213287085">Võimaldab määrata, kas veebisaitidel on lubatud kuvada töölauateatisi. Töölauateatiste kuvamine võib olla vaikimisi keelatud või lubatud või kasutaja käest võidakse küsida iga kord, kui veebisait soovib kuvada töölauateatisi.

          Kui jätate selle reegli määramata, siis kasutatakse reeglit „AskNotifications” ja kasutaja saab seda muuta.</translation>
<translation id="2386362615870139244">Ekraani aktiveerimise lukustamise lubamine</translation>
<translation id="6908640907898649429">Seadistab vaikeotsingupakkuja. Saate määrata kasutajate jaoks vaikeotsingupakkuja või vaikeotsingu keelata.</translation>
<translation id="6544897973797372144">Kui reeglile on määratud olek True ja reeglit ChromeOsReleaseChannel pole määratud, siis on registreerumisdomeeni kanali kasutajatel lubatud seadme versiooni kanalit muuta. Kui reeglile on määratud olek False, siis lukustatakse seade mis tahes viimati määratud kanalil.

      Kasutaja valitud kanali alistab reegel ChromeOsReleaseChannel. Kui aga reegli kanal on stabiilsem kui seadmesse installitud kanal, siis lülitub see sisse alles pärast seda, kui stabiilsem kanal jõuab seadmesse installitud kanalist kõrgema versiooninumbrini.</translation>
<translation id="389421284571827139">Võimaldab määrata puhverserveri, mida <ph name="PRODUCT_NAME"/> kasutab, ja takistab kasutajatel puhverserveri seadete muutmist.

      Kui te ei soovi puhverserverit kasutada ja soovite luua ühenduse alati vahetult, siis ignoreeritakse kõiki muid valikuid.

      Kui valite puhverserveri automaatse tuvastamise, siis ignoreeritakse kõiki muid valikuid.

      Vaadake üksikasjalikke näiteid:
      <ph name="PROXY_HELP_URL"/>

      Seade lubamisel ignoreerib <ph name="PRODUCT_NAME"/> kõiki käsureal määratud puhverserveriga seotud valikuid.

      Kui jätate selle reegli määramata, siis saavad kasutajad ise puhverserveri seaded valida.</translation>
<translation id="681446116407619279">Toetatud autentimisskeemid</translation>
<translation id="4027608872760987929">Luba vaikeotsingupakkuja</translation>
<translation id="2223598546285729819">Teatiste vaikeseade</translation>
<translation id="6158324314836466367">Ettevõtte veebipoe nimi (tugi on katkestatud)</translation>
<translation id="3984028218719007910">Määrab, kas <ph name="PRODUCT_OS_NAME"/> säilitab kohaliku konto andmed pärast väljalogimist. Selle reegli lubamisel ei säilita <ph name="PRODUCT_OS_NAME"/> kontode andmeid ja kasutaja seansi kõik andmed eemaldatakse pärast väljalogimist. Kui keelate selle reegli või jätate määramata, siis võib seade säilitada kohaliku kasutaja andmeid (krüptitult).</translation>
<translation id="3793095274466276777">Seadistab vaikebrauseri kontrolli rakenduses <ph name="PRODUCT_NAME"/> ja takistab kasutajaid neid muutmast. Kui lubate seade, kontrollib <ph name="PRODUCT_NAME"/> käivitamisel alati, kas ta on vaikebrauser, ja võimalusel registreerib end ise. Kui keelate seade, ei kontrolli <ph name="PRODUCT_NAME"/> kunagi, kas ta on vaikebrauser, ja kasutajal keelatakse valiku seadmine. Kui te ei määra seadet, võimaldab <ph name="PRODUCT_NAME"/> kasutajal valida, kas see on vaikebrauser ja kas vastasel korral näidatakse kasutajale teatist.</translation>
<translation id="3504791027627803580">Täpsustab pildiotsinguks kasutatava otsingumootori URL-i. Otsingupäringud saadetakse GET-meetodiga. Kui määratud on reegel DefaultSearchProviderImageURLPostParams, siis kasutab pildiotsingupäring POST-meetodit.

          Reegel on valikuline. Kui see pole määratud, siis pildiotsingut ei kasutata.

          Reeglit järgitakse ainult siis, kui lubatud on reegel „DefaultSearchProviderEnabled”.</translation>
<translation id="7529100000224450960">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud avada hüpikaknaid.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultPopupsSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="6155936611791017817">Sisselogimisekraanil suure kursori vaikeoleku määramine</translation>
<translation id="1530812829012954197">Renderda hostbrauseris alati järgmiste URL-ide mustrid</translation>
<translation id="9026000212339701596">Sõnastik, mis kaardistab hosti nimed kahendmuutuja märgisega ja määrab, kas hostile tuleb juurdepääs lubada (tõene) või blokeerida (väär)..

          Reegel on mõeldud Chrome'ile sisekasutuseks.</translation>
<translation id="913195841488580904">URL-ide loendile juurdepääsu blokeerimine</translation>
<translation id="3292147213643666827">Võimaldab rakendusel <ph name="PRODUCT_NAME"/> töötada puhverserverina teenuse <ph name="CLOUD_PRINT_NAME"/> ja seadmega ühendatud pärandprinterite vahel.

      Kui seade on lubatud või seadistamata, saavad kasutajad lubada pilvprintimise puhverserveri Google'i kontoga autentides.

      Kui seade on keelatud, ei saa kasutajad puhverserverit lubada ja seadmel ei ole lubatud jagada printereid teenusega <ph name="CLOUD_PRINT_NAME"/>.</translation>
<translation id="6373222873250380826">Reegli lubamisel on automaatsed värskendused keelatud.

      Kui seade ei ole seadistatud või on keelatud, siis otsivad teenuse <ph name="PRODUCT_OS_NAME"/> seadmed värskendusi automaatselt.</translation>
<translation id="6190022522129724693">Hüpikakende vaikeseade</translation>
<translation id="847472800012384958">Keela kõikidel saitidel hüpikakende näitamine</translation>
<translation id="4733471537137819387">Integreeritud HTTP autentimisega seotud reeglid</translation>
<translation id="8951350807133946005">Vahemälu kataloogi seadmine</translation>
<translation id="603410445099326293">Parameetrid POST-meetodit kasutava soovituse URL-i jaoks</translation>
<translation id="2592091433672667839">Inaktiivsuse periood, mille möödudes kuvatakse jaemüügirežiimis sisselogimiskuval ekraanisäästja</translation>
<translation id="166427968280387991">Puhverserver</translation>
<translation id="2805707493867224476">Luba kõigil saitidel hüpikakende näitamine</translation>
<translation id="1727394138581151779">Blokeeri kõik pistikprogrammid</translation>
<translation id="8118665053362250806">Määra meediaketta vahemälu maht</translation>
<translation id="7079519252486108041">Blokeeri hüpikaknad nendel saitidel</translation>
<translation id="1859633270756049523">Piira seansi pikkust</translation>
<translation id="7433714841194914373">Luba Instant</translation>
<translation id="4983201894483989687">Luba vananenud pistikprogrammide käitamine</translation>
<translation id="443665821428652897">Kustuta saidi andmed brauseri sulgemisel (toetamine lõpetatud)</translation>
<translation id="3823029528410252878">Keelab sirvimisajaloo salvestamise rakenduses <ph name="PRODUCT_NAME"/> ja takistab kasutajatel seade muutmist.

      Kui seade on lubatud, siis sirvimisajalugu ei salvestata.

      Kui keelate seade või jätate selle määramata, siis sirvimisajalugu ei salvestata.</translation>
<translation id="3844092002200215574">Seadistab kataloogi, mida <ph name="PRODUCT_NAME"/> kasutab vahemälus olevate failide kettale salvestamiseks.

      Kui selle reegli määrate, kasutab <ph name="PRODUCT_NAME"/> antud kataloogi olenemata sellest, kas kasutaja on märgistuse „--disk-cache-dir” määranud või mitte.

      Saidilt http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables leiate loendi muutujatest, mida saab kasutada.

      Kui seda reeglit ei määrata, kasutatakse vahemälu vaikekataloogi ja kasutaja saab selle käsurea märgistusega „--disk-cache-dir” alistada.</translation>
<translation id="3034580675120919256">Võimaldab määrata, kas veebisaitidel on lubatud käitada JavaScripti. JavaScripti käitamise saab kõikidel veebisaitidel lubada või keelata.

          Kui jätate selle reegli määramata, siis kasutatakse reeglit „AllowJavaScript” ja kasutaja saab seda muuta.</translation>
<translation id="193900697589383153">Lisab väljalogimisnupu süsteemisalve.

      Seade lubamisel ilmub süsteemisalves suur punane väljalogimisnupp, kui seanss on aktiivne ja ekraan ei ole lukustatud.

      Kui seade on keelatud või määramata, ei kuvata süsteemisalves suurt punast nuppu.</translation>
<translation id="5111573778467334951">Määrab toimingu, mis rakendub siis, kui tegevusetuse viivitusaeg täitub akutoite kasutamisel.

          Kui see reegel on määratud, siis täpsustab see, milline toiming rakendub operatsioonisüsteemis <ph name="PRODUCT_OS_NAME"/>, kui kasutaja on tegevusetu tegevusetuse viivitusajaga määratud perioodi jooksul (selle saab seadistada eraldi).

          Kui reegel on määramata, siis rakendub vaiketoiming, milleks on peatamine.

          Kui toiminguks on peatamine, saab operatsioonisüsteemi <ph name="PRODUCT_OS_NAME"/> seadistada ekraani enne peatamist lukustama või mitte lukustama.</translation>
<translation id="3195451902035818945">Määrab, kas SSL-kirjete jagamine on keelatud. Kirjete jagamine võib tõsta SSL 3.0 ja TLS 1.0 turvalisust, kuid see võib põhjustada ühilduvusprobleeme HTTPS-serverite ja -puhverserveritega.

Kui jätate reegli määramata või keelate selle, siis kasutatakse kirjete jagamist SSL-/TLS-ühenduste puhul, mis põhinevad CBC-šifril.</translation>
<translation id="6903814433019432303">See reegel on aktiivne vaid jaemüügirežiimis.

      Määrab URL-ide loendi, mis laaditakse demoseansi alguses. See reegel alistab muud algse URL-i määramise mehhanismid, mistõttu saab seda rakendada vaid seansile, mis ei ole seotud kindla kasutajaga.</translation>
<translation id="5868414965372171132">Kasutaja tasemel võrgukonfiguratsioon</translation>
<translation id="8519264904050090490">Kasutaja käsitsi sisestatavate URL-ide erandite haldamine</translation>
<translation id="4480694116501920047">Jõusta SafeSearchi kasutamine</translation>
<translation id="465099050592230505">Ettevõtte veebipoe URL (tugi on katkestatud)</translation>
<translation id="1221359380862872747">Laadi määratud URL-id demosse sisselogimisel</translation>
<translation id="2431811512983100641">Määrab, kas domeeni suunduvate TLS-i sertifikaatide laiendus on lubatud.

      Seade abil saab katsetamiseks lubada domeeni suunduvate TLS-i sertifikaatide laienduse. See katseline seade eemaldatakse tulevikus.</translation>
<translation id="8711086062295757690">Määrab märksõna, mis on otsetee, mida kasutatakse omnikastikeses otsingupakkuja käivitamiseks.

          Reegel on valikuline. Kui jätate selle määramata, siis ei saa märksõnaga otsingupakkujat aktiveerida.

         Reegel kehtib vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="5774856474228476867">Vaikeotsingupakkuja otsingu URL</translation>
<translation id="4650759511838826572">Keela URL-i protokolli skeemid</translation>
<translation id="7831595031698917016">Määrab millisekundites kindlaks maksimaalse viivituse, mis jääb reegli kehtetuks tunnistamise ja seadme haldusteenusest uue reegli toomise vahele.

      Selle reegli määramine tühistab vaikeväärtuse 5000 millisekundit. Reegli sobivad väärtused jäävad vahemikku 1000 (1 sekund) kuni 300 000 (5 minutit). Vahemikust väljapoole jäävad väärtused viiakse vastavusse vastava piirväärtusega.

      Kui jätate reegli määramata, siis kasutab toode <ph name="PRODUCT_NAME"/> vaikeväärtust 5000 millisekundit.</translation>
<translation id="8099880303030573137">Jõudeoleku viiteaeg akutoite kasutamisel</translation>
<translation id="2761483219396643566">Tegevusetuse hoiatuse viivitus akutoite kasutamisel</translation>
<translation id="1468307069016535757">Sisselogimisekraanil suure kontrastsusega režiimi hõlbustusfunktsiooni vaikeoleku määramine.

         Kui reegel on seatud väärtusele Tõene, on suure kontrastsusega režiim sisselogimisekraanili kuvamisel alati lubatud.

         Kui reegel on seatud väärtusele Väär, on suure kontrastsusega režiim sisselogimisekraanili kuvamisel alati keelatud.

         Kui määrate reegli, saavad kasutajad selle ajutiselt alistada, lubades või keelates suure kontrastsusega režiimi. Kasutaja valik pole siiski püsiv ja vaikeväärtus taastatakse, kui kuvatakse uuesti sisselogimisekraan või kui kasutaja jääb sisselogimisekraanile minutiks tegevuseta olekusse.

         Kui jätate reegli määramata, on suure kontrastsusega režiim algselt keelatud. Kasutaja võib suure kontrastsusega režiimi igal ajal lubada või keelata ja selle olek jääb sisselogimisekraanil kasutajati püsivaks.</translation>
<translation id="8580857153747395000">Hoiata sisupakettidest väljaspool olevate saitide külastamisel.</translation>
<translation id="350796261613621561">Järelevalvega kasutajate loomise lubamine.</translation>
<translation id="602728333950205286">Vaikeotsingupakkuja Instant-URL</translation>
<translation id="3030000825273123558">Luba mõõdikute aruandlus</translation>
<translation id="8465065632133292531">Parameetrid Instant-URL-i jaoks, mis kasutab POST-meetodit</translation>
<translation id="6559057113164934677">Keela kõikidel saitidel juurdepääs kaamerale ja mikrofonile</translation>
<translation id="7273823081800296768">Kui see seade on lubatud või seadistamata, siis saavad kasutajad kliente ja hoste ühenduse ajal siduda, nii ei pea iga kord sisestama PIN-koodi.

          Kui see seade on keelatud, siis pole funktsioon saadaval.</translation>
<translation id="1675002386741412210">Toetatud:</translation>
<translation id="3547954654003013442">Puhverserveri seaded</translation>
<translation id="4482640907922304445">Kuvab rakenduse <ph name="PRODUCT_NAME"/> tööriistaribal nuppu Kodu.

      Seade lubamisel on nupp Kodu alati kuvatud.

      Seade keelamisel nuppu Kodu ei kuvata.

      Seade lubamisel või keelamisel ei saa kasutajad seadet rakenduses <ph name="PRODUCT_NAME"/> muuta ega alistada.

      Kui jätate selle reegli määramata, siis saab kasutaja valida, kas ta soovib nuppu Kodu näha.</translation>
<translation id="6897718480289510689">Luba juurdepääs sisupakettidest väljaspool olevatele saitidele.</translation>
<translation id="2518231489509538392">Heli esitamise lubamine</translation>
<translation id="7301543427086558500">Määrab asendus-URL-ide loendi, mida saab kasutada otsinguterminite ekstraktimiseks otsingumootorist. URL-id peavad sisaldama stringi <ph name="SEARCH_TERM_MARKER"/>, mida kasutatakse otsinguterminite ekstraktimiseks.

          See reegel on valikuline. Kui seda ei määrata, ei kasutata otsinguterminite ekstraktimiseks asendus-URL-e.

          See reegel kehtib vaid siis, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="436581050240847513">Seadme võrguliidestest teatamine</translation>
<translation id="6282799760374509080">Heli jäädvustamise lubamine või keelamine</translation>
<translation id="8864975621965365890">Keelab tagasilükkamisviiba, mis kuvatakse, kui saiti renderdab <ph name="PRODUCT_FRAME_NAME"/>.</translation>
<translation id="3264793472749429012">Vaikeotsingupakkuja kodeeringud</translation>
<translation id="285480231336205327">Luba kõrge kontrastiga režiim</translation>
<translation id="5366977351895725771">Kui väärtuseks on seatud valik Väär, siis keelatakse sellel kasutajal järelevalvega kasutajate loomine. Kõik olemasolevad järelevalvega kasutajad on ikka saadaval.

          Kui väärtuseks on seatud valik Tõene või Seadistamata, saab see kasutaja luua ja hallata järelevalvega kasutajaid.</translation>
<translation id="8101760444435022591">Osalise nurjumise puhul ei suurenda tagasivõtmise kontrollimine turvalisust, mistõttu on kontrollimine vaikimisi rakenduse <ph name="PRODUCT_NAME"/> 19. ja hilisemates versioonides vaikimisi keelatud. Selle reegli lubamisel taastatakse varasem käitumine ja võrgus ei kontrollita OCSP-d/CRL-i.

      Kui jätate selle reegli määramata või keelate selle, siis ei kontrolli Chrome 19. ja hilisemates versioonides võrgus tagasivõtmist.</translation>
<translation id="5469484020713359236">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud küpsiseid määrata.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultCookiesSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="1504431521196476721">Kaugatesteerimine</translation>
<translation id="1881299719020653447">Veebipoe peitmine uuel vahelehel ja rakenduse käivitajas</translation>
<translation id="930930237275114205">Määra rakenduse <ph name="PRODUCT_FRAME_NAME"/> kasutaja andmekataloog</translation>
<translation id="244317009688098048">Pääsu otsetee lubamine automaatseks sisselogimiseks.

      Kui reegel on seadmata või on selle väärtuseks seatud Tõene ja seadmepõhine konto on konfigureeritud nullviivitusega automaatsele sisselogimisele, kasutab <ph name="PRODUCT_OS_NAME"/> automaatse sisselogimise vahelejätmiseks ja sisselogimisekraani näitamiseks klaviatuuri osteteed Ctrl + Alt + S.

      Kui reegli väärtuseks on seatud Väär, siis ei saa nullviivitusega automaatset sisselogimist vahele jätta (kui see on konfigureeritud).</translation>
<translation id="5208240613060747912">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel ei ole lubatud teatisi kuvada.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultNotificationsSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="7927140259706020912">URL-id, millele antakse juurdepääs helijäädvustusseadmetele ilma küsimata.</translation>
<translation id="4600786265870346112">Suure kursori lubamine</translation>
<translation id="8592105098257899882">Määrab ketta vahemälu mahu, kuhu rakendus <ph name="PRODUCT_NAME"/> talletab vahemälus olevaid faile.

      Reegli määramisel kasutab rakendus <ph name="PRODUCT_NAME"/> sisestatud vahemälu mahtu sõltumata sellest, kas kasutaja on määranud lipu „--disk-cache-size”.

      Kui reegli väärtus on 0, siis kasutatakse vahemälu vaikemahtu, kuid kasutaja ei saa seda muuta.

      Kui jätate selle reegli määramata, siis kasutatakse vaikemahtu ja kasutaja saab selle lipu „--disk-cache-size” abil alistada.</translation>
<translation id="5887414688706570295">Seadistab TalkGadgeti eesliite, mida kasutavad kaugjuurdepääsu hostid, ja takistab kasutajatel selle muutmist.

          Kui eesliide on määratud, lisatakse eesliide TalkGadgeti põhinime ette, et luua TalkGadgeti täielik domeeninimi. TalkGadgeti domeeni põhinimi on „.talkgadget.google.com”.

          Kui seade on lubatud, siis kasutavad hostid TalkGadgetisse pääsuks kohandatud domeeninime, mitte domeeni vaikenime.

          Kui seade on keelatud või pole määratud, kasutatakse kõigi hostide jaoks TalkGadgeti domeeni vaikenime („chromoting-host.talkgadget.google.com”).

          See reegliseade ei mõjuta kaugjuurdepääsuga kliente. Nemad kasutavad TalkGadgetile juurdepääsuks alati nime „chromoting-client.talkgadget.google.com”.</translation>
<translation id="5765780083710877561">Kirjeldus:</translation>
<translation id="6915442654606973733">Suulise tagasiside hõlbustusfunktsiooni lubamine.

          Kui reegel on seatud väärtusele Tõene, on suuline tagasiside alati lubatud.

          Kui reegel on seatud väärtusele Väär, on suuline tagasiside alati keelatud.

          Kui määrate reegli, ei saa kasutajad seda muuta ega alistada.

          Kui jätate reegli määramata, on suur kursor algselt keelatud, kuid kasutaja võib selle igal ajal lubada.</translation>
<translation id="7796141075993499320">Võimaldab teil määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud pistikprogramme käitada.

          Kui jätate selle reeglis määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultPluginsSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="3809527282695568696">Kui käivitustoiminguks on valitud „Ava URL-ide loend”, siis saate määrata avatavate URL-ide loendi. Kui jätate selle määramata, siis ei avata käivitamisel ühtki URL-i.

          Reegel kehtib ainult juhul, kui reegel „RestoreOnStartup” on seatud väärtusele „RestoreOnStartupIsURLs”.</translation>
<translation id="649418342108050703">Keelake 3D-graafika API-liidese tugi.

      Seade lubamine takistab veebisaitidel graafikaprotsessori (GPU) kasutamise. Täpsemalt ei pääse veebilehed WebGL-i API-liidese juurde ja pistikprogrammid ei saa kasutada Pepper 3D API-liidest.

      Kui keelate seade või jätate selle määramata, siis saavad veebilehed kasutada WebGL-i API-liidest ja pistikprogrammid kasutada Pepper 3D API-liidest. Sõltuvalt brauseri vaikeseadetest on võimalik, et API-liidese kasutamiseks tuleb siiski käitada käsurea argumente.</translation>
<translation id="2077273864382355561">Ekraani väljalülitamise viiteaeg akutoite kasutamisel</translation>
<translation id="909184783177222836">Toitehaldus</translation>
<translation id="3417418267404583991">Kui lubate selle reegli või jätate seadistamata, siis lubab <ph name="PRODUCT_OS_NAME"/> külastajatel sisse logida. Külastajana sisse logides kasutatakse anonüümseid seansse ja selleks ei ole vaja parooli sisestada.

      Selle reegli keelamisel ei luba <ph name="PRODUCT_OS_NAME"/> külastajaseansse alustada.</translation>
<translation id="8329984337216493753">See reegel on aktiivne vaid jaemüügirežiimis.

      Kui DeviceIdleLogoutTimeout on määratud, siis määratleb reegel, kui kaua kuvatakse loenduriga hoiatusboks enne väljalogimist.

      Määrake reegli väärtus millisekundites.</translation>
<translation id="237494535617297575">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud kuvada märguandeid.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultNotificationsSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="7258823566580374486">Kaugjuurdepääsu hostide varjamise lubamine</translation>
<translation id="5560039246134246593">Lisage parameeter variatsioonide lähteväärtuse toomisele teenuses <ph name="PRODUCT_NAME"/>.

      Kui see on määratud, lisatakse päringu parameeter „restrict” URL-ile, mida kasutatakse variatsioonide lähteväärtuse toomiseks. Parameetri väärtus on selles reeglis määratud väärtus.

      Kui seda ei määrata, siis variatsioonide lähteväärtuse URL-i ei muudeta.</translation>
<translation id="944817693306670849">Ketta vahemälu mahu määramine</translation>
<translation id="8544375438507658205">Rakenduse <ph name="PRODUCT_FRAME_NAME"/> HTML-i vaikerenderdaja</translation>
<translation id="2371309782685318247">Määrab vahemiku millisekundites, mille jooksul saadetakse seadmehaldusteenusele päring kasutaja reeglite teabe kohta.

      Reegli määramisel alistatakse vaikeväärtus 3 tundi. Reegli lubatud väärtused on vahemikus 1 800 000 (30 minutit) kuni 86 400 000 (1 päev). Vahemikust väljaspool olevad väärtused kohandatakse piiridesse.

      Kui jätate selle reegli määramata, kasutab <ph name="PRODUCT_NAME"/> vaikeväärtust 3 tundi.</translation>
<translation id="7424751532654212117">Keelatud pistikprogrammide loendi erandite loend</translation>
<translation id="6233173491898450179">Määra allalaadimiskataloog</translation>
<translation id="78524144210416006">Operatsioonisüsteemi <ph name="PRODUCT_OS_NAME"/> toitehalduse ja sisselogimiskuva seadistamine.

      Selle reegliga saate seadistada, kuidas operatsioonisüsteem <ph name="PRODUCT_OS_NAME"/> käitub juhul, kui kuvatakse sisselogimiskuva ja kasutaja pole teatud perioodi jooksul midagi teinud. Reegel juhib mitut seadet. Teavet individuaalse semantika ja väärtusevahemike kohta vaadake vastava seansi toitehaldust juhtivatest reeglitest. Ainsad kõrvalekalded nendest reeglitest on järgmised.
      * Tegevusetuse või kaane sulgemise korral ei saa toiminguks olla seansi lõpetamine.
      * Vahelduvvoolu toite kasutamisel on tegevusetuse korral vaiketoiminguks välja lülitamine.

      Reegel tuleb määrata stringina, mis väljendab konkreetseid seadeid JSON-vormingus järgmise skeemi järgi:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;AC&quot;: {
            &quot;description&quot;: &quot;Power management settings applicable only when running on AC power&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;The length of time without user input after which the screen is dimmed, in milliseconds&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;The length of time without user input after which the screen is turned off, in milliseconds&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;The length of time without user input after which the idle action is taken, in milliseconds&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Action to take when the idle delay is reached&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;Battery&quot;: {
            &quot;description&quot;: &quot;Power management settings applicable only when running on battery power&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;The length of time without user input after which the screen is dimmed, in milliseconds&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;ScreenOff&quot;: {
                    &quot;description&quot;: &quot;The length of time without user input after which the screen is turned off, in milliseconds&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  },
                  &quot;Idle&quot;: {
                    &quot;description&quot;: &quot;The length of time without user input after which the idle action is taken, in milliseconds&quot;,
                    &quot;type&quot;: &quot;integer&quot;,
                    &quot;minimum&quot;: 0
                  }
                }
              },
              &quot;IdleAction&quot;: {
                &quot;description&quot;: &quot;Action to take when the idle delay is reached&quot;,
                &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
              }
            }
          },
          &quot;LidCloseAction&quot;: {
            &quot;description&quot;: &quot;Action to take when the lid is closed&quot;,
            &quot;enum&quot;: [ &quot;Suspend&quot;, &quot;Shutdown&quot;, &quot;DoNothing&quot; ]
          },
          &quot;UserActivityScreenDimDelayScale&quot;: {
            &quot;description&quot;: &quot;Percentage by which the screen dim delay is scaled when user activity is observed while the screen is dimmed or soon after the screen has been turned off&quot;,
            &quot;type&quot;: &quot;integer&quot;,
            &quot;minimum&quot;: 100
          }
        }
      }

      Kui seade on määramata, siis kasutatakse vaikeväärtust.

      Kui reegel on määramata, kasutatakse kõikide seadete puhul vaikeväärtusi.</translation>
<translation id="8908294717014659003">Võimaldab määrata veebisaitidele juurdepääsu meediahõiveseadmetele. Juurdepääsu meediahõiveseadmetele saab lubada vaikimisi või lasta iga kord kasutajalt küsida, kui mõni veebisait neile juurdepääsu soovib.

          Kui reegel pole määratud, siis kasutatakse reeglit „PromptOnAccess” ja kasutaja saab seda muuta.</translation>
<translation id="2299220924812062390">Lubatud pistikprogrammide loendi määramine</translation>
<translation id="4325690621216251241">Lisa väljalogimisnupp süsteemisalve</translation>
<translation id="924557436754151212">Impordi salvestatud paroolid vaikebrauserist esimesel käitamisel</translation>
<translation id="1465619815762735808">Klõpsa esitamiseks</translation>
<translation id="7227967227357489766">Määrab loendi kasutajatest, kellel on luba seadmesse sisse logida. Kirjete vorming on <ph name="USER_WHITELIST_ENTRY_FORMAT"/>, näiteks <ph name="USER_WHITELIST_ENTRY_EXAMPLE"/>. Kui soovite juhukasutajaid domeeni lubada, siis kasutage kirjete vormingut <ph name="USER_WHITELIST_ENTRY_WILDCARD"/>.

      Kui jätate selle reegli seadistamata, siis ei ole kasutajate sisselogimine piiratud. Pidage meeles, et uute kasutajate loomisel on siiski vaja reegel <ph name="DEVICEALLOWNEWUSERS_POLICY_NAME"/> asjakohaselt seadistada.</translation>
<translation id="8135937294926049787">Määrab aja, pärast mida ekraan võrgutoitega töötamisel välja lülitatakse, kui kasutaja pole midagi sisestanud.

          Kui selle reegli väärtuseks määratakse arv, mis on suurem kui null, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui <ph name="PRODUCT_OS_NAME"/> ekraani välja lülitab.

          Kui reegli väärtuseks on määratud null, ei lülita <ph name="PRODUCT_OS_NAME"/> ekraani välja, kui kasutaja on tegevusetu.

          Kui jätate selle reegli määramata, kasutatakse vaikeaega.

          Reegli väärtus tuleb määrata millisekundites. Väärtused tuleb kinnitada väiksematena kui jõudeoleku viiteaeg või sellega võrdsetena.</translation>
<translation id="1897365952389968758">Luba kõikidel saitidel JavaScripti käitamine</translation>
<translation id="5244714491205147861">Toitehaldus sisselogimiskuval</translation>
<translation id="922540222991413931">Seadistage laienduste, rakenduste ja kasutaja skriptide installimise allikad</translation>
<translation id="7323896582714668701">Rakenduse <ph name="PRODUCT_NAME"/> täiendavad käsureaparameetrid</translation>
<translation id="6931242315485576290">Keela andmete sünkroonimine Google'iga</translation>
<translation id="7006788746334555276">Sisu seaded</translation>
<translation id="5142301680741828703">Renderda alati rakenduses <ph name="PRODUCT_FRAME_NAME"/> järgmiste URL-ide mustrid</translation>
<translation id="4625915093043961294">Installimiseks lubatud laienduste loendi seadistamine</translation>
<translation id="187819629719252111">Lubab juurdepääsu seadmes olevatele kohalikele failidele, võimaldades rakendusel <ph name="PRODUCT_NAME"/> kuvada failide valimise dialoogiaknaid.

      Seade lubamisel saavad kasutajad avada failide valimise dialoogiaknad tavapärasel moel.

      Kui kasutaja teeb mõne toimingu, mille puhul avaneks failide valimise dialoogiaken (näiteks järjehoidjate importimine, failide üleslaadimine, linkide salvestamine jne), ja seade on keelatud, siis kuvatakse dialoogiakna asemel sõnum ja edasine töö toimub nii, nagu kasutaja oleks klõpsanud failide valimise dialoogiaknas käsul Tühista.

      Kui jätate seade määramata, siis saavad kasutajad failide avamise dialoogiaknad tavapärasel moel avada.</translation>
<translation id="4507081891926866240">Kohandage loendit URL-i mustritest, mida renderdab alati rakendus <ph name="PRODUCT_FRAME_NAME"/>.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul vaikerenderdajat, mis on määratud reegliga „ChromeFrameRendererSettings”.

          Vaadake näidismustreid aadressilt http://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="3101501961102569744">Valimine, kuidas määrata puhverserveri seaded</translation>
<translation id="1803646570632580723">Kinnitatud rakenduste loend, mida näidatakse käivitis</translation>
<translation id="7774768074957326919">Kasuta süsteemi puhverserveri seadeid</translation>
<translation id="3891357445869647828">Luba JavaScript</translation>
<translation id="868187325500643455">Kõikidel saitidel pistikprogrammide automaatselt käitamise lubamine</translation>
<translation id="7421483919690710988">Määrake meediumiketta vahemälu suurus baitides</translation>
<translation id="5226033722357981948">Määramine, kas pistikprogrammide leidja tuleks keelata</translation>
<translation id="4890209226533226410">Lubatud ekraaniluubi tüübi määramine.

         Kui reegel on määratud, juhib see lubatud ekraaniluubi tüüpi. Reegli seadmine väärtusele Puudub keelab ekraaniluubi.

          Kui määrate reegli, ei saa kasutajad seda muuta ega alistada.

          Kui reegel on määramata, on ekraaniluup algselt keelatud, kuid kasutaja võib selle igal ajal lubada.</translation>
<translation id="3428247105888806363">Luba võrgu prognoos</translation>
<translation id="6145799962557135888">Võimaldab määrata URL-i mustrite nimekirja, mis määrab saidid, millel on lubatud käitada JavaScripti.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultJavaScriptSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="2757054304033424106">Laienduste/rakenduste tüübid, mille installimine on lubatud</translation>
<translation id="7053678646221257043">Kui see reegel on lubatud, siis imporditakse järjehoidjad praegusest vaikebrauserist. Lubamisel mõjutab reegel ka importimisdialoogi.

      Reegli keelamisel järjehoidjaid ei impordita.

      Kui jätate reegli määramata, siis võib importimine toimuda automaatselt või kasutajalt võidakse küsida, kas ta soovib importida.</translation>
<translation id="5757829681942414015">Seadistab kataloogi, mida <ph name="PRODUCT_NAME"/> kasutab kasutajate andmete salvestamiseks.

      Kui selle reegli määrate, kasutab <ph name="PRODUCT_NAME"/> antud kataloogi olenemata sellest, kas kasutaja on märgistuse „--user-data-dir” määranud või mitte.

      Saidilt http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables leiate loendi muutujatest, mida saab kasutada.

      Kui seda reeglit ei määrata, kasutatakse profiili vaiketeed ja kasutaja saab selle käsurea märgistusega „--user-data-dir” alistada.</translation>
<translation id="5067143124345820993">Kasutajate sisselogimise lubatud loend</translation>
<translation id="2514328368635166290">Määrab vaikeotsingupakkuja lemmikikooni URL-i.

          See reegel on valikuline. Kui jätate selle määramata, siis ei kuvata otsingupakkuja ikooni.

          See reegel kehtib vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="7194407337890404814">Vaikeotsingupakkuja nimi</translation>
<translation id="1843117931376765605">Kasutajareegli värskendussagedus</translation>
<translation id="5535973522252703021">Kerberose volitusserveri lubatud nimekiri</translation>
<translation id="4578030379102330182">Kasutajale kaugatestaarimise lubamine.</translation>
<translation id="9187743794267626640">Keela välismäluseadmete ühendamine</translation>
<translation id="6353901068939575220">Määrab, mis parameetreid kasutatakse POST-meetodiga URL-i otsimisel. See koosneb komaga eraldatud nime/väärtuse paaridest. Kui väärtus on malliparameeter, nt {searchTerms} ülalolevas näites, siis asendatakse see otsingutermini andmetega.

          See reegel on valikuline. Kui see pole määratud, siis saadetakse soovituse otsingu taotlus GET-meetodiga.

          Reeglit järgitakse ainult siis, kui lubatud on reegel „DefaultSearchProviderEnabled”.</translation>
<translation id="5307432759655324440">Inkognito režiimi saadavus</translation>
<translation id="4056910949759281379">Keela SPDY-protokoll</translation>
<translation id="3808945828600697669">Keelatud pistikprogrammide loendi määramine</translation>
<translation id="4525521128313814366">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel ei ole lubatud kujutisi kuvada.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultImagesSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="8499172469244085141">Vaikeseaded (kasutajad saavad alistada)</translation>
<translation id="8693243869659262736">Kasuta sisseehitatud DNS-i klienti</translation>
<translation id="3072847235228302527">Teenusetingimuste määramine seadmes kasutatava konto jaoks</translation>
<translation id="5523812257194833591">Avalik seanss automaatseks sisselogimiseks pärast viivitust.

      Kui selle reegli määrate, logitakse määratud seanssi automaatselt sisse pärast teatud perioodi möödumist sisselogimisekraanil ilma kasutaja interaktsioonita. Avalik seanss peab olema juba seadistatud (vt |DeviceLocalAccounts|).

      Kui te seda reeglit ei määra, siis automaatset sisselogimist ei toimu.</translation>
<translation id="5983708779415553259">Mitte ühessegi sisupaketti kuuluvate saitide vaikekäitumine</translation>
<translation id="3866530186104388232">Kui lubate selle reegli või jätate määramata, siis kuvab <ph name="PRODUCT_OS_NAME"/> olemasolevad kasutajad sisselogimiskuval ja võimaldab neid valida. Selle reegli keelamisel kasutab <ph name="PRODUCT_OS_NAME"/> sisselogimiseks kasutajanime ja parooli viipa.</translation>
<translation id="2098658257603918882">Luba kasutus- ja krahhiandmete aruandlus</translation>
<translation id="2324547593752594014">Lubab Chrome'i sisselogimise</translation>
<translation id="172374442286684480">Luba kõikidel saitidel kohalike andmete määramine</translation>
<translation id="1151353063931113432">Luba kujutised nendel saitidel</translation>
<translation id="1297182715641689552">Kasuta puhverserveri pac-skripti</translation>
<translation id="2976002782221275500">Määrab aja, pärast mida hämardatakse akutoitega töötamisel ekraan, kui kasutaja pole midagi sisestanud.

          Kui selle reegli väärtuseks määratakse arv, mis on suurem kui null, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui <ph name="PRODUCT_OS_NAME"/> ekraani hämardab.

          Kui reegli väärtuseks on määratud null, ei hämarda <ph name="PRODUCT_OS_NAME"/> ekraani, kui kasutaja on tegevusetu.

          Kui jätate selle reegli määramata, kasutatakse vaikeaega.

          Reegli väärtus tuleb määrata millisekundites. Väärtused tuleb kinnitada väiksematena kui ekraani väljalülitamise viiteaeg (kui see on määratud) ja jõudeoleku viiteaeg või nendega võrdsetena.</translation>
<translation id="8631434304112909927">versioonini <ph name="UNTIL_VERSION"/></translation>
<translation id="7469554574977894907">Luba otsingusoovitused</translation>
<translation id="4906194810004762807">Seadme reeglite värskendussagedus</translation>
<translation id="8922668182412426494">Serverid, kuhu teenus <ph name="PRODUCT_NAME"/> võib delegeerida.

          Eraldage serverite nimed komadega. Metamärgid (*) on lubatud.

          Kui jätate selle reegli määramata, ei delegeeri Chrome kasutaja mandaate isegi siis, kui server tuvastatakse intranetis olevana.</translation>
<translation id="1398889361882383850">Saate määrata, kas veebisaitidel on lubatud pistikprogramme automaatselt käitada. Pistikprogrammide automaatse käitamise saab kõigi veebisaitide puhul lubada või keelata.

          „Klõpsa esitamiseks” lubab pistikprogramme käitada, kuid kasutaja peab selleks pistikprogrammil klõpsama.

          Kui seda reeglit ei määrata, kasutatakse funktsiooni „Luba pistikprogrammid” ja kasutaja saab seda muuta.</translation>
<translation id="7974114691960514888">Seda reeglit ei toetata enam.
          Lubab STUN-i ja vaheserverite kasutamise kaugkliendiga ühenduse loomisel.

          Seade lubamisel saab masin eemal asuvaid hostmasinaid tuvastada ja nendega ühenduse luua ka juhul, kui neid eraldab tulemüür.

          Kui keelate seade ja tulemüür filtreerib väljuvaid UDP-ühendusi, siis saab masin luua ühenduse vaid kohalikus võrgus olevate hostmasinatega.</translation>
<translation id="7694807474048279351">Toote <ph name="PRODUCT_OS_NAME"/> värskenduse rakendamise järgse automaatse taaskäivitamise ajastamine.

      Kui reegel on seatud väärtusele Tõene, ajastatakse pärast toote <ph name="PRODUCT_OS_NAME"/> värskenduse rakendamist automaatne taaskäivitus, kui taaskäivitus on värskendustoimingu lõpuleviimiseks vajalik. Taaskäivitus ajastatakse kohe, kuid võib viibida kuni 24 tundi, kui kasutaja parajasti seadet kasutab.

      Kui reegel on seatud väärtusele Väär, siis pärast toote <ph name="PRODUCT_OS_NAME"/> värskendamist automaatset taaskäivitust ei ajastata. Värskendamine viiakse lõpule, kui kasutaja järgmine kord seadme taaskäivitab.

      Kui määrate reegli, ei saa kasutajad seda muuta ega alistada.

      Märkus. Praegu on automaatsed taaskäivitused lubatud ainult siis, kui kuvatakse sisselogimisekraan või kioskirakendus on pooleli. Tulevikus see muutub ja reegel rakendub alati, olenemata sellest, kas mis tahes tüüpi seanss on pooleli või mitte.</translation>
<translation id="5511702823008968136">Luba järjehoidjariba</translation>
<translation id="5105313908130842249">Ekraani lukustamise viiteaeg akutoite kasutamisel</translation>
<translation id="7882585827992171421">Reegel on aktiivne ainult jaerežiimis.

      Määrab laienduse ID, mida kasutatakse sisselogimisekraani ekraanisäästjana. Laiendus peab kuuluma AppPacki, mis on seadistatud domeenile DeviceAppPack-reegliga.</translation>
<translation id="7736666549200541892">Luba TLS-i domeenisuunaliste sertifikaatide laiendus</translation>
<translation id="1796466452925192872">Võimaldab määrata, millised URL-id on lubatud laienduste, rakenduste ja teemade installimiseks.

          Alates versioonist Chrome 21 on väljaspoolt Chrome'i veebipoodi hangitud laienduste, rakenduste ja kasutajaskriptide installimine keeruline. Varem said kasutajad klõpsata *.crx-faili lingil ja Chrome pakkus pärast paari hoiatust võimaluse fail installida. Alates versioonist Chrome 21 tuleb sellised failid alla laadida ja lohistada Chrome'i seadete lehele. Seade võimaldab teatud URL-ide puhul ka vana ja lihtsamat installivoogu.

          Kõik loendis olevad üksused on laiendusstiilis vastendusmustrid (vt http://code.google.com/chrome/extensions/match_patterns.html). Kasutajad saavad üksused hõlpsasti installida mis tahes URL-ilt, mis vastab loendis olevale üksusele. Need mustrid peavad lubama nii *.crx-faili asukoha kui ka lehe, millelt allalaadimine käivitatakse (st viitaja).

          Selle reegli alistab reegel ExtensionInstallBlacklist. See tähendab, et mustas nimekirjas olevat laiendust ei installita isegi siis, kui see toimub loendis olevalt saidilt.</translation>
<translation id="2113068765175018713">Seadme tööaja piiramine automaatse taaskäivitamisega</translation>
<translation id="7848840259379156480">Võimaldab seadistada HTML-i vaikerenderdusmootori, kui <ph name="PRODUCT_FRAME_NAME"/> on installitud. Vaikeseadena on hostbrauseril lubatud renderdada, kuid võite selle soovi korral alistada ja lasta rakendusel <ph name="PRODUCT_FRAME_NAME"/> HTML-lehti vaikimisi renderdada.</translation>
<translation id="186719019195685253">Toiming, mis rakendub siis, kui tegevusetuse viivitusaeg saab täis vahelduvvoolu kasutamise ajal</translation>
<translation id="7890264460280019664">Serverile edastatakse loend võrgu liideste ning nende tüüpide ja riistvara aadresside kohta.

      Kui reegel on määramata või on seatud olekusse Väär, siis liidese loendit ei edastata.</translation>
<translation id="4121350739760194865">Rakenduste reklaamide ilmumise takistamine uuel vahelehel</translation>
<translation id="2127599828444728326">Luba märguanded nendel saitidel</translation>
<translation id="3973371701361892765">Ära peida hoidlat kunagi automaatselt</translation>
<translation id="7635471475589566552">Seadistab rakenduse lokaadi rakenduses <ph name="PRODUCT_NAME"/> ja takistab kasutajatel lokaadi muutmist.

      Seade lubamisel kasutab rakendus <ph name="PRODUCT_NAME"/> määratud lokaati. Kui seadistatud lokaati ei toetata, siis kasutatakse lokaati „en-US”.

      Kui keelate seade või jätate selle määramata, kasutab rakendus <ph name="PRODUCT_NAME"/> kasutaja määratud eelistatud lokaati (kui see on seadistatud), süsteemi lokaati või varulokaati „en-US”.</translation>
<translation id="2948087343485265211">Määrab, kas helitoimingud mõjutavad toitehaldust.

          Kui reegel määratakse tõeseks või jäetakse määramata, ei peeta kasutajat heli esitamise ajal tegevusetuks. Nii ei jõuta jõudeoleku ajalõpuni ja jõudeoleku puhul ette nähtud toimingut ei tehta. Olenemata helitoimingutest aga hämardatakse ekraan, lülitatakse see välja või lukustatakse see pärast seadistatud ajalõppe.

          Kui see reegel on määratud valeks, ei mõjuta helitoimingud kasutaja tegevusetuse määramist.</translation>
<translation id="7842869978353666042">Google Drive'i valikute seadistamine</translation>
<translation id="718956142899066210">Värskenduste jaoks lubatud ühenduse tüübid</translation>
<translation id="1734716591049455502">Kaugjuurdepääsu valikute seadistamine</translation>
<translation id="7336878834592315572">Säilita küpsised seansi kestuse jooksul</translation>
<translation id="7715711044277116530">Esitlusrežiimis ekraani tumenduse viivituse skaleerimise määr protsentides</translation>
<translation id="8777120694819070607">Võimaldab rakendusel <ph name="PRODUCT_NAME"/> käitada vananenud pistikprogramme. Kui lubate selle seade, kasutatakse vananenud pistikprogramme tavapärasel moel. Kui keelate seade, ei kasutata vananenud pistikprogramme ja kasutajatelt ei küsita luba nende kasutamiseks. Kui seade ei ole määratud, küsitakse kasutajatelt luba vananenud pistikprogrammide käitamiseks.</translation>
<translation id="2629448496147630947">Kaugjuurdepääsu valikute seadistamine rakenduses <ph name="PRODUCT_NAME"/>. Kui kaugjuurdepääsu veebirakendus pole installitud, siis neid funktsioone ignoreeritakse.</translation>
<translation id="1310699457130669094">Siin saate määrata puhverserveri pac-faili URL-i.

          Reegel kehtib vaid juhul, kui valisite jaotises „Valige puhverserveri seadete määramise viis” puhverserveri käsitsi seadistamise.

          Jätke see reegel määramata, kui valisite puhverserveri reeglite määramiseks muu viisi.

          Vaadake üksikasjalikke näiteid:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="1509692106376861764">Reegel on alates rakenduse <ph name="PRODUCT_NAME"/> versioonist 29 kasutusest kõrvaldatud.</translation>
<translation id="5464816904705580310">Hallatud kasutajate seadete konfigureerimine.</translation>
<translation id="3219421230122020860">Saadaval on inkognito režiim</translation>
<translation id="7690740696284155549">Seadistab kataloogi, mida <ph name="PRODUCT_NAME"/> kasutab failide allalaadimiseks.

      Kui selle reegli määrate, kasutab <ph name="PRODUCT_NAME"/> antud kataloogi olenemata sellest, kas kasutaja on selle määranud või lubanud allalaadimise asukoha valimisel iga kord märgistuse esitamise.

      Saidilt http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables leiate loendi muutujatest, mida saab kasutada.

      Kui seda reeglit ei määrata, kasutatakse allalaadimise vaikekataloogi ja kasutaja saab seda muuta.</translation>
<translation id="7381326101471547614">Keelab SPDY-protokolli kasutamise rakenduses <ph name="PRODUCT_NAME"/>. Kui reegel on lubatud, siis ei ole SPDY-protokoll rakenduses <ph name="PRODUCT_NAME"/> saadaval. Reegli keelamisel on SPDY kasutamine lubatud. Kui jätate reegli määramata, siis on SPDY saadaval.</translation>
<translation id="2208976000652006649">Parameetrid POST-meetodit kasutava otsingu URL-i jaoks</translation>
<translation id="1583248206450240930">Kasuta vaikimisi rakendust <ph name="PRODUCT_FRAME_NAME"/></translation>
<translation id="1047128214168693844">Keela kõigil saitidel kasutajate füüsilise asukoha jälgimine</translation>
<translation id="4101778963403261403">Määrab rakenduse <ph name="PRODUCT_NAME"/> vaikeavalehe tüübi ja takistab kasutajatel avalehe eelistuste muutmist. Avaleheks võib määrata teie valitud URL-i või uue vahelehe.

          Seade lubamisel kasutatakse avalehena alati uut vahelehte ja avalehe URL-i asukohta ignoreeritakse.

          Seade keelamisel ei kasutata avalehena kunagi uut vahelehte, välja arvatud juhul, kui avalehe URL-iks on määratud „chrome://newtab”.

          Seade lubamisel või keelamisel ei saa kasutajad rakenduses <ph name="PRODUCT_NAME"/> avalehe tüüpi muuta.

          Kui jätate selle reegli määramata, siis saab kasutaja valida, kas ta soovib oma avalehena kasutada uut vahelehte.</translation>
<translation id="8970205333161758602">Toote <ph name="PRODUCT_FRAME_NAME"/> tagasilükkamisviiba keelamine</translation>
<translation id="3273221114520206906">JavaScripti vaikeseade</translation>
<translation id="4025586928523884733">Blokeerib kolmanda osapoole küpsised.

      Kui lubate seade, siis takistatakse veebilehtede elementidel, mis ei pärine brauseri aadressiribal olevast domeenist, küpsiste määramine.

      Kui keelate seade, siis saavad veebilehe elemendid, mis ei pärine brauseri aadressiribal olevast domeenist, küpsiseid määrata ja takistavad kasutajatel seade muutmist.

      Kui jätate selle reegli määramata, siis lubatakse kolmanda osapoole küpsised, kuid kasutaja saab seda muuta.</translation>
<translation id="6810445994095397827">Blokeeri JavaScript nendel saitidel</translation>
<translation id="6672934768721876104">See reegel on aegunud, kasutage selle asemel reeglit „ProxyMode”.

          Võimaldab määrata puhverserveri, mida rakendus <ph name="PRODUCT_NAME"/> kasutab, ja takistab kasutajatel puhverserveri seadete muutmist.

          Kui otsustate puhverserverit mitte kasutada ja alati ühenduse vahetult luua, siis ignoreeritakse kõiki muid valikuid.

          Kui otsustate kasutada süsteemi puhverserveri seadeid või tuvastada puhverserveri automaatselt, siis ignoreeritakse kõiki muid valikuid.

          Kui valite puhverserveri käsitsi seadistamise, siis saate määrata lisavalikud jaotistes „Puhverserveri aadress või URL”, „Puhverserveri pac-faili URL” ja „Komaeraldusega reeglite loend puhverserverist möödumiseks”.

          Vaadake üksikasjalikke näiteid:
          <ph name="PROXY_HELP_URL"/>

          Seade lubamisel ignoreerib rakendus <ph name="PRODUCT_NAME"/> kõiki käsureal määratud puhverserveriga seotud valikuid.

          Kui jätate selle reegli määramata, siis saavad kasutajad ise puhverserveri seaded valida.</translation>
<translation id="3780152581321609624">Kaasa Kerberose SPN-i mittestandardne port</translation>
<translation id="1749815929501097806">Määrab teenusetingimused, millega kasutaja peab enne seadmes kasutatava konto seansi käivitamist nõustuma.

      Kui see reegel määratakse, laadib <ph name="PRODUCT_OS_NAME"/> alla teenusetingimused ja esitab need kasutajale seadmes kasutatava konto seansi käivitamisel. Kasutajal lubatakse seanssi siseneda ainult pärast teenusetingimustega nõustumist.

      Kui jätate selle reegli määramata, siis teenusetingimusi ei kuvata.

      Reegel tuleb määrata URL-ile, kust <ph name="PRODUCT_OS_NAME"/> saab teenusetingimused alla laadida. Teenusetingimused peavad olema lihtteksti vormingus, esitatud MIME-tüüpi tekstina/lihttekstina. Märgistused pole lubatud.</translation>
<translation id="2660846099862559570">Ära kunagi kasuta puhverserverit</translation>
<translation id="1435659902881071157">Seadme tasemel võrgukonfigureerimine</translation>
<translation id="2131902621292742709">Ekraani hämardamise viiteaeg akutoite kasutamisel</translation>
<translation id="5781806558783210276">Määrab aja, pärast mida lülitatakse akutoitega töötamisel sisse jõudeolek, kui kasutaja pole midagi sisestanud.

          Kui see reegel määratakse, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui <ph name="PRODUCT_OS_NAME"/> jõudeoleku sisse lülitab (selle saab seadistada eraldi).

          Kui jätate selle reegli määramata, kasutatakse vaikeaega.

          Reegli väärtus tuleb määrata millisekundites.</translation>
<translation id="5512418063782665071">Avalehe URL</translation>
<translation id="2948381198510798695">Rakendus <ph name="PRODUCT_NAME"/> möödub siin loetletud hostide puhul kõikidest puhverserveritest.

          Reegel kehtivad vaid juhul, kui valisite jaotises „Valige puhverserveri seadete määramise viis” puhverserveri käsitsi seadistamise.

          Jätke see reegel määramata, kui valisite puhverserveri reeglite seadistamiseks muu viisi.

          Vaadake üksikasjalikke näiteid:
          <ph name="PROXY_HELP_URL"/></translation>
<translation id="6658245400435704251">Määrab sekundite arvu pärast värskenduse serverist väljalaskmist, mille jooksul võib seade värskenduse allalaadimist juhuslikult viivitada. Seade võib oodata osa ajast reaalajas ja ülejäänud aja sõltuvalt värskenduste otsimiste arvust. Igal juhul on hajutatuse ülempiir seotud ajalise konstandiga, et seade ei jääks värskenduse allalaadimist igaveseks ootama.</translation>
<translation id="523505283826916779">Juurdepääsuseaded</translation>
<translation id="1948757837129151165">HTTP autentimise reeglid</translation>
<translation id="5946082169633555022">Beetakanal</translation>
<translation id="7187256234726597551">Kui see on seatud väärtusele Tõene, on seadme kaugkinnitus lubatud ning sertifikaat luuakse ja laaditakse seadmehaldusserverisse üles automaatselt.

          Kui reegel on määramata või seatud väärtusele Väär, siis sertifikaati ei looda ja kõned üksuse enterprise.platformKeysPrivate laienduse API-le ebaõnnestuvad.</translation>
<translation id="5242696907817524533">Seadistab hallatud järjehoidjate loendi.

      Reegel koosneb järjehoidjate loendist ja iga järjehoidja on sõnastik, mis sisaldab järjehoidja nime ja siht-URL-i.

      Need järjehoidjad lisatakse jaotise Mobiili järjehoidjad kausta Hallatud järjehoidjad. Kasutaja ei saa neid järjehoidjaid muuta.

      Kui määratakse see reegel, siis avatakse Chrome'is järjehoidjate kuva avamisel vaikimisi kaust Hallatud järjehoidjad.

      Hallatud järjehoidjaid ei sünkroonita kasutaja kontoga.</translation>
<translation id="8303314579975657113">Määrab GSSAPI teegi, mida kasutatakse HTTP autentimiseks. Võite määrata vaid teegi nime või kogu tee.

          Kui jätate seade määramata, siis kasutab rakendus <ph name="PRODUCT_NAME"/> teegi vaikenime.</translation>
<translation id="7749402620209366169">Lubab kaugjuurdepääsu hostide autentimiseks kasutaja määratud PIN-koodi asemel kahetasandilise autentimise.

          Kui seade on lubatud, siis peavad kasutajad hosti pääsemiseks esitama kehtiva kahetasandilise koodi.

          Kui seade on keelatud või pole määratud, siis pole kahetasandiline autentimine lubatud ja vaikimisi kasutatakse kasutaja määratud PIN-koodi.</translation>
<translation id="7329842439428490522">Määrab aja, pärast mida ekraan akutoitega töötamisel välja lülitatakse, kui kasutaja pole midagi sisestanud.

          Kui selle reegli väärtuseks määratakse arv, mis on suurem kui null, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui <ph name="PRODUCT_OS_NAME"/> ekraani välja lülitab.

          Kui reegli väärtuseks on määratud null, ei lülita rakendus <ph name="PRODUCT_OS_NAME"/> ekraani välja, kui kasutaja on tegevusetu.

          Kui jätate selle reegli määramata, kasutatakse vaikeaega.

          Reegli väärtus tuleb määrata millisekundites. Väärtused tuleb kinnitada väiksematena kui jõudeoleku viiteaeg või sellega võrdsetena.</translation>
<translation id="384743459174066962">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel ei ole lubatud hüpikuid avada.

          Kui jätate selle reegli määramata, siis kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultPopupsSetting”, kui see on määratud, või kasutaja isiklikku konfigureerimist.</translation>
<translation id="5645779841392247734">Luba küpsised nendel saitidel</translation>
<translation id="4043912146394966243"> Ühendustüübid, mis on lubatud kasutamiseks OS-i värskendamiseks. OS-i värskendused võivad oma mahu tõttu panna ühendusele suure koormuse ja sellega võib kaasneda ka lisakulu. Seepärast pole need vaikimisi lubatud ühendustüüpidele, mida peetakse kalliteks ja mille hulka praegu kuuluvad WiMax, Bluetooth ja Cellular.

      Tunnustatud ühendustüübi identifikaatorid on „ethernet”, „wifi”, „wimax”, „bluetooth” ja „cellular”.</translation>
<translation id="6652197835259177259">Kohalikult hallatud kasutajaseaded</translation>
<translation id="3243309373265599239">Määrab aja, pärast mida hämardatakse võrgutoitega töötamisel ekraan, kui kasutaja pole midagi sisestanud.

          Kui selle reegli väärtuseks määratakse arv, mis on suurem kui null, määrab see aja, mille jooksul peab kasutaja olema tegevusetu, enne kui <ph name="PRODUCT_OS_NAME"/> ekraani hämardab.

          Kui reegli väärtuseks on määratud null, ei hämarda <ph name="PRODUCT_OS_NAME"/> ekraani, kui kasutaja on tegevusetu.

          Kui jätate selle reegli määramata, kasutatakse vaikeaega.

          Reegli väärtus tuleb määrata millisekundites. Väärtused tuleb kinnitada väiksematena kui ekraani väljalülitamise viiteaeg (kui see on määratud) ja jõudeoleku viiteaeg või nendega võrdsetena.</translation>
<translation id="3859780406608282662">Parameteri lisamine variatsioonide lähteväärtuse toomisel rakendusest <ph name="PRODUCT_OS_NAME"/>.

      Kui see on määratud, lisab see päringuparameetri „piira” URL-ile, mida kasutatakse variatsioonide lähteväärtuse toomisel. Parameetri väärtuseks on reeglis määratud väärtus.

      Kui seda pole määratud, siis see variatsioonide lähteväärtuse URL-i ei muuda.</translation>
<translation id="7049373494483449255">Lubab rakendusel <ph name="PRODUCT_NAME"/> saata dokumendid printimiseks teenusesse <ph name="CLOUD_PRINT_NAME"/>. MÄRKUS. See mõjutab vaid teenuse <ph name="CLOUD_PRINT_NAME"/> tuge rakenduses <ph name="PRODUCT_NAME"/>. See ei takista kasutajatel veebisaitidel printimistööde saatmist.

      Kui seade on lubatud või seadistamata, siis saavad kasutajad rakenduse <ph name="PRODUCT_NAME"/> printimisdialoogis teenuse <ph name="CLOUD_PRINT_NAME"/> abil printida.

      Seade keelamisel ei saa kasutajad rakenduse <ph name="PRODUCT_NAME"/> printimisdialoogis teenuse <ph name="CLOUD_PRINT_NAME"/> abil printida.</translation>
<translation id="4088589230932595924">Inkognito režiim on jõustatud</translation>
<translation id="5862253018042179045">Sisselogimisekraanil suulise tagasiside hõlbustusfunktsiooni vaikeoleku määramine.

          Kui reegel on seatud väärtusele Tõene, lubatakse sisselogimisekraani kuvamisel suuline tagasiside.

          Kui reegel on seatud väärtusele Väär, keelatakse sisselogimisekraani kuvamisel suuline tagasiside.

          Kui määrate reegli, saavad kasutajad selle ajutiselt alistada, lubades või keelates suulise tagasiside. Kasutaja valik pole siiski püsiv ja vaikeväärtus taastatakse, kui kuvatakse uuesti sisselogimisekraan või kui kasutaja jääb sisselogimisekraanile minutiks tegevuseta olekusse.

          Kui jätate reegli määramata, on suuline tagasiside algselt keelatud. Kasutaja võib suulise tagasiside igal ajal lubada või keelata ja selle olek jääb sisselogimisekraanil kasutajati püsivaks.</translation>
<translation id="8197918588508433925">Reegel määrab lubatud laiendused, mida kasutada kaugatesteerimisel Enterprise Platform Keys API chrome.enterprise.platformKeysPrivate.challengeUserKey() jaoks. API kasutamiseks tuleb laiendused loendisse kanda.

          Kui laiendust loendis pole või kui loendit pole koostatud, siis kõne API-le ebaõnnestub ja saate vastuseks veakoodi.</translation>
<translation id="7649638372654023172">Seadistab rakenduses <ph name="PRODUCT_NAME"/> avalehe vaike-URL-i ja takistab kasutajatel selle muutmist.

          Avaleht on leht, mis avaneb nupu Kodu vajutamisel. Käivitamisel avanevatele lehtedele kehtib reegel RestoreOnStartup.

          Avalehe tüübiks saab määrata URL-i, mille saab määrata siin, või uue vahelehe. Kui valite uue vahelehe, siis seda reeglit ei rakendata.

          Kui lubate selle seade, siis ei saa kasutajad rakenduses <ph name="PRODUCT_NAME"/> oma avalehe URL-i muuta, kuid saavad valida oma avaleheks uue vahelehe.

          Kui jätate reegli määramata ja määramata on ka reegel HomepageIsNewTabPage, siis saab kasutaja avalehe ise valida.</translation>
</translationbundle>