<?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="793134539373873765">Määrab, kas OS-i värskendamise lastide jaoks kasutatakse p2p-võrgustikku. Kui väärtuseks on seatud Tõene, siis seade jagab ja proovib tarbida värskendamise laste LAN-is, vähendades potentsiaalselt Interneti-ribalaiuse kasutamist ja ummistumist. Kui värskendamise last pole LAN-is saadaval, naaseb seade allalaadimise juurde värskendusserverist. Kui väärtuseks on seatud Vale või see pole määratud, siis p2p-võrgustikku ei kasutata.</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="7267809745244694722">Meediaklahvid on vaikimisi funktsiooniklahvid</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="5298412045697677971">Seadistage kasutaja avatari kujutis.

      See reegel lubab teil seadistada avatari kujutise, mis esindab kasutajat sisselogimisekraanil. URL-i täpsustamisega määratakse reegel, kust operatsioonisüsteem <ph name="PRODUCT_OS_NAME"/> saab alla laadida avatari kujutise ja krüptograafilise räsimärgi, mida kasutatakse allalaaditava faili terviklikkuse kontrollimiseks. Kujutis peab olema JPEG-vormingus ja selle maht ei tohi ületada 512 kB. URL peab olema juurdepääsetav ilma igasuguse autentimiseta.

      Avatari kujutis laaditakse alla ja salvestatakse vahemällu. Kui URL või räsimärk muutub, laaditakse see uuesti alla.

      Reegel tuleb määrata stringina, milles on välja toodud URL ja räsimärk JSON-vormingus, mis vastab järgmisele skeemile:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;URL, kust avatari kujutise saab alla laadida.&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;Avatari kujutise SHA-256 räsimärk.&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Kui see reegel määratakse, laadib operatsioonisüsteem <ph name="PRODUCT_OS_NAME"/> avatari kujutise alla ja kasutab seda.

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

      Kui te reeglit ei määra, saab kasutaja valida teda esindava avatari kujutise sisselogimisekraanil.</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="2482676533225429905">Omasõnumside</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="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="8294750666104911727">Tavaliselt renderdatakse lehed, mille metasilt X-UA-Compatible on seatud väärtusele chrome=1 teenuses <ph name="PRODUCT_FRAME_NAME"/>, olenemata reeglist „ChromeFrameRendererSettings”.

          Kui lubate selle seade, siis lehti metasiltide osas ei skannita.

          Kui keelate selle seade, siis skannitakse lehti metasiltide osas.

          Kui reegel pole määratud, siis skannitakse lehti metasiltide osas.</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="979541737284082440">(See dokument võib sisaldada reegleid, mis on sihitud teenuse
      <ph name="PRODUCT_NAME"/> hilisematele versioonidele, ja need võivad
      ette teatamata muutuda. Toetatud reeglid on
      Chromiumi ja Google Chrome'i puhul samad.)

      Te ei pea neid seadeid käsitsi muutma!  Siit saate alla laadida hõlpsalt kasutatavad mallid:
      <ph name="POLICY_TEMPLATE_DOWNLOAD_URL"/>.

      Need reeglid on mõeldud ainult teie organisatsioonis kasutatavate Chrome'i eksemplaride konfigureerimiseks. Nende reeglite kasutamist teie organisatsioonist väljaspool (näiteks avalikult levitatavas programmis) loetakse pahavaraks ning ka Google ja viirusetõrje teenusepakkujad märgivad need tõenäoliselt pahavaraks.

      Märkus. Alates teenusest <ph name="PRODUCT_NAME"/>
      28 laaditakse reeglid otse rühmareeglite API-st
      Windowsis. Registrisse käsitsi kirjutatud reegleid eiratakse. Üksikasjad leiate
      saidilt http://crbug.com/259236.

      Alates teenusest <ph name="PRODUCT_NAME"/> 35 loetakse reegleid otse registrist, kui tööjaam ühendatakse Active Directory domeeniga; muul juhul loetakse reegleid GPO-st.</translation>
<translation id="4157003184375321727">OS-ist ja püsivara versioonist teavitamine</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="4555850956567117258">Kasutajale kaugatesteerimise lubamine</translation>
<translation id="5966615072639944554">Kaugatesteerimise API kasutamiseks lubatud laiendused</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="268577405881275241">Andmete tihendamise puhverserveri funktsiooni lubamine</translation>
<translation id="3820526221169548563">Ekraanil kuvatava klaviatuuri lubamine.

          Kui reegel seatakse väärtusele Tõene, on ekraanil kuvatav klaviatuur alati lubatud.

          Kui reegel seatakse väärtusele Väär, on ekraanil kuvatav klaviatuur alati keelatud.

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

          Kui jätate reegli määramata, on ekraanil kuvatav klaviatuur algselt keelatud, kuid kasutaja saab selle igal ajal lubada.</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="2067011586099792101">Sisupakettidest väljaspool olevatele saitidele juurdepääsu blokeerimine</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="5318185076587284965">Luba kaugjuurdepääsuhostil kasutada releeservereid</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="4807950475297505572">Kõige kauem aega tagasi kasutanud kasutajad eemaldatakse, kuni on piisavalt vaba ruumi</translation>
<translation id="8789506358653607371">Täisekraanrežiimi lubamine.

      Reegel juhib täisekraanrežiimi saadavalolekut, milles kõik toote <ph name="PRODUCT_NAME"/> kasutajaliidese elemendid on varjatud ja nähtav on ainult veebisisu.

      Kui reegel seatakse väärtusele Tõene või jäetakse seadistamata, saavad kasutaja, rakendused ja laiendused asjakohaste lubade korral kasutada täisekraanrežiimi.

      Kui reegel seatakse väärtusele Väär, ei saa kasutaja ega ka ükski rakendus ega laiendus kasutada täisekraanrežiimi.

      Kui täisekraanrežiim keelatakse, ei ole kioskirežiim saadaval ühelgi platvormil, välja arvatud <ph name="PRODUCT_OS_NAME"/>.</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="7173856672248996428">Kaduvad profiilid</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öölaua märguannete kuvamine</translation>
<translation id="8614804915612153606">Keelab automaatvärskenduse</translation>
<translation id="4834526953114077364">Kõige kauem aega tagasi kasutanud kasutajad, kes ei ole viimase 3 kuu jooksul sisse loginud, eemaldatakse, kuni on piisavalt vaba ruumi</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="4386578721025870401">Piirake aega, mille jooksul SAML-i kaudu autenditud kasutaja saab võrguühenduseta sisse logida.

      Sisselogimisel saab Chrome OS autentida serveri kaudu (võrgus) või vahemällu salvestatud parooli (võrguühenduseta) kasutades.

      Kui see reegel on määratud väärtusele –1, saab kasutaja autentida võrguühenduseta ajaliste piiranguteta. Kui reegel on määratud mõnele muule väärtusele, siis täpsustab see ajaperioodi, mille möödudes peab kasutaja uuesti kasutama võrgus autentimist.

      Kui te seda reeglit ei määra, kasutab <ph name="PRODUCT_OS_NAME"/> 14 päeva pikkust vaikeajapiirangut, pärast mida peab kasutaja uuesti kasutama võrgus autentimist.

      See reegel mõjutab ainult neid kasutajad, kes kasutavad autentimiseks SAML-i.

      Reegli väärtus tuleb määrata sekundites.</translation>
<translation id="3758249152301468420">Keela arendaja tööriistad</translation>
<translation id="8665076741187546529">Sunnitult installitud laienduste loendi seadistamine</translation>
<translation id="2386768843390156671">Võimaldab omasõnumside hostide kasutajate tasemel installimise.

          Kui see seade lubatakse, lubab teenus <ph name="PRODUCT_NAME"/>
          kasutada kasutaja tasemel installitud omasõnumside hoste.

          Kui see seade keelatakse, kasutab teenus <ph name="PRODUCT_NAME"/>
          ainult süsteemi tasemel installitud omasõnumside hoste.

          Kui seda seadet ei määrata, lubab teenus <ph name="PRODUCT_NAME"/>
          kasutada kasutaja tasemel omasõnumside hoste.</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="6598235178374410284">Kasutaja avatarkujutis</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="4372704773119750918">Ärge lubage ettevõtte kasutajal olla osa multiprofiilist (esmane või teisene)</translation>
<translation id="7027785306666625591">Operatsioonisüsteemi <ph name="PRODUCT_OS_NAME"/> toitehalduse seadistamine.

      Need reeglid võimaldavad teil seadistada, kuidas <ph name="PRODUCT_OS_NAME"/> käitub, kui kasutaja on teatud aja vältel tegevusetu.</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="8176035528522326671">Luba ettevõtte kasutajal olla ainult peamine mitme profiiliga kasutaja (vaikekäitumine ettevõtte hallatud kasutajate puhul)</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="348495353354674884">Luba virtuaalne klaviatuur</translation>
<translation id="2168397434410358693">Jõudeoleku viiteaeg võrgutoite kasutamisel</translation>
<translation id="838870586332499308">Luba andmeside rändlusteenus</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="8112122435099806139">Määrab seadmes kasutatava kellaaja vormingu.

      See reegel seadistab kellaaja vormingu, mida kasutatakse sisselogimisekraanil ja vaikevalikuna kasutaja seansside jaoks. Kasutajad saavad kellaaja vormingut oma kontol muuta.

      Kui reegel on määratud väärtusele Tõene, siis kasutab seade 24-tunnist kellaaja vormingut. Kui reegel on määratud väärtusele Väär, siis kasutab seade 12-tunnist kellaaja vormingut.

      Kui reegel on määramata, siis kasutab seade vaikevalikuna 24-tunnist kellaaja vormingut.</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="6064943054844745819">Määrake loend iganenud veebiplatvormi funktsioonidest, mis tuleb uuesti lubada.

      See reegel võimaldab piiratud ajaks administraatoril uuesti lubada iganenud veebiplatvormi funktsioonid. Funktsioonid tuvastatakse stringi märgendiga ja reegliga määratud loendis sisalduvad märgenditele vastavad funktsioonid lubatakse uuesti.

      Praegu on määratud järgmised märgendid:
      - ShowModalDialog_EffectiveUntil20150430

      Kui see reegel on määramata või loend on tühi, siis jäävad kõik iganenud veebiplatvormi funktsioonid keelatuks.</translation>
<translation id="3805659594028420438">Luba TLS-i domeenisuunaliste sertifikaatide laiendus (pakkumine on peatatud)</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="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="2488010520405124654">Võrguseadistuse viiba lubamine, kui seade on võrguühenduseta.

      Kui seda reeglit pole määratud või on määratud valikule Tõene ja seadme kohalik konto on seadistatud viivituseta automaatsele sisselogimisele ning seadmel puudub Interneti-ühendus, siis kuvab operatsioonisüsteem <ph name="PRODUCT_OS_NAME"/> võrguseadistuse viiba.

      Kui reegel on määratud valikule Väär, kuvatakse võrguseadistuse viiba asemel veateade.</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="8140204717286305802">Saadab serverile loendi võrguliideste ning nende tüüpide ja riistvara aadresside kohta.

      Kui reegel määratakse olekule Väär, siis liideseloendit ei edastata.</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="1017967144265860778">Toitehaldus sisselogimiskuval</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="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="5776485039795852974">Küsi iga kord, kui sait tahab näidata töölauateatisi</translation>
<translation id="5047604665028708335">Sisupakettidest väljaspool olevatele saitidele juurdepääsu lubamine</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="7132877481099023201">URL-id, millele antakse ilma küsimata juurdepääs videojäädvustusseadmetele</translation>
<translation id="8947415621777543415">Esita seadme asukoht</translation>
<translation id="1655229863189977773">Määrake ketta vahemälu suurus baitides</translation>
<translation id="3358275192586364144">Lubab tootes <ph name="PRODUCT_NAME"/> WPAD-optimeerimise ega lase kasutajatel seda seadet muuta.

      Kui see reegel on lubatud, siis ootab Chrome DNS-põhiste WPAD-serverite puhul lühemat intervalli.

      Kui seda reeglit ei määrata, siis on see lubatud ja kasutaja
      ei saa seda muuta.</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="4639407427807680016">Omasõnumside hostide nimed mustast nimekirjast välistamiseks</translation>
<translation id="8382184662529825177">Kaugatesteerimise lubamine seadme sisu kaitsmiseks</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="480987484799365700">Kui on lubatud, nõuavad eeskirjad, et profiil oleks lülitatud kadumisrežiimile. Kui eeskirjad on määratletud OS-i eeskirjadena (nt GPO Windowsis), rakendub see süsteemi kõikidele profiilidele; kui eeskirjad on määratletud pilve-eeskirjadena, rakenduvad need ainult profiilidele, millele on sisse logitud hallatud kontoga.

      Selles režiimis säilitatakse profiili andmeid kettal ainult kasutajaseansi ajal. Funktsioone (nagu brauseri ajalugu, laiendused ja nende andmed) ning veebiandmeid (nagu küpsised ning veebi andmebaasid) ei säilitata pärast brauseri sulgemist. See ei takista kasutajal käsitsi kettale andmeid alla laadimast, lehti salvestamast ega neid printimast.

      Kui kasutaja on sünkroonimise lubanud, säilitatakse kõik need andmed kasutaja sünkroonimisprofiilil nagu tavaliste profiilide puhul. Saadaval on ka inkognitorežiim, kui eeskirjad ei ole seda sõnaselgelt keelanud.

      Kui ei ole lubatud või on jäetud määramata, viib sisselogimine tavaliste profiilide juurde.</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="467449052039111439">Ava URL-ide loend</translation>
<translation id="1988371335297483117">Automaatse värskendamise lastid tootes <ph name="PRODUCT_OS_NAME"/> saab HTTPS-i asemel alla laadida HTTP kaudu. See lubab HTTP kaudu allalaaditud failidele läbipaistva HTTP-vahemälu kasutamist.

      Kui reegel on seatud väärtusele Tõene, proovib <ph name="PRODUCT_OS_NAME"/> automaatsete värskenduste laste alla laadida HTTP kaudu. Kui reegel on seatud väärtusele Väär või on määramata, kasutatakse automaatsete värskenduste lastide allalaadimiseks HTTPS-i.</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="4557134566541205630">Otsingupakkuja uue vahelehe vaike-URL</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="7260277299188117560">Lubatud p2p automaatne värskendamine</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="6211428344788340116">Saadab teavet seadme aktiivsuse aja kohta.

      Kui te seda seadet ei määra või määrate olekule Tõene, saadavad registreeritud seadmed teavet ajaperioodide kohta, mil kasutaja seadet kasutab. Kui määrate seade olekule Väär, siis ei talletata ega saadeta teavet seadme aktiivsuse aja kohta.</translation>
<translation id="3964909636571393861">Võimaldab juurdepääsu URL-ide loendile</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="383466854578875212">Lubab määrata, millised omasõnumside hostid välistatakse mustast nimekirjast.

          Musta nimekirja väärtus * tähendab, et kõik omasõnumside hostid on mustas nimekirjas ja laaditakse ainult lubatud üksuste loendisse lisatud omasõnumside hostid.

          Vaikimisi on kõik omasõnumside hostid lubatud üksuste loendis, kui aga reegli kohaselt on kõik omasõnumside hostid mustas nimekirjas, siis saab kasutada lubatud üksuste loendit selle reegli alistamiseks.</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="5836064773277134605">Piira kaugjuurdepääsuhosti kasutatavate UDP-portide vahemikku</translation>
<translation id="7625444193696794922">Määrab väljalaskekanali, millele seade tuleks lukustada.</translation>
<translation id="2552966063069741410">Ajavöönd</translation>
<translation id="3788662722837364290">Toitehalduse seaded, kui kasutaja on tegevusetu</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="2956777931324644324">Selle reegli pakkumine lõpetati toote <ph name="PRODUCT_NAME"/> versiooniga 36.

      Määrab, kas TLS-i domeenisuunaline sertifikaatide laiendus peab olema lubatud.

      Selle seadega lubatakse testimiseks TLS-i domeenisuunaline sertifikaatide laiendus. See katseline seade eemaldatakse tulevikus.</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="1327466551276625742">Võrguseadistuse viiba lubamine, kui seade on võrguühenduseta</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="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="2201555246697292490">Omasõnumside lubatud üksuste loendi seadistamine</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="5196805177499964601">Blokeerige arendaja režiim.

      Kui see reegel on tõene, ei luba üksus <ph name="PRODUCT_OS_NAME"/> seadmel arendaja režiimi käivitada. Süsteem keeldub käivitamisest ja kuvab arendaja lüliti sisselülitamisel veaekraani.

      Kui see reegel on määramata või vale, on arendaja režiim seadmes saadaval.</translation>
<translation id="1265053460044691532">Piirake aega, mille jooksul SAML-i kaudu autenditud kasutaja saab võrguühenduseta sisse logida</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="2744751866269053547">Protokollitöötlejate registreerimine</translation>
<translation id="6367755442345892511">Määramine, kas kasutajal on võimalik versiooni kanalit seadistada</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="3756011779061588474">Arendaja režiimi blokeerimine</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="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="7933141401888114454">Järelevalvega kasutajate loomise lubamine</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="1950814444940346204">Iganenud veebiplatvormi funktsioonide lubamine</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="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="5365946944967967336">Kuva tööriistaribal nuppu Avaleht</translation>
<translation id="3709266154059827597">Laienduste installimise musta nimekirja seadistamine</translation>
<translation id="1933378685401357864">Taustapildi kujutis</translation>
<translation id="8451988835943702790">Kasuta avalehena Uut vahelehte</translation>
<translation id="4617338332148204752">Metasildi kontrollimise vahelejätmine teenuses <ph name="PRODUCT_FRAME_NAME"/></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="687046793986382807">Selle reegli pakkumine lõpetati toote <ph name="PRODUCT_NAME"/> versiooniga 35.

      Valiku väärtustest olenemata edastatakse mäluteabe aruandlus alati lehele, kuid                 edastatud suurused
      on kvantifitseeritud ja värskenduste määra piiratakse turvakaalutlustel.
      Reaalajas täpsete andmete hankimiseks kasutage sellist tööriista nagu            telemeetria.</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="7332963785317884918">Reegel on peatatud. <ph name="PRODUCT_OS_NAME"/> kasutab alati puhastusstrateegiat „RemoveLRU”.

      Juhib automaatset puhastamist operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME"/> seadmetes. Automaatne puhastamine käivitatakse osaliseks kettaruumi vabastamiseks, kui vaba kettaruumi hulk on jõudnud kriitilise tasemeni.

      Kui reegel on määratud valikule „RemoveLRU”, jätkab automaatne puhastamine kasutajate eemaldamist seadmest, lähtudes sellest, milline kasutaja kõige kauem aega tagasi sisse logis, kuni on piisavalt vaba ruumi.

      Kui reegel on määratud valikule „RemoveLRUIfDormant”, jätkab automaatne puhastamine nende kasutajate eemaldamist, kes ei ole vähemalt 3 kuu jooksul sisse loginud, lähtudes sellest, milline kasutaja kõige kauem aega tagasi sisse logis, kuni on piisavalt vaba ruumi.

      Kui reegel on määramata, kasutab automaatne puhastamine sisseehitatud vaikestrateegiat. Praegu on selleks strateegia „RemoveLRUIfDormant”.</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="5447306928176905178">Mäluteabe (JS kuhja maht) aruandluse lubamine lehele (iganenud)</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="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="9175109938712007705">Kuna veebipõhised softfail-tühistamiskontrollid ei suurenda turvalisust, keelatakse need vaikimisi rakenduse <ph name="PRODUCT_NAME"/> 19. versioonis ja hilisemates versioonides. Kui seate reegli väärtusele Tõene, taastatakse varasem käitumine ja kasutatakse veebipõhiseid OCSP-/CRL-kontrolle.

      Kui jätate reegli määramata või seate selle väärtuseks Väär, ei tehta Chrome'i 19. versioonis ja hilisemates versioonides veebipõhiseid tühistamiskontrolle.</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="6095999036251797924">Määrab, kui palju aega võib mööduda kasutaja viimasest toimingust, enne kui ekraan lukustatakse, kui seade töötab vahelduvvoolu- või akutoitel.

          Kui aja väärtus on suurem kui null, siis tähistab see aega, mille jooksul kasutaja peab olema tegevusetu enne, kui operatsioonisüsteem <ph name="PRODUCT_OS_NAME"/> lukustab ekraani.

          Kui aja väärtus on null, siis ei lukusta <ph name="PRODUCT_OS_NAME"/> kasutaja tegevusetuse korral ekraani.

          Kui aega pole määratud, siis kasutatakse vaikeaega.

          Soovitatud viis tegevusetuse korral ekraani lukustamiseks on lubada ekraanilukk peatamise korral ja lasta operatsioonisüsteemil <ph name="PRODUCT_OS_NAME"/> peatada seade pärast tegevusetuse aega. Seda reeglit tuleks kasutada ainult siis, kui ekraani lukustamine peaks toimuma oluliselt varem kui peatamine või kui te ei soovi, et tegevusetuse korral toimuks peatamine.

          Reegli väärtus tuleb määrata millisekundites. Väärtusi piiratakse nii, et need oleks väiksemad kui tegevusetuse aeg.</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="1464848559468748897">Kasutaja käitumise juhtimine mitme profiiliga seansside puhul operatsioonisüsteemi <ph name="PRODUCT_OS_NAME"/> seadmetes.

      Kui reegel on määratud valikule „MultiProfileUserBehaviorUnrestricted”, saab kasutaja mitme profiiliga seansi puhul olla kas peamine või sekundaarne kasutaja.

      Kui reegel on määratud valikule „MultiProfileUserBehaviorMustBePrimary”, saab kasutaja mitme profiiliga seansi puhul olla ainult peamine kasutaja..

      Kui reegel on määratud valikule „MultiProfileUserBehaviorNotAllowed”, ei saa kasutaja osaleda mitme profiiliga seansis.

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

      Kui seadet muudetakse ajal, mil kasutaja on mitme profiiliga seanssi sisse logitud, kontrollitakse seansi kõiki kasutajaid vastavate seadete alusel. Seanss suletakse, kui ühel kasutajal ei ole enam lubatud seansis osaleda.

      Kui jätate reegli määramata, kasutatakse seade „MultiProfileUserBehaviorMustBePrimary” vaikeväärtust ettevõtte hallatud kasutajate puhul ja seadet „MultiProfileUserBehaviorUnrestricted” haldamata kasutajate puhul.</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="5761030451068906335">Seadistab rakenduse <ph name="PRODUCT_NAME"/> puhverserveri seaded. See reegel ei ole veel valmis, seetõttu ärge kasutage seda.</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="5085647276663819155">Printimise eelvaate keelamine</translation>
<translation id="8672321184841719703">Automaatse värskendamise sihtversioon</translation>
<translation id="553658564206262718">Seadistage toitehalduse seaded kasutaja tegevusetuse korral.

          See reegel juhib mitut seadet, mis reguleerivad toitehalduse strateegiat kasutaja tegevusetuse ajal.

          Võimalik on rakendada nelja tüüpi toiminguid.
          * Ekraan muutub tumedaks, kui kasutaja on tegevusetu aja jooksul, mis on määratud üksusega |ScreenDim|.
          * Ekraan lülitatakse välja, kui kasutaja on tegevusetu aja jooksul, mis on määratud üksusega |ScreenOff|.
          * Kui kasutaja on tegevusetu aja jooksul, mis on määratud üksusega |IdleWarning|, siis kuvatakse hoiatusdialoog, mis ütleb kasutajale, et peagi rakendub tegevusetu oleku toiming.
          * Kui kasutaja on tegevusetu üksusega |Idle| määratud aja jooksul, rakendub toiming |IdleAction|.

          Iga ülalnimetatud toimingu puhul tuleb viivitus määrata millisekunditega ja vastava toimingu rakendamiseks peab aja väärtus peab olema suurem kui null. Kui viivituse väärtus on null, siis <ph name="PRODUCT_OS_NAME"/> vastavat toimingut ei rakenda.

          Kui mõne ülaltoodud viivituse puhul pole aega määratud, siis kasutatakse vaikeväärtust.

          Pange tähele, et üksuse |ScreenDim| väärtusi piiratakse nii, et need oleksid väiksemad või võrdväärsed üksusega |ScreenOff|, üksuseid |ScreenOff| ja |IdleWarning| piiratakse nii, et need oleksid väiksemad või võrdväärsed üksusega |Idle|.

          |IdleAction| võib olla üks neljast võimalikust toimingust.
          * |Suspend|
          * |Logout|
          * |Shutdown|
          * |DoNothing|

          Kui üksust |IdleAction| pole määratud, rakendub vaiketoiming, milleks on peatamine.

          Vahelduvvoolu- ja akutoite jaoks on saadaval ka eraldi seaded.
          </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="7593523670408385997">Seadistab vahemälu mahu, mida <ph name="PRODUCT_NAME"/> kasutab vahemällu salvestatud failide kettale salvestamiseks.

      Kui kasutate seda reeglit, kasutab <ph name="PRODUCT_NAME"/> olemasolevat vahemälu mahtu sellest olenemata, kas kasutaja on määranud märgendi „--ketta-vahemälu-maht” või mitte. Selle reegliga määratud väärtus pole kindel limiit, vaid pigem soovitus vahemälusüsteemile. Mõnest megabaidist väiksem väärtus on liiga väike ja see ümardatakse mõistliku miinimumini.

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

      Kui reeglit pole määratud, siis kasutatakse vaikemahtu ja kasutaja saab selle alistada märgendiga --ketta-vahemälu-maht.</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="4721232045439708965">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="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="5697306356229823047">Seadme kasutajatest teavitamine</translation>
<translation id="8649763579836720255">Chrome OS-i seadmed saavad kasutada kaugatesteerimist (kinnitatud juurdepääs), et saada Chrome OS CA välja antav sertifikaat, mis kinnitab seadme sobilikkust kaitstud sisu esitamiseks.  Protsess hõlmab riistvara kinnitusteabe saatmist Chrome OS CA-le seadme kordumatuks tuvastamiseks.

          Kui seade väärtuseks on Vale, ei kasuta seade sisu kaitsmiseks kaugatesteerimist ja seade ei pruugi saada kaitstud sisu esitada.

          Kui seade väärtuseks on Tõene või see pole määratud, võidakse sisu kaitsmiseks kasutada kaugatesteerimist.</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="5461308170340925511">Konfigureerib laiendusega seotud eeskirjad. Kasutaja ei tohi installida mustas nimekirjas olevaid laiendusi, välja arvatud juhul, kui need on lubatud loendisse lisatud. Saate jõustada eeskirju <ph name="PRODUCT_NAME"/> automaatselt laiendusi installima, määrates need teenuses <ph name="EXTENSIONINSTALLFORCELIST_POLICY_NAME"/>. Jõustamisega installitud laiendused installitakse olenemata sellest, kas need on mustas nimekirjas või mitte.</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="8501011084242226370">Määrab pistikprogrammide loendi, mille kasutaja saab rakenduses <ph name="PRODUCT_NAME"/> lubada või keelata.

      Juhuslike märkide jadade vastendamiseks võib kasutada metamärke „*” ja „?”. „*” vastab mis tahes märkide arvule, „?” vastab ühele valikulisele tähemärgile, st nullile või ühele tähemärgile. Paomärk on „\”. See tähendab, et tegelike märkide „*”, „?” või „\” vastendamiseks võite nende ette lisada märgi „\”.

      Kui lubate sätte, tohib määratud pistikprogrammide loendit rakenduses <ph name="PRODUCT_NAME"/> kasutada. Kasutajad saavad neid jaotises „about:plugins” lubada ja keelata isegi juhul, kui pistikprogramm vastab atribuudis DisabledPlugins olevale mustrile. Kasutajad saavad ka lubada ja keelata pistikprogramme, mis ei vasta ühelegi mustrile atribuutides DisabledPlugins, DisabledPluginsExceptions ja EnabledPlugins.

      Reegli eesmärk on lubada pistikprogrammide ranget keelatud loendisse määramist ja loend „DisabledPlugins” sisaldab metamärkidega kirjeid, näiteks kõikide pistikprogrammide keelamine „*” või kõikide Java pistikprogrammide keelamine „*Java*”, kuid administraator soovib lubada kindla versiooni, näiteks „IcedTea Java 2.3”. Reegel võimaldab määrata konkreetsed versioonid.

      Pange tähele, et keelatud loendist tuleb välistada nii pistikprogrammi nimi kui ka pistikprogrammi grupi nimi. Iga pistikprogrammi grupp kuvatakse lehel about:plugins eraldi jaotises ja igas jaotises võib olla üks või mitu pistikprogrammi. Näiteks pistikprogramm „Shockwave Flash” kuulub gruppi „Adobe Flash Player” ja mõlemal nimel peab olema erandite loendis vaste, kui soovite pistikprogrammi keelatud loendist välistada.

      Kui jätate reegli määramata, keelatakse kõik pistikprogrammid, mis vastavad atribuudis „DisabledPlugins” olevatele mustritele ja kasutaja ei saa neid lubada.</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 kuvamine</translation>
<translation id="1727394138581151779">Blokeeri kõik pistikprogrammid</translation>
<translation id="8118665053362250806">Määra meediaketta vahemälu maht</translation>
<translation id="6565312346072273043">Määrake sisselogimiskuval oleva ekraanil kuvatava klaviatuuri vaikeolek.

          Kui reegel seatakse väärtusele Tõene, lubatakse ekraanil kuvatav klaviatuur sisselogimiskuval.

          Kui reegel seatakse väärtusele Väär, keelatakse ekraanil kuvatav klaviatuur sisselogimiskuval.

          Kui määrate reegli, saavad kasutajad selle ajutiselt alistada, lubades või keelates ekraanil kuvatava klaviatuuri. Kasutaja valik ei ole jääv ja vaikeseade taastatakse iga kord, kui sisselogimiskuva uuesti ilmub või kasutaja on sisselogimiskuval minut aega tegevusetu.

          Kui jätate reegli määramata, keelatakse ekraanil kuvatav klaviatuur sisselogimiskuva esmakordsel ilmumisel. Kasutajad saavad ekraanil kuvatava klaviatuuri igal ajal lubada või keelata ja selle olek sisselogimiskuval on kõikide kasutajate jaoks jääv.</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="7295019613773647480">Luba valvatavad kasutajad</translation>
<translation id="2759224876420453487">Kasutaja käitumise kontrollimine multiprofiili seansis</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="2006530844219044261">Toitehaldus</translation>
<translation id="1221359380862872747">Laadi määratud URL-id demosse sisselogimisel</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="1152117524387175066">Saadab teavet seadme arendaja lüliti oleku kohta käivitamisel.

      Kui määrate reegli olekule Väär, siis ei saadeta teavet arendaja lüliti oleku kohta.</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="1709037111685927635">Taustapildi kujutise seadistamine.

      Selle reegliga saate seadistada, milline taustapildi kujutis kuvatakse kasutaja töölaual ja sisselogimisekraani taustal. Reegli määramiseks tuleb täpsustada URL-i, kust <ph name="PRODUCT_OS_NAME"/> saab taustapildi kujutise alla laadida, ja krüptograafilist räsi, mida kasutatakse allalaadimise terviklikkuse kinnitamiseks. Kujutis peab olema JPEG-vormingus ja selle suurus ei tohi ületada 16 MB. URL-ile peab olema juurdepääs ilma autentimata.

      Taustapildi kujutis laaditakse alla ja salvestatakse vahemällu. See laaditakse uuesti alla iga kord, kui URL või räsi muutub.

      Reegel tuleb määrata stringina, mis väljendab URL-i ja räsi JSON-vormingus ning järgib järgmist skeemi:
      {
        &quot;type&quot;: &quot;object&quot;,
        &quot;properties&quot;: {
          &quot;url&quot;: {
            &quot;description&quot;: &quot;URL, kust saab taustapildi kujutise alla laadida.&quot;,
            &quot;type&quot;: &quot;string&quot;
          },
          &quot;hash&quot;: {
            &quot;description&quot;: &quot;Taustapildi kujutise SHA-256 räsi.&quot;,
            &quot;type&quot;: &quot;string&quot;
          }
        }
      }

      Kui see reegel on määratud, laadib <ph name="PRODUCT_OS_NAME"/> taustapildi kujutise alla ja kasutab seda.

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

      Kui reeglit ei määrata, saab kasutaja ise valida, milline kujutis töölaual ja sisselogimisekraani taustal kuvatakse.</translation>
<translation id="2761483219396643566">Tegevusetuse hoiatuse viivitus akutoite kasutamisel</translation>
<translation id="6281043242780654992">Omasõnumside reeglite seadistamine. Musta nimekirja lisatud omasõnumside hostid on keelatud seni, kuni need lisatakse lubatud üksuste nimekirja.</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="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="1608755754295374538">URL-id, millele antakse ilma küsimata juurdepääs helijäädvustusseadmetele</translation>
<translation id="3547954654003013442">Puhverserveri seaded</translation>
<translation id="5921713479449475707">Automaatsete allalaadimiste lubamine HTTP kaudu</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="2518231489509538392">Heli esitamise lubamine</translation>
<translation id="8146727383888924340">Lubage kasutajatel pakkumisi lunastada Chrome OS-i registreerimise kaudu</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="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="346731943813722404">Määrab, kas toitehalduse viivituste ja seansi pikkuse limiidi aktiveerimine peaks toimuma pärast seda, kui seansi ajal on toimunud esmane kasutajatoiming.

          Kui reegel on määratud olekule Tõene, siis ei toimu toitehalduse viivituste ja seansi pikkuse limiidi aktiveerimine enne, kui seansi ajal on toimunud esimene kasutajatoiming.

          Kui see reegel on määratud olekule Väär või seda pole määratud, siis toimub toitehalduse viivituste ja seansi pikkuse limiidi aktiveerimine kohe, kui seanss algab.</translation>
<translation id="4600786265870346112">Suure kursori lubamine</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="1103860406762205913">Lubab vaba veebipõhist sisselogimist</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="9112897538922695510">Lubab teil registreerida protokollitöötlejate loendi. See saab olla ainult soovitatud reegel. Atribuut |protocol| tuleb määrata skeemile (nagu „mailto”) ja atribuut |url| tuleb määrata skeemi käsitleva rakenduse URL-i mustrile. Muster võib sisaldada märgendit „%s”, mis asendatakse sellisel juhul käsitletava URL-iga.

          Reegliga registreeritud protokollitöötlejad liidetakse kasutaja registreeritud töötlejatega ja mõlemad on kasutamiseks saadaval. Kasutajad saavad alistada reegliga installitud protokollitöötlejad, kui installivad uue vaiketöötleja, kuid nad ei saa eemaldada reegliga registreeritud protokollitöötlejat.</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="527237119693897329">Lubab määrata, milliseid omasõnumside hoste ei tule laadida.

          Musta nimekirja väärtus '*' tähendab, et kõik omasõnumside hostid on mustas nimekirjas, kui nad pole lisatud konkreetselt lubatud üksuste loendisse.

          Kui seda reeglit ei määrata, laadib <ph name="PRODUCT_NAME"/> kõik installitud omasõnumside hostid.</translation>
<translation id="749556411189861380">Saadab registreeritud seadmete OS-i ja püsivara versiooni.

      Kui te seda seadet ei määra või määrate olekule Tõene, saadavad registreeritud seadmed regulaarselt teavet OS-i ja püsivara versiooni kohta. Kui määrate seade olekule Väär, siis versiooniteavet ei saadeta.</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="2571066091915960923">Lubab või keelab andmete tihendamise puhverserveri ja takistab kasutajatel seadet muuta.

      Selle seade lubamisel või keelamisel ei saa kasutajad seadet muuta ega üle kirjutada.

      Kui reegel pole määratud, on andmete tihendamise puhverserver kasutajatele saadaval ja nad saavad valida, kas kasutavad seda või mitte.</translation>
<translation id="2170233653554726857">WPAD-optimeerimise lubamine</translation>
<translation id="7424751532654212117">Keelatud pistikprogrammide loendi erandite loend</translation>
<translation id="6233173491898450179">Määra allalaadimiskataloog</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="4429220551923452215">Lubab või keelab rakenduste otsetee järjehoidjaribal.

      Kui te seda reeglit ei määra, saab kasutaja rakenduste otsetee järjehoidjariba kontekstimenüüs kuvada või peita.

      Kui selle reegli konfigureerite, ei saa kasutaja seda muuta ja rakenduste otsetee on alati kuvatud või seda ei kuvata kunagi.</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="2521581787935130926">Kuva rakenduste otsetee järjehoidjaribal</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="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="1330145147221172764">Luba ekraanil kuvatav klaviatuur</translation>
<translation id="7006788746334555276">Sisu seaded</translation>
<translation id="450537894712826981">Seadistab vahemälu mahu, mida <ph name="PRODUCT_NAME"/> kasutab vahemällu salvestatud meediafailide kettale salvestamiseks.

     Kui kasutate seda reeglit, kasutab <ph name="PRODUCT_NAME"/> olemasolevat vahemälu mahtu sellest olenemata, kas kasutaja on määranud märgendi „--meedia-vahemälu-maht” või mitte. Selle reegliga määratud väärtus pole kindel limiit, vaid pigem soovitus vahemälusüsteemile. Mõnest megabaidist väiksem väärtus on liiga väike ja see ümardatakse mõistliku miinimumini.

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

      Kui reeglit pole määratud, siis kasutatakse vaikemahtu ja kasutaja saab selle alistada märgendiga --meedia-vahemälu-maht.</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="5893553533827140852">Kui see seade on lubatud, siis edastatakse gnubby autentimistaotlused puhverserverisse kaughosti ühenduse abil.

          Kui see seade on keelatud või seadistamata, siis ei edastata gnubby autentimistaotlusi puhverserveri abil.</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="1062011392452772310">Seadme kaugatesteerimise lubamine</translation>
<translation id="7774768074957326919">Kasuta süsteemi puhverserveri seadeid</translation>
<translation id="3891357445869647828">Luba JavaScript</translation>
<translation id="2274864612594831715">See reegel seadistab virtuaalse klaviatuuri sisendseadmena lubamise Chrome OS-is. Kasutajad ei saa seda reeglit alistada.

      Kui reegel on määratud väärtusele Tõene, on ekraanil kuvatav virtuaalne klaviatuur alati lubatud.

      Kui reegel on määratud väärtusele Väär, on ekraanil kuvatav virtuaalne klaviatuur alati keelatud.

      Kui määrate selle reegli, ei saa kasutajad seda muuta ega alistada. Kuid kasutajad saavad ikka lubada/keelata juurdepääsetavuse ekraanil kuvatava klaviatuuri, millel on eesõigus võrreldes virtuaalse klaviatuuriga, mida juhib see reegel.

      Kui reeglit ei määrata, siis on ekraanil kuvatav klaviatuur esialgu keelatud, kuid kasutaja saab selle igal ajal lubada. Klaviatuuri kuvamiseks võidakse kasutada ka heuristilisi reegleid.</translation>
<translation id="6774533686631353488">Kasutaja tasemel omasõnumside hostide (installitud administraatori loata) lubamine.</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="7234280155140786597">Keelatud omasõnumside hostide nimed (või väärtus * kõikide keelamiseks)</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="3460784402832014830">Määrab URL-i, mida otsingumootor kasutab uue vahelehe loomiseks.

          See reegel on valikuline. Kui seda pole määratud, siis ei looda ühtegi uut vahelehte.

          Reeglit arvestatakse ainult juhul, kui on lubatud reegel „DefaultSearchProviderEnabled”.</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="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="4816674326202173458">Luba ettevõtte kasutajal olla nii peamine kui ka teisene kasutaja (vaikekäitumine haldamata kasutajate puhul)</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="7384902298286534237">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud seansipõhiseid küpsiseid salvestada.

          Kui jätate reegli määramata, kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultCookiesSetting” (kui see on määratud) või kasutaja isiklikust konfiguratsioonist.

          Kui eelmise seansi URL-ide taastamiseks on määratud reegel „RestoreOnStartup”, ei rakendu see reegel ja nende saitide küpsised talletatakse jäädavalt.</translation>
<translation id="2098658257603918882">Luba kasutus- ja krahhiandmete aruandlus</translation>
<translation id="4633786464238689684">Asendab klaviatuuri ülemise rea klahvide vaiketoimingud funktsiooniklahvide toimingutega.

          Kui reegel on määratud valikule Tõene, toimivad klaviatuuri ülemise rea klahvid vaikimisi funktsiooniklahvidena. Nende meediaklahvidena kasutamiseks tuleb vajutada otsinguklahvi.

          Kui see reegel on määratud valikule Väär või pole see määratud, siis toimivad klahvid vaikimisi meediaklahvidena. Funktsiooniklahvidena toimivad need siis, kui samal ajal vajutatakse otsinguklahvi.</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="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="4224610387358583899">Ekraaniluku viivitused</translation>
<translation id="5388730678841939057">Valib automaatse puhastamise ajal kettaruumi vabastamiseks strateegia (pakkumine on peatatud)</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="197143349065136573">Lubab vana veebipõhise sisselogimisvoo.

      See seade on kasulik ettevõtte klientidele, kes kasutavad SSO lahendusi, mis ei ühildu veel uue tekstisisese sisselogimisvooga.
      Kui lubate selle seade, kasutatakse vana veebipõhist sisselogimisvoogu.
      Kui keelate selle seade või jätate selle määramata, kasutatakse vaikimisi uut tekstisisest sisselogimisvoogu. Kasutajad võivad endiselt lubada vana veebipõhist sisselogimisvoogu käsurea markeeringu kaudu – veebipõhise sisselogimise lubamine.

      Katseline seade eemaldatakse tulevikus, kui tekstisisene sisselogimine kõiki SSO sisselogimisvooge täielikult toetab.</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="4001275826058808087">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="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="4604931264910482931">Omasõnumside musta nimekirja seadistamine</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="2623014935069176671">Kasutaja esmase tegevuse ootamine</translation>
<translation id="2660846099862559570">Ära kunagi kasuta puhverserverit</translation>
<translation id="637934607141010488">Saadab loendi seadme kasutajatest, kes on hiljuti sisse loginud.

      Kui määrate reegli olekule Väär, siis kasutajatest ei teavitata.</translation>
<translation id="1956493342242507974">Toitehalduse seadistamine sisselogimisekraanil operatsioonisüsteemis <ph name="PRODUCT_OS_NAME"/>.

      Selle reegliga saate seadistada, kuidas <ph name="PRODUCT_OS_NAME"/> käitub, kui kuvatakse sisselogimisekraan ja kasutaja ei tee teatud aja jooksul ühtegi toimingut. See reegel juhib mitut seadet. Individuaalset semantikat ja väärtusevahemikke vaadake vastavatest seansi toitehaldust juhtivatest reeglitest. Ainsad kõrvalekalded nendest reeglitest on järgmised.
      * Tegevusetuse või kaane sulgemise korral ei tohi toiminguks olla seansi lõpetamine.
      * Kui seade töötab vahelduvvoolutoitel, siis on tegevusetuse korral vaiketoiminguks väljalülitamine.

      Kui seadet ei määrata, siis kasutatakse vaikeväärtust.

      Kui seda reeglit ei määrata, siis kasutatakse kõikide seadete jaoks vaikevalikuid.</translation>
<translation id="1435659902881071157">Seadme tasemel võrgukonfigureerimine</translation>
<translation id="8071636581296916773">Lubab releeserverite kasutamise, kui kaugkliendid proovivad luua ühenduse selle seadmega.

          Seade lubamisel saavad kaugkliendid kasutada releeservereid seadmega ühenduse loomiseks siis, kui otseühendus pole saadaval (nt tulemüüri piirangute tõttu).


          Pange tähele, et kui reegel <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/> on keelatud, siis seda reeglit ignoreeritakse.


          Kui jätate selle reegli määramata, siis seade lubatakse.</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="102492767056134033">Sisselogimiskuval kuvatava klaviatuuri vaikeoleku määramine</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="6757375960964186754">Rakenduse <ph name="PRODUCT_OS_NAME"/> hõlbustusvalikute kuvamine süsteemimenüüs.

          Kui reegel seatakse väärtusele Tõene, kuvatakse süsteemisalve menüüs alati hõlbustusvalikud.

          Kui reegel seatakse väärtusele Väär, ei kuvata süsteemisalve menüüs kunagi hõlbustusvalikuid.

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

          Kui jätate reegli määramata, ei kuvata süsteemisalve menüüs hõlbustusvalikuid, kuid kasutaja võib lehel Seaded lubada hõlbustussuvandite kuvamise.</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="8549772397068118889">Hoiatamine sisupakettidest väljaspool olevate saitide külastamisel</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="6698424063018171973">Piirab UDP-portide vahemikku, mida kaugjuurdepääsuhost selles seadmes kasutab.

          Kui see reegel on määramata või selleks määratakse tühi string, siis saab kaugjuurdepääsuhost kasutada iga saadaolevat porti, kui just reegel <ph name="REMOTEACCESSHOSTFIREWALLTRAVERSAL_POLICY_NAME"/> pole keelatud. Sellisel juhul kasutab kaugjuurdepääsuhost UDP-porte vahemikus 12400–12409.</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="2808013382476173118">Lubab STUN-serverite 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 seade klientseadmetest tulevaid ühendusi vaid kohalikus võrgus.

          Kui jätate selle reegli määramata, siis seade lubatakse.</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="2811293057593285123">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 seadistamata, saavad kasutajad pärast hoiatuse kuvamist teha valiku edasiminekuks märgistatud saidile.</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>
<translation id="3806576699227917885">Heli esitamise lubamine.

      Kui reegel seatakse väärtusele Väär, 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 seade seatakse väärtusele Tõene või jäetakse seadistamata, saavad kasutajad kasutada kõiki oma seadmes toetatud heliväljundeid.</translation>
<translation id="6517678361166251908">Gnubby autentimise lubamine</translation>
<translation id="4858735034935305895">Täisekraanrežiimi lubamine</translation>
</translationbundle>