<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="et">
<translation id="101438888985615157">Ekraani pööramine 180 kraadi</translation>
<translation id="1016912092715201525">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.

      Märkus operatsioonisüsteemi <ph name="MS_WIN_NAME" /> administraatoritele. Selle seade lubamine toimib ainult seadmetes, kus töötab Windows 7. Alates operatsioonisüsteemist Windows 8 tuleb teil juurutada rakenduste vaikeseoste fail, mis määrab rakenduse <ph name="PRODUCT_NAME" /> protokollide <ph name="HHTPS_PROTOCOL" /> ja <ph name="HTTP_PROTOCOL" /> töötlejaks (ning vajaduse korral ka protokolli <ph name="FTP_PROTOCOL" /> ja failivormingute, nt <ph name="HTML_EXTENSION" />, <ph name="HTM_EXTENSION" />, <ph name="PDF_EXTENSION" />, <ph name="SVG_EXTENSION" />, <ph name="WEBP_EXTENSION" /> jms töötlejaks). Vaadake lisateavet aadressilt <ph name="SUPPORT_URL" />.</translation>
<translation id="1017967144265860778">Toitehaldus sisselogimiskuval</translation>
<translation id="1019101089073227242">Kasutaja andmete kataloogi määramine</translation>
<translation id="1022361784792428773">Laienduste ID-d, mida kasutajatel ei ole lubatud installida (märk * keelab kõik)</translation>
<translation id="102492767056134033">Sisselogimiskuval kuvatava klaviatuuri vaikeoleku määramine</translation>
<translation id="1027000705181149370">Määrab, kas autentimiseks kasutatavad küpsisefailid, mille SAML-i IdP sisselogimisel määrab, kantakse üle kasutajaprofiilile.

      Kui kasutaja autendib sisselogimisel SAML-i IdP kaudu, kirjutatakse IdP määratud küpsisefailid esmalt ajutisele profiilile. Need küpsisefailid saab autentimisoleku edastamiseks kasutajaprofiilile üle kanda.

      Kui reegel on määratud olekule Tõene, kantakse IdP seadistatud küpsisefailid kasutajaprofiilile üle iga kord, kui ta sisselogimisel SAML IdP vastu autendib.

      Kui reegel on määramata või määratud olekule Väär, kantakse IdP määratud küpsisefailid kasutajaprofiilile üle ainult tema esimesel sisselogimisel seadmesse.

      Reegel mõjutab ainult kasutajaid, kelle domeen kattub seadme registreerimisel kasutatava domeeniga. Kõigi muude kasutajate puhul kantakse IdP määratud küpsisefailid kasutajaprofiilile üle ainult tema esimesel sisselogimisel seadmesse.</translation>
<translation id="1035385378988781231">Reegel määrab, kas teenuse <ph name="PRODUCT_NAME" /> funktsioon Network File Shares kasutab autentimiseks NTLM-i.

      Kui reegel on seatud väärtusele Tõene, kasutatakse SMB ühiskasutuse autentimiseks NTLM-i.
      Kui reegel on seatud väärtusele Väär, on SMB ühiskasutuse puhul NTLM-i autentimine keelatud.

      Kui reegel on määramata, on see ettevõtte hallatavate kasutajate jaoks vaikimisi keelatud ja haldamata kasutajate jaoks vaikimisi lubatud.</translation>
<translation id="1040446814317236570">Luba PAC URL-i eemaldamine (https:// puhul)</translation>
<translation id="1044878202534415707">Saatke aruandeid riistvara statistika kohta (nt protsessori/RAM-i kasutus).

      Kui reegli väärtuseks on määratud Väär, siis statistikat ei saadeta.
      Kui väärtuseks on määratud Tõene või seda ei määrata, saadetakse statistikat.</translation>
<translation id="1046484220783400299">Iganenud veebiplatvormi funktsioonide lubamine piiratud ajaks</translation>
<translation id="1047128214168693844">Keela kõigil saitidel kasutajate füüsilise asukoha jälgimine</translation>
<translation id="1049138910114524876">Seadistab lokaadi, mis jõustatakse operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> sisselogimisekraanil.

      Kui see reegel on määratud, kuvatakse sisselogimisekraan alati lokaadis, mis selle reegli esimese väärtusega määratakse (reegel on määratud suunamise ühilduvuse loendina). Kui seda reeglit pole määratud või see on tühi loend, kuvatakse sisselogimisekraan kasutaja viimase seansi lokaadis. Kui sellele reeglile on määratud väärtus, mis ei ole kehtiv lokaat, kuvatakse sisselogimisekraan varulokaadis (praegu en-US).</translation>
<translation id="1062011392452772310">Seadme kaugatesteerimise lubamine</translation>
<translation id="1062407476771304334">Asenda</translation>
<translation id="1079801999187584280">Arendaja tööriistade kasutamise keelamine</translation>
<translation id="1093082332347834239">Kui seade on lubatud, käitatakse protsessis kaugabi hosti lubadega <ph name="UIACCESS_PERMISSION_NAME" />. See võimaldab kaugkasutajatel suhelda kohaliku kasutaja töölaual olevate administraatoriõigusi nõudvate akendega.

          Kui seade on keelatud või seadistamata, käitatakse kaugabi hosti kasutaja kontekstis ja kaugkasutajad ei saa töölaual suhelda administraatoriõigusi nõudvate akendega.</translation>
<translation id="1096105751829466145">Vaikeotsingupakkuja</translation>
<translation id="1099282607296956954">Saidi isoleerimise lubamine igal saidil</translation>
<translation id="1100570158310952027">
      Reegel määrab loendi lähtekohtadest (URL-id) või hostinimemustritest (nt
      „*.example.com”), mille puhul ei kehti ebaturvaliste lähtekohtade
      turvapiirangud.

      Selle eesmärk on võimaldada organisatsioonidel seadistada lubatud 
      lähtekohad pärandrakenduste jaoks, kus ei saa TLS-i juurutada, või
      seadistada kontrollserver sisemise veebiarenduse jaoks,
      mis võimaldab arendajatel testida turvakontekste nõudvaid funktsioone,
      ilma et kontrollserveris oleks vaja juurutada TLS-i.
      Reegel takistab ka omnikastikeses päritolule märke
      „Ebaturvaline” lisamist.

      Reeglis URL-ide loendi määramisel on sama mõju mis käsurea märgistuse

      „--unsafely-treat-insecure-origin-as-secure” lisamisel samade URL-ide
      komaeraldusega loendile. Kui reegel on määratud, alistab see
      käsurea märgistuse.

      Reegel alistab reegli UnsafelyTreatInsecureOriginAsSecure, kui see on määratud.

      Vaadake lisateavet turvaliste kontekstide kohta aadressilt
      https://www.w3.org/TR/secure-contexts/.
      </translation>
<translation id="1117535567637097036">Selle reegliga määratud protokollitöötlejaid Androidi kavatsuste käsitlemisel ei kasutata.</translation>
<translation id="1118093128235245168">Luba saitidel küsida kasutajalt luba ühendatud USB-seadmetele juurdepääsemisks</translation>
<translation id="1128903365609589950">Seadistab kataloogi, mida <ph name="PRODUCT_NAME" /> kasutab vahemälus olevate failide kettale salvestamiseks.

      Kui määrate reegli, kasutab <ph name="PRODUCT_NAME" /> sisestatud kataloogi sellest olenemata, kas kasutaja on määranud märgistuse „--disk-cache-dir”. Andmete kaotsimineku ja muude ootamatute vigade vältimiseks ei tohi reegli jaoks valida ketta juurkataloogi ega muudel eesmärkidel kasutatavat kataloogi, kuna <ph name="PRODUCT_NAME" /> haldab selle kataloogi sisu.

      Vaadake kasutamiseks saadaolevate muutujate loendit aadressilt https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Kui jätate reegli määramata, kasutatakse vahemälu vaikekataloogi ja kasutaja saab selle alistada käsurea märgistusega „--disk-cache-dir”.</translation>
<translation id="1135264353752122851">Seadistab, millised klaviatuuripaigutused on operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> kasutajaseansside jaoks lubatud.

      Kui see reegel on määratud, saab kasutaja valida ainult ühe selle reegliga määratud sisestusmeetodi. Kui reegel on määramata või seadistatud on tühi loend, saab kasutaja valida kõik toetatud sisestusmeetodid. Kui selle reegliga on praegune sisestusmeetod keelatud, lülitatakse sisestusmeetod riistvara klaviatuuripaigutusele (kui see on lubatud) või esimesele loendis olevale kehtivale väärtusele. Kõiki selles loendis olevaid kehtetuid või toetamata sisestusmeetodeid eiratakse.</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="1151353063931113432">Luba kujutised nendel saitidel</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="1160479894929412407">QUIC-protokolli lubamine</translation>
<translation id="1160939557934457296">Keela turvalise sirvimise hoiatuslehest edasiliikumine</translation>
<translation id="1189817621108632689">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel ei ole lubatud pilte 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 seadistust.

          Pange tähele, et reegel oli seni Androidis ekslikult lubatud, ent seda funktsiooni ei ole Androidis kunagi täielikult toetatud.</translation>
<translation id="1198465924256827162">Seadme oleku üleslaadimiste saatmise sagedus millisekundites.

      Kui see reegel on määramata, on vaikesagedus 3 tundi. Minimaalne
      lubatud sagedus on 60 sekundit.</translation>
<translation id="1204263402976895730">Ettevõtte lubatud printerid</translation>
<translation id="1219695476179627719">Määrab, kas seade peaks tagasi minema reegliga <ph name="DEVICE_TARGET_VERSION_PREFIX_POLICY_NAME" /> määratud versioonile, kui see käitab juba hilisemat versiooni.

      Vaikereegel on RollbackDisabled.</translation>
<translation id="1221359380862872747">Laadi määratud URL-id demosse sisselogimisel</translation>
<translation id="1223789468190631420">Ohutu sirvimise lubamise olek usaldusväärsete allikate puhul</translation>
<translation id="122899932962115297">Lubatute loend, mis juhib seda, milliseid kiiravamisrežiime kasutaja saab lukustuskuva avamiseks seadistada ja kasutada.

          See väärtus on stringide loend; kehtivad loendikanded on „all”, „PIN”, „FINGERPRINT”. Kui lisate loendisse stringi „all", tähendab see, et kasutajale on saadaval kõik kiiravamisrežiimid (sh need, mis rakendatakse tulevikus). Muul juhul on saadaval ainult loendis olevad kiiravamisrežiimid.

          Kui soovite lubada näiteks kõik kiiravamisrežiimid, kasutage stringi ["all"]. Kui soovite lubada ainult PIN-koodiga avamise, kasutage stringi ["PIN", "FINGERPRINT"]. Kõikide kiiravamisrežiimide keelamiseks kasutage stringi [].

          Vaikimisi pole hallatud seadmetes saadaval ühtegi kiiravamisrežiimi.</translation>
<translation id="123081309365616809">Sisu ülekandmise lubamine seadmesse</translation>
<translation id="1243570869342663665">Teenuse SafeSites täiskasvanutele mõeldud sisu filtreerimise haldamine.</translation>
<translation id="1257550411839719984">Allalaadimise vaikekataloogi määramine</translation>
<translation id="1265053460044691532">Piirake aega, mille jooksul SAML-i kaudu autenditud kasutaja saab võrguühenduseta sisse logida</translation>
<translation id="1291880496936992484">Hoiatus. RC4 eemaldatakse teenusest <ph name="PRODUCT_NAME" /> pärast versiooni 52 täielikult (umbes septembris 2016) ja sellest hetkest see reegel enam ei tööta.

      Kui reegel on määramata või selle väärtuseks on määratud Väär, siis ei ole RC4 šifreerimiskomplektid TLS-is lubatud. Selle väärtuseks võib olla määratud ka Tõene, et säilitada ühilduvus aegunud serveriga. See on ajutine meede ja server tuleks ümber seadistada.</translation>
<translation id="1297182715641689552">Kasuta puhverserveri pac-skripti</translation>
<translation id="1304973015437969093">Taustal installitavate laienduste/rakenduste ID-d ja värskenduste URL-id</translation>
<translation id="1307454923744766368">Lähtekohad või hostinimede mustrid, mille puhul ei kehti
      ebaturvaliste lähtekohtade piirangud</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="131353325527891113">Kuva kasutajanimed sisselogimiskuval</translation>
<translation id="1327466551276625742">Võrguseadistuse viiba lubamine, kui seade on võrguühenduseta</translation>
<translation id="1330145147221172764">Luba ekraanil kuvatav klaviatuur</translation>
<translation id="13356285923490863">Reegli nimi</translation>
<translation id="1352174694615491349">See reegel lubab HTTP/2 ühenduse liitmise, kui kliendisertifikaadid on kasutuses. Liitmiseks peab nii potentsiaalse uue ühenduse hostinimi kui ka olemasoleva ühenduse hostinimi kattuma vähemalt ühe reeglis kirjeldatud mustriga. Reegel on hostide loend, mis põhineb filtri URLBlacklist vormingul: „example.com” vastendab domeeni „example.com” ja kõik alamdomeenid (nt „sub.example.com”), samas kui „.example.net” vastendab ainult domeeni „example.net”.

      Kliendisertifikaate kasutatavatele eri hostidele edastatavad liitmistaotlused võivad põhjustada turva- ja privaatsusprobleeme, kuna üldine sertifitseerimisorgan edastatakse kõigile taotlustele, isegi kui kasutaja seda ei volitanud. Reegel on ajutine ja see eemaldatakse tulevases versioonis. Vt https://crbug.com/855690.

      Kui reegel jäetakse määramata, kasutatakse vaikekäitumist, mille puhul ei lubata HTTP/2 ühenduse liitmist kliendisertifikaatidel põhinevate ühenduste korral.</translation>
<translation id="1353966721814789986">Käivitamisel avatavad lehed</translation>
<translation id="1359553908012294236">Kui selle reegli väärtuseks määratakse Tõene või seda ei seadistata, lubab teenus <ph name="PRODUCT_NAME" /> külaliste sisselogimise. Külaliste sisselogimised on teenuse <ph name="PRODUCT_NAME" /> profiilid, kus kõik aknad on inkognito režiimis.

      Kui selle reegli väärtuseks määratakse Väär, ei luba teenus <ph name="PRODUCT_NAME" /> külaliste profiile käivitada.</translation>
<translation id="1363275621236827384">Lubatakse riistvaraprofiilide päringud Quirks Serverist</translation>
<translation id="1372267489642113556">
      Kui reegel on lubatud, käitab iga komadega eraldatud loendis
      nimetatud lähtekoht oma protsesse. See isoleerib ka alamdomeenide
      nimetatud lähtekohad; nt aadressi https://example.com/ määramisel
      isoleeritakse saidi https://example.com/ osana ka aadress
      https://foo.example.com/.
      Kui reegel on keelatud, ei toimu selget saidi isoleerimist ning reeglite IsolateOrigins ja SitePerProcess testid keelatakse. Kasutajad saavad reegli IsolateOrigins siiski käsitsi lubada.
      Kui reegel on seadistamata, saab kasutaja seda seadet muuta.
      Teenuses <ph name="PRODUCT_OS_NAME" /> on soovitatav seadistada ka seadmereegel <ph name="DEVICE_LOGIN_SCREEN_ISOLATE_ORIGINS_POLICY_NAME" /> samale väärtusele. Kui kahes reeglis määratud väärtused ei ühti, võib kasutajareegliga määratud väärtuse rakendamisel esineda kasutajaseanssi sisenemisel viivitusi.

      MÄRKUS. Androidis see reegel ei kehti. Androidis reegli IsolateOrigins lubamiseks kasutage reegli IsolateOriginsAndroid seadet.
      </translation>
<translation id="1384459581748403878">Viide: <ph name="REFERENCE_URL" /></translation>
<translation id="1387596372902085462">Määrab, kas usaldada Symantec Corporationi PKI pärandtaristut</translation>
<translation id="1393485621820363363">Ettevõtte seadmete jaoks lubatud printerid</translation>
<translation id="1397855852561539316">Vaikeotsingupakkuja soovitatud URL</translation>
<translation id="1413936351612032792">Linuxi rakenduste kasutusteabe saatmine</translation>
<translation id="142346659686073702">Seoseta kasutajatel Crostini kasutamise lubamine</translation>
<translation id="1426410128494586442">Jah</translation>
<translation id="1427655258943162134">Puhverserveri aadress või URL</translation>
<translation id="1435659902881071157">Seadme tasemel võrgukonfigureerimine</translation>
<translation id="1438739959477268107">Võtmete loomise vaikeseade</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="1456822151187621582">Windows (operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> kliendid):</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="1465619815762735808">Klõpsa esitamiseks</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="1468707346106619889">Kui reegel on seatud väärtusele Tõene, on ühendatud töölaud lubatud ja
      vaikimisi sisse lülitatud, mis võimaldab rakendustel hõlmata mitu ekraani.
      Kasutaja võib individuaalsetel ekraanidel ühendatud töölaua keelata, 
      tühjendades valiku ekraaniseadetes.

      Kui reegel on määramata või seatud väärtusele Väär, on ühendatud töölaud
      keelatud. Sel juhul ei saa kasutaja funktsiooni lubada.</translation>
<translation id="1474273443907024088">TLS-i valekäivitamise keelamine</translation>
<translation id="1477934438414550161">TLS 1.2</translation>
<translation id="1484146587843605071">Rakendus <ph name="PRODUCT_NAME" /> möödub siin loetletud hostide puhul kõikidest puhverserveritest.

          Reegel kehtib vaid juhul, kui valisite jaotises „Puhverserveri seadete määramise viisi valimine” 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="1502843533062797703">Kolmanda osapoole tarkvara sisestamise blokeerimise lubamine</translation>
<translation id="1504431521196476721">Kaugatesteerimine</translation>
<translation id="1507957856411744193">Kui reegel on seatud väärtusele Tõene, loob <ph name="PRODUCT_NAME" /> ühenduse Casti seadmetega kõigi IP-aadresside, mitte ainult RFC1918/RFC4193 privaatsete aadresside kaudu.

          Kui reegel on seatud väärtusele Väär, loob <ph name="PRODUCT_NAME" /> ühenduse Casti seadmetega ainult RFC1918/RFC4193 privaatsete aadresside kaudu.

          Kui reegel on määramata, loob <ph name="PRODUCT_NAME" /> ühenduse Casti seadmetega ainult RFC1918/RFC4193 privaatsete aadresside kaudu, v.a juhul, kui funktsioon CastAllowAllIPs on lubatud.

          Kui reegel „EnableMediaRouter” on seatud väärtusele Väär, ei ole selle reegli väärtusel mingit mõju.</translation>
<translation id="1509692106376861764">Reegel on alates rakenduse <ph name="PRODUCT_NAME" /> versioonist 29 kasutusest kõrvaldatud.</translation>
<translation id="1514888685242892912">Teenuse <ph name="PRODUCT_NAME" /> lubamine</translation>
<translation id="1522425503138261032">Luba saitidel kasutaja füüsilist asukohta jälgida</translation>
<translation id="152657506688053119">Asendus-URL-ide loend vaikeotsingupakkujale</translation>
<translation id="1530812829012954197">Renderda hostbrauseris alati järgmiste URL-ide mustrid</translation>
<translation id="1541170838458414064">Prinditava lehe suuruse piiramine</translation>
<translation id="1553684822621013552">Kui see reegel on tõene, lubatakse ARC kasutaja jaoks
      (oleneb reegli seadete lisakontrollidest – ARC pole endiselt
      saadaval, kui efemeerne režiim või mitu sisselogimist on
      praeguses kasutajaseansis lubatud).

      Kui see seade on keelatud või seadistamata, siis ei saa ettevõtte
      kasutajad ARC-d kasutada.</translation>
<translation id="1561424797596341174">Kaugjuurdepääsu hosti silumisjärkude reeglite alistused</translation>
<translation id="1561967320164410511">U2F koos laiendustega individuaalseks atesteerimiseks</translation>
<translation id="1574554504290354326">Selle seade tugi on katkestatud. Kasutage selle asemel seadet SafeBrowsingExtendedReportingEnabled. Seade SafeBrowsingExtendedReportingEnabled lubamine või keelamine on võrdne seade SafeBrowsingExtendedReportingOptInAllowed määramisega väärtusele Väär.

      Kui reegli väärtuseks määratakse Väär, ei saa kasutajad Google'i serveritesse saata teatud süsteemiteavet ega lehe sisu. Kui selle seade väärtuseks määratakse Tõene või see jäetakse seadistamata, saavad kasutajad ohutu sirvimise teenusesse saata teatud süsteemiteavet ja lehe sisu, et aidata tuvastada ohtlikke rakendusi ning saite.

      Vaadake ohutu sirvimise kohta lisateavet aadressilt https://developers.google.com/safe-browsing.</translation>
<translation id="1583248206450240930">Kasuta vaikimisi rakendust <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="1599424828227887013">Android-seadmetes saidi isoleerimise lubamine konkreetsete lähtekohtade puhul</translation>
<translation id="1608755754295374538">URL-id, millele antakse ilma küsimata juurdepääs helijäädvustusseadmetele</translation>
<translation id="1615221548356595305">Nende hostide puhul HTTP/2 ühenduste liitmise lubamine isegi kliendisertifikaatide kasutamisel</translation>
<translation id="1617235075406854669">Brauseri ja allalaadimiste ajaloo kustutamise lubamine</translation>
<translation id="163200210584085447">Selles loendis olevaid mustreid võrreldakse taotleva URL-i
      algse turvalisusega. Vaste leidmisel antakse SAML-i
      sisselogimislehtedele juurdepääs videosalvestusseadmetele. Kui vastet
      ei leita, blokeeritakse juurdepääs automaatselt. Metamärgiga mustreid
      ei lubata.</translation>
<translation id="1634989431648355062">Luba nendel saitidel pistikprogramm <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="1655229863189977773">Määrake ketta vahemälu suurus baitides</translation>
<translation id="166427968280387991">Puhverserver</translation>
<translation id="1668836044817793277">Kas lubada automaatselt käivitatud viivituseta kioskirakendusel juhtida operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> versiooni?

      See reegel juhib seda, kas lubada automaatselt käivitatud viivituseta kioskirakendusel juhtida operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> versiooni, määrates manifesti võtme required_platform_version ja kasutades seda automaatvärskenduse sihtversiooni eesliitena.

      Kui reegel on määratud väärtusele Tõene, siis kasutatakse automaatselt käivitatud viivituseta kioskirakenduse manifesti võtme required_platform_version väärtust automaatvärskenduse sihtversiooni eesliitena.

      Kui reeglit pole seadistatud või see on määratud väärtusele Väär, eiratakse manifesti võtit required_platform_version ja automaatvärskendus toimub tavapäraselt.

      Hoiatus. Operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> versiooni juhtimist ei ole soovitatav üle anda kioskirakendusele, kuna see võib takistada seadmel tarkvaravärskendusi ja kriitilisi turvapaikasid vastu võtmast. Operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> versiooni juhtimise üleandmine võib kasutajad ohtu seada.</translation>
<translation id="1675002386741412210">Toetatud:</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="1708496595873025510">Piirangu määramine variatsioonide lähteväärtuse toomisele</translation>
<translation id="172374442286684480">Luba kõikidel saitidel kohalike andmete määramine</translation>
<translation id="1734716591049455502">Kaugjuurdepääsu valikute seadistamine</translation>
<translation id="1736269219679256369">SSL-i hoiatuslehelt jätkamise lubamine</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="1750315445671978749">Blokeeri kõik allalaadimised</translation>
<translation id="1781356041596378058">See reegel juhib ka juurdepääsu Androidi arendaja valikutele. Kui määrate reegli väärtuseks Tõene, ei pääse kasutajad arendaja valikutele juurde. Kui määrate reegli väärtuseks Väär või jätate selle määramata, pääsevad kasutajad arendaja valikutele juurde, puudutades rakenduses Androidi seaded seitse korda järgunumbrit.</translation>
<translation id="1797233582739332495">Kuva kasutajale korduv viip, mis näitab, et taaskäivitamine on nõutav</translation>
<translation id="1803646570632580723">Kinnitatud rakenduste loend, mida näidatakse käivitis</translation>
<translation id="1808715480127969042">Blokeeri nende saitide küpsised</translation>
<translation id="1810261428246410396">Kiirjagamise kasutamise lubamine.</translation>
<translation id="1827523283178827583">Kasuta fikseeritud puhverservereid</translation>
<translation id="1843117931376765605">Kasutajareegli värskendussagedus</translation>
<translation id="1844620919405873871">Seadistab kiiravamisega seotud reeglid.</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="1852294065645015766">Meedia automaatesituse lubamine</translation>
<translation id="1859859319036806634">Hoiatus. TLS-i versiooni taandeversioon eemaldatakse teenusest <ph name="PRODUCT_NAME" /> pärast versiooni 52 (umbes 2016. aasta septembris), misjärel lakkab see reegel töötamast.

      Kui TLS-i käitlus ebaõnnestub, üritab teenus <ph name="PRODUCT_NAME" /> esmalt uuesti ühendust luua TLS-i vanema versiooniga, et vältida HTTPS-serverites esinevaid vigu. See seade määrab versiooni, mille juures taandeprotsess peatub. Seade ei kehti, kui versiooni läbirääkimine serveris õnnestub (st ühendus ei katke). Sellele vaatamata peab loodav ühendus vastama reeglile SSLVersionMin.

      Kui seda reeglit ei seadistata või see kasutab väärtust „tls1.2”, siis ei taanda teenus <ph name="PRODUCT_NAME" /> enam versiooni. Pange tähele, et see ei keela TLS-i vanemate versioonide tuge, vaid määrab, kas teenus <ph name="PRODUCT_NAME" /> väldib vigadega servereid, milles versioonide läbirääkimine ei õnnestu.

      Kui ühilduvus vigadega serveriga peab säilima, võib valida väärtuse „tls1.1”. See on ajutine abinõu ja server tuleb kiiresti parandada.</translation>
<translation id="1864269674877167562">Kui selle reegli jaoks valitakse tühi string või jäetakse reegel seadistamata, ei näita <ph name="PRODUCT_OS_NAME" /> kasutaja sisselogimisvoos automaatse täitmise valikut.
      Kui selleks reegliks on määratud string, mis esindab domeeni nime, kuvab <ph name="PRODUCT_OS_NAME" /> kasutaja sisselogimisel automaatse täitmise valiku, võimaldades kasutajal sisestada ainult oma kasutajanime ilma domeeninime laiendita. Kasutaja saab selle domeeninime laiendi alistada.</translation>
<translation id="1864382791685519617">Lubab teenuses <ph name="PRODUCT_NAME" /> võrguprognoosid ja keelab kasutajatel selle seade muutmise.

      See juhib DNS-i eellaadimist, TCP ja SSL-i eelühendamist ning veebilehtede eelrenderdust.

      Kui määrate selle reegli, ei saa kasutajad seda seadet teenuses <ph name="PRODUCT_NAME" /> muuta ega alistada.

      Kui see reegel jäetakse määramata, on võrguprognoosid lubatud, kuid kasutaja saab seda muuta.</translation>
<translation id="1865417998205858223">Võtmeload</translation>
<translation id="186719019195685253">Toiming, mis rakendub siis, kui tegevusetuse viivitusaeg saab täis vahelduvvoolu kasutamise ajal</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="1879485426724769439">Määrab seadmes kasutatava ajavööndi. Kasutajad saavad määratud ajavööndi praeguse seansi jaoks alistada, ent pärast väljalogimist taastatakse määratud ajavöönd. Kui sisestatud väärtus on sobimatu, aktiveeritakse reegel ajavööndiga GMT. Kui string on tühi, eiratakse reeglit.

      Kui reeglit ei kasutata, jätkatakse praegu aktiivse ajavööndi kasutamist, ent kasutajad saavad ajavööndit jäädavalt muuta. See tähendab, et ühe kasutaja tehtud muudatus mõjutab sisselogimisekraani ja kõiki teisi kasutajaid.

      Uutes seadmetes on alguses valitud USA Vaikse ookeani ajavöönd.

      Väärtuse vorming põhineb IANA ajavööndite andmebaasis olevatel nimedel (vt https://en.wikipedia.org/wiki/Tz_database). Täpsemalt tähendab see, et ajavööndite nimetused on kujul „manner/suurlinn” või „ookean/suurlinn”.

      Reegli määramisel keelatakse ajavööndi automaatne lahendamine seadme asukoha alusel. Samuti alistab see reegli SystemTimezoneAutomaticDetection.</translation>
<translation id="1885782360784839335">Kogu vahelehel kuvatava reklaamsisu lubamine</translation>
<translation id="1888871729456797026">Pilvepõhise reegli registreerimismärk lauaarvutis</translation>
<translation id="1897365952389968758">Luba kõikidel saitidel JavaScripti käitamine</translation>
<translation id="1906888171268104594">Määrab, kas kasutusmõõdikute teave ja diagnostikaandmed, sh krahhiaruanded, edastatakse Google'ile.

      Kui reegli väärtuseks on määratud Tõene, edastab <ph name="PRODUCT_OS_NAME" /> kasutusmõõdikute teavet ja diagnostikaandmeid.

      Kui reegli väärtuseks on määratud Väär, siis on mõõdikute teabe ja diagnostikaandmete edastamine keelatud.

      Kui reegel on seadistamata, siis on mõõdikute teabe ja diagnostikaandmete edastamine haldamata seadmetes keelatud ja hallatud seadmetes lubatud.</translation>
<translation id="1920046221095339924">Seadmes hallatud seansi lubamine</translation>
<translation id="1929709556673267855">Määrab seadistused seadmetega seotud ettevõtte printeritele.

      See reegel võimaldab teil määrata printeri seadistused operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> seadmetele. Vorming on sama, mis sõnastikul NativePrinters, kus lubatute või keelatute loendisse lisamiseks on printeri puhul vajalik lisaväli „id” või „guid”.

      Faili maht ei tohi ületada 5 MB ja see peab olema kodeeritud JSON-is. Prognooside kohaselt kodeeritakse fail, mis sisaldab ligikaudu 21 000 printerit, 5 MB failina. Krüptograafilist räsiväärtust kasutatakse allalaadimise terviklikkuse kinnitamiseks.

      Fail laaditakse alla ja salvestatakse vahemällu. See laaditakse uuesti alla alati, kui URL või räsiväärtus muutub.

      Kui see reegel on määratud, laadib operatsioonisüsteem <ph name="PRODUCT_OS_NAME" /> alla faili printeri seadistuste jaoks ja muudab printerid kättesaadavaks kooskõlas reeglitega <ph name="DEVICE_PRINTERS_ACCESS_MODE" />, <ph name="DEVICE_PRINTERS_WHITELIST" /> ja <ph name="DEVICE_PRINTERS_BLACKLIST" />.

      See reegel ei mõjuta seda, kas kasutajad saavad printereid seadistada individuaalsetes seadmetes. See on mõeldud individuaalsete kasutajate printerite seadistuse täienduseks.

      See reegel on reegli <ph name="BULK_PRINTERS_POLICY" /> lisa.

      Kui see reegel on määramata, siis seadmete printereid ei ole ja teisi reegleid <ph name="DEVICE_PRINTERS_POLICY_PATTERN" /> eiratakse.
      </translation>
<translation id="193259052151668190">Eemaldatavate USB-seadmete lubatud üksuste loend</translation>
<translation id="1933378685401357864">Taustapildi kujutis</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="1958138414749279167">Lubab rakenduse <ph name="PRODUCT_NAME" /> automaattäite funktsiooni ja võimaldab kasutajatel aadressiteabe automaatselt veebivormidele sisestada, kasutades varem salvestatud teavet.

      Selle seade keelamisel ei anna automaattäite funktsioon soovitusi ega sisesta aadressiteavet. Samuti ei salvesta see aadressi lisateavet, mille kasutaja võib veebi sirvimisel esitada.

      Selle seade lubamisel või määramata jätmisel saab kasutaja kasutajaliideses aadresside automaattäite funktsiooni juhtida.</translation>
<translation id="1960840544413786116">Kas lubada kohalike usaldusvõtmete väljastatud sertifikaadid, millel puudub laiend subjectAlternativeName?</translation>
<translation id="1962273523772270623">Google'i teenustest WebRTC sündmuselogide kogumise lubamine</translation>
<translation id="1964634611280150550">Inkognito režiim on keelatud</translation>
<translation id="1964802606569741174">See reegel ei mõjuta Androidi YouTube'i rakendust. Kui ohutusrežiim on sisse lülitatud, tuleks YouTube jõustada ja Androidi YouTube'i rakenduse installimine keelata.</translation>
<translation id="1969212217917526199">Alistab kaugjuurdepääsu hosti silumisjärkude reeglid.

          Väärtust sõelutakse reegli nime ja reegli väärtuse vastenduste JSON-sõnastikuna.</translation>
<translation id="1969808853498848952">Käitatakse alati pistikprogramme, mis vajavad volitamist (tugi on katkestatud)</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="199764499252435679">Komponentide värskenduste lubamine teenuses <ph name="PRODUCT_NAME" /></translation>
<translation id="2006530844219044261">Toitehaldus</translation>
<translation id="201557587962247231">Seadme oleku aruannete üleslaadimise sagedus</translation>
<translation id="2017301949684549118">Märkamatult installitavate veebirakenduste URL-id.</translation>
<translation id="2018836497795982119">Määrab perioodi millisekundites, mille jooksul seadme haldusteenusele esitatakse päring kasutajareegli teabe hankimiseks.

      Selle reegli määramisel alistatakse vaikeväärtus 3 tundi. Selle reegli kehtivad väärtused jäävad vahemikku 1 800 000 (30 minutit) kuni 86 400 000 (1 päev). Sellest vahemikust välja jäävad väärtused surutakse vastavatesse piiridesse. Kui platvorm toetab reeglite märguandeid, määratakse värskendamise viiteks 24 tundi, kuna eeldatakse, et reegli märguanded jõustavad värskendamise reegli muutmisel automaatselt.

      Kui see reegel jäetakse määramata, kasutab teenus <ph name="PRODUCT_NAME" /> vaikeväärtust 3 tundi.

      Pange tähele, et kui platvorm toetab reeglite märguandeid, määratakse värskendamise viiteks 24 tundi (eirates kõiki vaikeväärtusi ja selle reegli väärtust), kuna eeldatakse, et reegli märguanded jõustavad reegli muutmisel automaatse värskendamise, mis muudab sagedasemad värskendused ebavajalikuks.</translation>
<translation id="2024476116966025075">Vajaliku domeeninime seadistamine kaugjuurdepääsuga klientidele</translation>
<translation id="2030905906517501646">Vaikeotsingupakkuja märksõna</translation>
<translation id="203096360153626918">See reegel ei mõjuta Androidi rakendusi. Täisekraanirežiimi saab aktiveerida ka siis, kui reegli väärtuseks on määratud <ph name="FALSE" />.</translation>
<translation id="2043770014371753404">Ettevõtte keelatud printerid</translation>
<translation id="2057317273526988987">Loendisse lisatud URL-idele juurdepääsu lubamine</translation>
<translation id="206623763829450685">Määrab, milliseid HTTP autentimisskeeme rakendus <ph name="PRODUCT_NAME" /> toetab.

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

          Kui jätate selle reegli määramata, siis kasutatakse kõiki nelja skeemi.</translation>
<translation id="2067011586099792101">Sisupakettidest väljaspool olevatele saitidele juurdepääsu blokeerimine</translation>
<translation id="2073552873076775140">Teenusesse <ph name="PRODUCT_NAME" /> sisselogimise lubamine</translation>
<translation id="2077129598763517140">Kasuta võimaluse korral riistvarakiirendust</translation>
<translation id="2077273864382355561">Ekraani väljalülitamise viiteaeg akutoite kasutamisel</translation>
<translation id="2082205219176343977">Seadmes kõige vanema lubatud Chrome'i versiooni seadistamine.</translation>
<translation id="209586405398070749">Stabiilne kanal</translation>
<translation id="2098658257603918882">Luba kasutus- ja krahhiandmete aruandlus</translation>
<translation id="2111016292707172233">Lubab teenuse <ph name="PRODUCT_NAME" /> sisu vaates funktsiooni Puuduta otsimiseks.

      Kui selle seade lubate, on funktsioon Puuduta otsimiseks kasutaja jaoks saadaval ja ta saab selle sisse või välja lülitada.

      Kui selle seade keelate, keelatakse funktsioon Puuduta otsimiseks täielikult.

      Kui seda reeglit ei määrata, on see võrdväärne lubatuga (vt eelnevat kirjeldust).</translation>
<translation id="2113068765175018713">Seadme tööaja piiramine automaatse taaskäivitamisega</translation>
<translation id="2116790137063002724">Reegel määrab, kas rakendus edastab teavet, mis võimaldab kasutajaid tuvastada, nagu operatsioonisüsteemi sisselogimisteave, rakenduse <ph name="PRODUCT_NAME" /> profiili sisselogimisteave, rakenduse <ph name="PRODUCT_NAME" /> profiili nimi, rakenduse <ph name="PRODUCT_NAME" /> profiili tee ja rakenduse <ph name="PRODUCT_NAME" /> täitmistee.

      Kui reegel on määramata või seatud väärtusele Tõene, kogutakse teavet, mille alusel saab kasutajaid tuvastada.
      Kui reegel on seatud väärtusele Väär, ei koguta teavet, mille alusel saab kasutajaid tuvastada.

      Reegel kehtib ainult juhul, kui <ph name="CHROME_REPORTING_EXTENSION_NAME" /> on lubatud ja seade on reeglis <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" /> registreeritud.</translation>
<translation id="2127599828444728326">Luba märguanded nendel saitidel</translation>
<translation id="2131902621292742709">Ekraani hämardamise viiteaeg akutoite kasutamisel</translation>
<translation id="2132732175597591362">Juhib lubatud loendit URL-i mustritest, mille puhul on automaatesitus alati lubatud.

      Kui automaatesitus on lubatud, võib teenuses <ph name="PRODUCT_NAME" /> videoid koos helisisuga automaatselt (kasutajalt luba küsimata) esitada.

      URL-i muster peab olema vormindatud järgmiste juhiste kohaselt: https://www.chromium.org/administrators/url-blacklist-filter-format.

      Kui reegel AutoplayAllowed on seatud väärtusele Tõene, ei ole sellel reeglil mingit mõju.

      Kui reegel AutoplayAllowed on seatud väärtusele Väär, on selles reeglis määratud URL-i mustrite esitamine lubatud.

      Pange tähele, et kui <ph name="PRODUCT_NAME" /> töötab ja reeglit muudetakse, rakendub see ainult uutele vahelehtedele. Seetõttu võite teatud vahelehtedel märgata eelmist käitumismustrit.</translation>
<translation id="2134437727173969994">Keela ekraani lukustamine</translation>
<translation id="2137064848866899664">Selle reegli määramisel pööratakse iga ekraan
      määratud suunda igal taaskäivitamisel ja esimesel korral, kui see pärast
      reegli väärtuse muutmist ühendatakse. Kasutajad saavad ekraani
      pöördenurka seadete lehel pärast sisselogimist muuta, kuid reegli
      väärtus alistab nende seade järgmisel taaskäivitamisel.

      See reegel kehtib nii peamiste kui ka teiseste ekraanide puhul.

      Kui reegel jäetakse määramata, on vaikeväärtus 0 kraadi ja kasutaja
      saab seda muuta. Sellisel juhul ei rakendata vaikeväärtust
      taaskäivitamisel uuesti.</translation>
<translation id="214901426630414675">Printimise dupleksrežiimi piiramine</translation>
<translation id="2149330464730004005">Värvilise printimise lubamine</translation>
<translation id="2156132677421487971">Seadistab teenuse <ph name="PRODUCT_NAME" /> reeglid. See on funktsioon, mis võimaldab kasutajatel saata vahelehtede, saitide või töölaua sisu brauserist kaugekraanidele või helisüsteemidesse.</translation>
<translation id="2166472654199325139">Täiskasvanutele mõeldud sisuga saite ei filtreerita</translation>
<translation id="2168397434410358693">Jõudeoleku viiteaeg võrgutoite kasutamisel</translation>
<translation id="2170233653554726857">WPAD-optimeerimise lubamine</translation>
<translation id="2176565653304920879">Kui reegel on määratud, toimib ajavööndi automaatse tuvastamise voog seade väärtusest olenevalt järgmisel moel.

      Kui valitud on seade TimezoneAutomaticDetectionUsersDecide, saavad kasutajad ajavööndi automaatset tuvastamist jaotises chrome://settings tavapäraste juhtnuppude abil hallata.

      Kui valitud on seade TimezoneAutomaticDetectionDisabled, keelatakse ajavööndi automaatsed juhtnupud jaotises chrome://settings. Ajavööndi automaatne tuvastamine on alati välja lülitatud.

      Kui valitud on seade TimezoneAutomaticDetectionIPOnly, keelatakse ajavööndi juhtnupud jaotises chrome://settings. Ajavööndi automaatne tuvastamine on alati sisse lülitatud. Ajavööndi tuvastamise funktsioon kasutab asukoha lahendamiseks ainult IP-aadressil põhinevat meetodit.

      Kui valitud on seade TimezoneAutomaticDetectionSendWiFiAccessPoints, keelatakse ajavööndi juhtnupud jaotises chrome://settings. Ajavööndi automaatne tuvastamine on alati sisse lülitatud. Nähtavate WiFi-pääsupunktide loend saadetakse ajavööndi täpseks tuvastamiseks alati asukoha määramise API serverisse.

      Kui valitud on seade TimezoneAutomaticDetectionSendAllLocationInfo, keelatakse ajavööndi juhtnupud jaotises chrome://settings. Ajavööndi automaatne tuvastamine on alati sisse lülitatud. Asukohateave (nt WiFi-pääsupunktid, kättesaadavad mobiilimastid, GPS) saadetakse täpseks ajavööndi tuvastamiseks serverisse.

      Kui reegel on määramata, käitub see, nagu oleks valitud seade TimezoneAutomaticDetectionUsersDecide.

      Kui määratud on reegel SystemTimezone, alistab see selle reegli. Sel juhul keelatakse ajavööndi automaatne tuvastamine täielikult.</translation>
<translation id="2178899310296064282">Jõusta YouTube'is vähemalt keskmiselt piiratud režiim</translation>
<translation id="2182291258410176649">Kasutaja otsustab, kas lubada varundamine ja taastamine</translation>
<translation id="2183294522275408937">See seade juhib, kui sageli nõuab lukustuskuva parooli sisestamist, et kiiravamise kasutamist jätkata. Iga kord kui kuva lukustatakse ja parooli sisestamisest on möödunud kauem, kui on selle seade väärtus, pole kiiravamine lukustuskuval saadaval. Kui kasutaja on lukustuskuval sellest perioodist kauem, nõutakse parooli järgmisel korral, kui kasutaja sisestab vale koodi või aktiveerib uuesti lukustuskuva (olenevalt sellest, kumb enne juhtub).

          Kui see seade on seadistatud, peavad kasutajad, kes kasutavad kiiravamist, sisestama lukustuskuval parooli sellest seadest olenevalt.

          Kui see seade on seadistamata, peavad kasutajad, kes kasutavad kiiravamist, sisestama lukustuskuval parooli iga päev.</translation>
<translation id="2194470398825717446">Tugi sellele reeglile on versioonis M61 katkestatud. Kasutage selle asemel reeglit EcryptfsMigrationStrategy.

      Määrab, kuidas peaks käituma süsteemiga ecryptfs tarnitud seade, mis on vaja üle viia krüpteerimissüsteemile ext4.

      Kui määrate reegli väärtuseks „DisallowArc”, on Androidi rakendused kõigi seadme kasutajate jaoks keelatud (sh rakendused, mis põhinevad juba krüpteerimissüsteemil ext4) ja ühelegi kasutajale ei pakuta üleminekut krüpteerimissüsteemilt ecryptfs süsteemile ext4.

      Kui määrate reegli väärtuseks „AllowMigration”, pakutakse kasutajatele, kelle juurkataloog põhineb süsteemil ecryptfs, vajaduse korral (praegu siis, kui Android N tuleb seadmes saadavale) võimalust üle minna krüpteerimissüsteemile ext4.

      See reegel ei kehti kioskirakendustele – need viiakse üle automaatselt. Kui jätate reegli määramata, käitub seade nii, nagu oleks valitud väärtus „DisallowArc”.</translation>
<translation id="2195032660890227692">Reegel eemaldati operatsioonisüsteemist <ph name="PRODUCT_NAME" /> 68 ja see asendati reegliga <ph name="ARC_BR_POLICY_NAME" />.</translation>
<translation id="2201555246697292490">Omasõnumside lubatud üksuste loendi seadistamine</translation>
<translation id="2204753382813641270">Seadista hoidla automaatne peitmine</translation>
<translation id="2208976000652006649">Parameetrid POST-meetodit kasutava otsingu URL-i jaoks</translation>
<translation id="2214880135980649323">Kui see reegel on lubatud, lubatakse ettevõtte reegliga installitud laiendustel kasutada ettevõtte riistvara platvormi API-t.
      Kui see reegel on keelatud või määramata, ei tohi ükski laiendus ettevõtte riistvara platvormi API-t kasutada.
      See reegel kehtib ka komponendi laiendustele, nt Hangouti teenuste laiendusele.</translation>
<translation id="2223598546285729819">Teatiste vaikeseade</translation>
<translation id="2231817271680715693">Sirvimisajaloo importimine vaikebrauserist esimesel käitamisel</translation>
<translation id="2236488539271255289">Keela kõigil saitidel kohalike andmete seadmine</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="2269319728625047531">Sisselogimisel sünkroonimise nõusoleku kuvamise lubamine</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="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="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="2294382669900758280">Video esitamist Androidi rakendustes ei arvestata, isegi kui reegli väärtuseks on määratud <ph name="TRUE" />.</translation>
<translation id="2298647742290373702">Seadistab uue vaikevahelehe teenuses <ph name="PRODUCT_NAME" />.</translation>
<translation id="2299220924812062390">Lubatud pistikprogrammide loendi määramine</translation>
<translation id="2303795211377219696">Automaattäite lubamine krediitkaartide puhul</translation>
<translation id="2309390639296060546">Geograafilise asukoha vaikeseade</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="2327252517317514801">G Suite'i kasutamise loaga domeenide määramine</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="2386362615870139244">Ekraani aktiveerimise lukustamise lubamine</translation>
<translation id="2411817661175306360">Paroolikaitse hoiatus on välja lülitatud</translation>
<translation id="2411919772666155530">Blokeerige märguanded nendel saitidel</translation>
<translation id="2418507228189425036">Keelab brauseris <ph name="PRODUCT_NAME" /> sirvimisajaloo salvestamise ja takistab kasutajaid seadet muutmast.

      Kui seade on lubatud, ei salvestata sirvimisajalugu. Seade keelab ka vahelehtede sünkroonimise.

      Kui seade on keelatud või määramata, salvestatakse sirvimisajalugu.</translation>
<translation id="2426782419955104525">Lubab toote <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.

      Toote <ph name="PRODUCT_NAME" /> 29-st ja uuematest versioonidest on see seade eemaldatud.</translation>
<translation id="2433412232489478893">Reegel määrab, kas teenuse <ph name="PRODUCT_NAME" /> failide võrguhoidlate funktsioon on kasutaja jaoks lubatud.

      Kui reegel on seadistamata või seatud väärtusele Tõene, saavad kasutajad failide võrguhoidlaid kasutada.

      Kui reegel on seatud väärtusele Väär, ei saa kasutajad failide võrguhoidlaid kasutada.</translation>
<translation id="2438609638493026652">Võimaldab Androidi rakenduse installimise ajal saata Google'ile teavitusi oluliste sündmuste kohta. Sündmused jäädvustatakse ainult rakenduste puhul, mille installimine käivitati reegli kaudu.

      Kui reegel on määratud väärtusele Tõene, siis sündmused logitakse.
      Kui reegel on määratud väärtusele Väär või määramata, siis sündmusi ei logita.</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="2463365186486772703">Rakenduse lokaat</translation>
<translation id="2466131534462628618">Hõiveportaali autentimisel puhverserveri eiramine</translation>
<translation id="2482676533225429905">Omasõnumside</translation>
<translation id="2483146640187052324">Ennusta võrgutoiminguid iga võrguühenduse puhul</translation>
<translation id="2484208301968418871">See reegel haldab teenuse SafeSites URL-ide filtri rakendamist.
      See filter kasutab Google Safe Search API-t, et määrata, kas URL-il olev sisu on pornograafiline või mitte.

      Kui see reegel on seadistamata või määratud valikule „Täiskasvanutele mõeldud sisuga saite ei filtreerita”, siis saite ei filtreerita.

      Kui see reegel on määratud valikule „Filtreeri täiskasvanutele mõeldud sisuga ülataseme saidid”, siis pornograafilist sisu sisaldavad saidid filtreeritakse.</translation>
<translation id="2486371469462493753">Keelab sertifikaadi läbipaistvuse nõuete jõustamise loetletud URL-idel.

      Reegel lubab määratud URL-ide hostinimede sertifikaadid, mis ei ole sertifikaadi läbipaistvuse reegli kaudu avalikustatud. See lubab ka edaspidi kasutada sertifikaate, mida peetaks muidu ebausaldusväärseks, kuna need ei ole sobival moel avalikustatud, ent muudab hostide valesti väljastatud sertifikaatide tuvastamise keerulisemaks.

      URL-i muster vormindatakse aadressil https://www.chromium.org/administrators/url-blacklist-filter-format kirjeldatud moel. Kuna aga sertifikaadid kehtivad konkreetse hostinime puhul olenemata skeemist, pordist või teest, võetakse arvesse ainult URL-i hostinime osa. Metamärkidega hoste ei toetata.

      Kui jätate reegli määramata, peetakse ebausaldusväärseks kõiki sertifikaate, mis ei ole sertifikaadi läbipaistvuse reegli kaudu avalikustatud, ent mille puhul see on kohustuslik.</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="2498238926436517902">Peida hoidla alati automaatselt</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="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="2518231489509538392">Heli esitamise lubamine</translation>
<translation id="2521581787935130926">Kuva rakenduste otsetee järjehoidjaribal</translation>
<translation id="2529880111512635313">Sunniviisiliselt installitud rakenduste ja laienduste loendi seadistamine</translation>
<translation id="253135976343875019">Tegevusetuse hoiatuse viivitus vahelduvvoolutoite kasutamisel</translation>
<translation id="2536525645274582300">Kasutaja otsustab, kas lubada Google'i asukohateenused</translation>
<translation id="2550593661567988768">Ainult simpleksprintimine</translation>
<translation id="2552966063069741410">Ajavöönd</translation>
<translation id="2562339630163277285">Määrab otsingumootori URL-i, mida kasutatakse vahetute 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.

          Google'i vahetute otsingutulemuste URL-iks võib määrata: <ph name="GOOGLE_INSTANT_SEARCH_URL" />


         See reegel kehtib vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="2569647487017692047">Kui reegel määratakse väärtusele Väär, keelab <ph name="PRODUCT_OS_NAME" /> Bluetoothi ja kasutaja ei saa seda uuesti lubada.

      Kui reegel jäetakse määramata või määratakse väärtusele Tõene, saab kasutaja ise Bluetoothi lubada ja keelata.

      Kui reegel on määratud, ei saa kasutaja seda muuta ega alistada.

      Pärast Bluetoothi lubamist peab kasutaja välja ja uuesti sisse logima, et muudatused jõustuksid (seda ei ole vaja Bluetoothi keelamisel).</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="2587719089023392205">Brauseri <ph name="PRODUCT_NAME" /> määramine vaikebrauseriks</translation>
<translation id="2592091433672667839">Inaktiivsuse periood, mille möödudes kuvatakse jaemüügirežiimis sisselogimiskuval ekraanisäästja</translation>
<translation id="2596260130957832043">Määrab, kas NTLMv2 on lubatud või mitte.

          Kõik hiljutised Samba ja Windowsi serverid toetavad NTLMv2. See tuleks keelata ainult tagasiulatuva ühilduvuse puhul ja see vähendab autentimise turvalisust.

          Kui see reegel on määramata, siis on vaikeväärtus Tõene ja NTLMv2 on lubatud.</translation>
<translation id="2598508021807251719">Seadistab lokaadid, kus tohib operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> kuvada.

      Kui reegel on määratud, saab kasutaja seadistada operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> nii, et seda tohiks kuvada ainult selle reegliga määratud lokaatides. Kui reegel on määramata või määratud on tühi loend, tohib operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> kuvada kõikides toetatud lokaatides. Kui reegli jaoks on määratud sobimatute väärtustega loend, eiratakse kõiki sobimatuid väärtusi. Kui kasutaja oli operatsioonisüsteemis <ph name="PRODUCT_OS_NAME" /> valinud kuvatava keele, mis ei ole selle reegli kohaselt lubatud, määratakse kasutaja järgmisel sisselogimisel lubatud kuvatav lokaat. Kui kasutaja oli seadistanud eelistatud lokaadid ja üks eelistatud lokaatidest on selle reegli alusel lubatud, aktiveeritakse operatsioonisüsteemis <ph name="PRODUCT_OS_NAME" /> see lokaat. Muul juhul kasutatakse operatsioonisüsteemis <ph name="PRODUCT_OS_NAME" /> reegli esimest sobivat väärtust või varulokaati (praegu en-US), kui reegel sisaldab ainult sobimatuid kirjeid.</translation>
<translation id="2604182581880595781">Failide võrguhoidlatega seotud reeglite seadistamine.</translation>
<translation id="2623014935069176671">Kasutaja esmase tegevuse ootamine</translation>
<translation id="262740370354162807">Luba dokumentide saatmine teenusesse <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="2627554163382448569">Määrab seadistused ettevõtte printeritele.

      See reegel võimaldab teil määrata printeri seadistused operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> seadmetele. Vorming on sama, mis sõnastikul NativePrinters, kus lubatute või keelatute loendisse lisamiseks on printeri puhul vajalik lisaväli „id” või „guid”.

      Faili maht ei tohi ületada 5 MB ja see peab olema kodeeritud JSON-is. Prognooside kohaselt kodeeritakse fail, mis sisaldab ligikaudu 21 000 printerit, 5 MB failina. Krüptograafilist räsiväärtust kasutatakse allalaadimise terviklikkuse kinnitamiseks.

      Fail laaditakse alla ja salvestatakse vahemällu. See laaditakse uuesti alla alati, kui URL või räsiväärtus muutub.

      Kui see reegel on määratud, laadib operatsioonisüsteem <ph name="PRODUCT_OS_NAME" /> alla faili printeri seadistuste jaoks ja muudab printerid kättesaadavaks kooskõlas reeglitega <ph name="BULK_PRINTERS_ACCESS_MODE" />, <ph name="BULK_PRINTERS_WHITELIST" /> ja <ph name="BULK_PRINTERS_BLACKLIST" />.

      Selle reegli määramisel ei saa kasutajad seda muuta ega alistada.

      See reegel ei mõjuta seda, kas kasutajad saavad printereid seadistada individuaalsetes seadmetes. See on mõeldud individuaalsete kasutajate printerite seadistuse täienduseks.
      </translation>
<translation id="2633084400146331575">Luba suuline tagasiside</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="2647069081229792812">Järjehoidjate muutmise lubamine või keelamine</translation>
<translation id="2650049181907741121">Tehtav toiming, kui kasutaja kaane sulgeb</translation>
<translation id="2655233147335439767">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.

          Google'i otsingu URL-iks võib määrata: <ph name="GOOGLE_SEARCH_URL" />

          Valik tuleb määrata ja seda rakendatakse vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="2659019163577049044">Kui seade on lubatud, võivad kasutajad seadmetes seadistada SMS-ide sünkroonimise telefoni ja Chromebooki vahel. Pange tähele, et kui reegel on lubatud, peavad kasutajad funktsiooni selgesõnaliselt lubama, viies lõpule seadistusvoo. Pärast seadistusvoo lõppu saavad kasutajad Chromebookis SMS-e saata ja vastu võtta.

      Kui seade on keelatud, ei ole kasutajatel lubatud SMS-ide sünkroonimist seadistada.

      Kui seade jäetakse seadistamata, on see hallatavate kasutajate puhul vaikimisi keelatud ja haldamata kasutajate puhul lubatud.</translation>
<translation id="2660846099862559570">Ära kunagi kasuta puhverserverit</translation>
<translation id="2672012807430078509">Võimaldab lubada NTLM-i autentimisprotokolli ühendatud SMB-de jaoks</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="268577405881275241">Andmete tihendamise puhverserveri funktsiooni lubamine</translation>
<translation id="2693108589792503178">Parooli URL-i muutmise seadistamine.</translation>
<translation id="2731627323327011390">Keela ARC-rakenduste jaoks operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> sertifikaatide kasutamine</translation>
<translation id="2742843273354638707">Peitke Chrome'i veebipoe rakendus ja jaluse link uuel vahelehel ja operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> rakenduse käivitajas.

      Kui selle reegli olekuks määratakse Tõene, siis ikoonid peidetakse.

      Kui selle reegli olekuks määratakse Väär või jäetakse seadistamata, on ikoonid nähtaval.</translation>
<translation id="2744751866269053547">Protokollitöötlejate registreerimine</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="2753637905605932878">WebRTC kasutatavate kohalike UDP-portide vahemiku piiramine</translation>
<translation id="2755385841634849932">See reegel juhib Androidi varundamise ja taastamise saadavalolekut.

      Kui reegel on seadistamata või seatud väärtusele <ph name="BR_DISABLED" />, on Androidi varundamine ja taastamine keelatud ning kasutaja ei saa seda lubada.

      Kui reegel on määratud väärtusele <ph name="BR_UNDER_USER_CONTROL" />, palutakse kasutajal valida, kas ta soovib Androidi varundus- ja taasteteenust kasutada. Kui kasutaja lubab varundamise ja taastamise, laaditakse ühilduvate Androidi rakenduste andmed üles Androidi varundusserveritesse ja need taastatakse rakenduste uuesti installimisel.</translation>
<translation id="2757054304033424106">Laienduste/rakenduste tüübid, mille installimine on lubatud</translation>
<translation id="2759224876420453487">Kasutaja käitumise kontrollimine multiprofiili seansis</translation>
<translation id="2761483219396643566">Tegevusetuse hoiatuse viivitus akutoite kasutamisel</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="2769952903507981510">Kaugjuurdepääsu hostidele nõutava domeeninime seadistamine</translation>
<translation id="2787173078141616821">Saada teavet Androidi oleku kohta</translation>
<translation id="2799297758492717491">Lubatud loendisse lisatud URL-i mustrite puhul meediasisu automaatesituse lubamine</translation>
<translation id="2801230735743888564">Luba kasutajal mängida dinosauruse üllatusmängu, kui seade pole võrguga ühendatud.

      Kui selle reegli väärtuseks on määratud Väär, ei saa kasutajad dinosauruse üllatusmängu mängida, kui seade pole võrguga ühendatud. Kui seade väärtuseks on määratud Tõene, saavad kasutajad dinosaurusemängu mängida. Kui see reegel on määramata, ei saa kasutajad dinosauruse üllatusmängu mängida registreeritud Chrome OS-is, kuid saavad seda mängida muudel juhtudel.</translation>
<translation id="2802085784857530815">Võimaldab juhtida, kas kasutajatel on juurdepääs ettevõttevälistele printeritele

      Kui reegel on seadistamata või määratud väärtusele Tõene, saavad kasutajad enda printereid lisada ja seadistada ning nendega printida.

      Kui reegel on määratud väärtusele Väär, ei saa kasutajad enda printereid lisada ega seadistada. Samuti ei saa nad varem konfigureeritud printeritega printida.
      </translation>
<translation id="2805707493867224476">Luba kõigil saitidel hüpikakende kuvamine</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="2823870601012066791">Windowsi registri asukoht operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> klientide puhul:</translation>
<translation id="2824715612115726353">Luba inkognitorežiim</translation>
<translation id="2838830882081735096">Keela andmete üleviimine ja ARC</translation>
<translation id="2839294585867804686">Failide võrguhoidlate seaded</translation>
<translation id="2840269525054388612">Määrab printerid, mida kasutaja saab kasutada.

      Seda reeglit kasutatakse ainult siis, kui režiimis <ph name="DEVICE_PRINTERS_ACCESS_MODE" /> on valitud väärtus <ph name="PRINTERS_WHITELIST" />

      Selle reegli kasutamisel on kasutajale saadaval ainult printerid, mille ID-d ühtivad selles reeglis olevate väärtustega. ID-d peavad ühtima reeglis <ph name="DEVICE_PRINTERS_POLICY" /> määratud failis olevate väljadega „id” või „guid”.
      </translation>
<translation id="285480231336205327">Luba kõrge kontrastiga režiim</translation>
<translation id="2854919890879212089"><ph name="PRODUCT_NAME" /> kasutab selle seade puhul printimise eelvaates vaikevalikuna süsteemi vaikeprinterit, mitte viimati kasutatud printerit.

      Kui keelate seade või jätate väärtuse määramata, kasutab printimise eelvaade vaikesihtkohana viimati kasutatud printerit.

      Kui lubate selle seade, kasutab printimise eelvaade vaikesihtkohana operatsioonisüsteemi vaikeprinterit.</translation>
<translation id="2856674246949497058">Võimaldab naasta ja jääda sihtversioonile, kui operatsioonisüsteemi versioon on uuem kui sihtversioon. Tehke protsessi käigus Powerwash.</translation>
<translation id="2872961005593481000">Lülita välja</translation>
<translation id="2873651257716068683">Alistab prinditava lehe vaikesuuruse. Reeglit eiratakse, kui lehe suurus ei ole saadaval.</translation>
<translation id="2874209944580848064">Märkus Androidi rakendusi toetavate operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> seadmete kohta.</translation>
<translation id="2877225735001246144">Keela CNAME-i otsing Kerberose autentimise läbirääkimisel</translation>
<translation id="2890645751406497668">Nendele saitidele antakse automaatselt luba luua ühendus määratud tootja ja toote ID-ga USB-seadmetega.</translation>
<translation id="2892414556511568464">Piirab printimise dupleksrežiimi. Määramata reeglit ja tühja hulka käsitletakse piirangu puudumisena.</translation>
<translation id="2893546967669465276">Süsteemilogide saatmine haldusserverisse</translation>
<translation id="2899002520262095963">Androidi rakendused saavad kasutada selle reegliga määratud võrguseadistusi ja CA-sertifikaate, kuid ei pääse juurde mõnele seadistusvalikule.</translation>
<translation id="290002216614278247">Võimaldab lukustada kasutajaseansi kliendi aja või igapäevase kasutuskvoodi alusel.

          Atribuut |time_window_limit| määrab igapäevase ajavahemiku, mille vältel peab kasutajaseanss olema lukustatud. Iga nädalapäeva puhul toetatakse ainult üht reeglit, seega võib massiivi |entries| suurus varieeruda vahemikus 0–7. Atribuudid |starts_at| ja |ends_at| määravad ajavahemiku alguse ja lõpu. Kui |ends_at| on väiksem kui |starts_at|, tähendab see, et |time_limit_window| lõpeb järgmisel päeval. Atribuut |last_updated_millis| on UTC ajatempel, mis näitab kirje viimase värskendamise aega. See saadetakse stringina, kuna ajatemplit ei saa täisarvuna esitada.

          Atribuut |time_usage_limit| määrab igapäevase kasutuskvoodi, mille täitumisel kasutajaseanss lukustatakse. Iga nädalapäeva jaoks on eraldi atribuut ja see tuleks määrata ainult juhul, kui teatud päeval kehtib aktiivne kvoot. Atribuut |usage_quota_mins| määrab, kui kaua tohib hallatud seadet päeva jooksul kasutada, ja |reset_at| määrab, millal kasutuskvooti uuendatakse. Atribuudi |reset_at| vaikeväärtus on südaöö ({'hour': 0, 'minute': 0}). Atribuut |last_updated_millis| on UTC ajatempel, mis näitab kirje viimase värskendamise aega. See saadetakse stringina, kuna ajatemplit ei saa täisarvuna esitada.

          Atribuut |overrides| võimaldab ühe või mitu eelmist reeglit ajutiselt tühistada.
          * Kui atribuudid time_window_limit ja time_usage_limit ei ole aktiivsed, saab seadme lukustamiseks kasutada atribuuti |LOCK|.
          * |LOCK| lukustab kasutajaseansi ajutiselt kuni järgmise atribuudi time_window_limit või time_usage_limit alguseni.
          * |UNLOCK| avab kasutajaseansi, mis lukustati atribuudiga time_window_limit või time_usage_limit.
          Atribuut |created_time_millis| on alistuse loomise UTC ajatempel. See saadetakse stringina, kuna ajatemplit ei saa täisarvuna esitada. Selle alusel määratakse, kas alistus tuleks rakendada. Kui praegune aktiivne ajapiirangu funktsioon (time_usage_limit või time_window_limit) algas pärast alistuse loomist, ei tohiks see aktiveeruda. Seda ei tohiks rakendada ka juhul, kui alistus loodi enne atribuutide time_window_limit või time_usage_window viimast muutmist.

          Saata võib mitu alistust, misjuhul rakendatakse uusim sobiv kirje.</translation>
<translation id="2906874737073861391">AppPacki laienduste loend</translation>
<translation id="2907992746861405243">Juhib, millised printerid on reegli <ph name="BULK_PRINTERS_POLICY" /> puhul kasutajatele saadaval.

      Määrab, millist juurdepääsureeglit kasutatakse printerite hulgiseadistamiseks. Kui valitud on väärtus <ph name="PRINTERS_ALLOW_ALL" />, kuvatakse kõik printerid. Kui valitud on väärtus <ph name="PRINTERS_BLACKLIST" />, kasutatakse määratud printeritele juurdepääsu piiramiseks reeglit <ph name="BULK_PRINTERS_BLACKLIST" />. Kui valitud on väärtus <ph name="PRINTERS_WHITELIST" />, määrab reegel <ph name="BULK_PRINTERS_WHITELIST" /> ainult need printerid, mida saab valida.

      Kui see reegel on määramata, kasutatakse väärtust <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="2908277604670530363">Puhverserveri samaaegsete ühenduste maksimaalne arv</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="2957506574938329824">Ära luba ühelgi seadmel taotleda Web Bluetooth API kaudu juurdepääsu Bluetoothi seadmetele</translation>
<translation id="2957513448235202597">Üksuse <ph name="HTTP_NEGOTIATE" /> autentimisel kasutatava konto tüüp</translation>
<translation id="2959898425599642200">Puhverserveri möödumisreeglid</translation>
<translation id="2960128438010718932">Kontrollimise ajakava uue värskenduse rakendamiseks</translation>
<translation id="2960691910306063964">Kaugjuurdepääsu hostide PIN-koodita autentimise lubamine või keelamine</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="2987155890997901449">ARC lubamine</translation>
<translation id="2987227569419001736">Web Bluetooth API kasutuse kontrollimine</translation>
<translation id="3016255526521614822">Lisage lubatud rakenduste loendisse märkmete tegemise rakendused, mida <ph name="PRODUCT_OS_NAME" /> võib lukustuskuval näidata</translation>
<translation id="3021562480854470924">Tagasiminekuks lubatud eelmiste versioonide arv</translation>
<translation id="3030000825273123558">Luba mõõdikute aruandlus</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="3038323923255997294">Jätka taustarakenduste käitamist pärast rakenduse <ph name="PRODUCT_NAME" /> sulgemist</translation>
<translation id="3046192273793919231">Veebioleku jälgimiseks võrgupakettide haldusserverisse saatmine</translation>
<translation id="3047732214002457234">Määrab, kuidas Chrome Cleanup edastab andmeid Google'ile</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="306887062252197004">See reegel võimaldab funktsiooni WebDriver kasutajatel alistada
      reeglid, mis võivad selle tööd häirida.

      See reegel keelab praegu reeglid SitePerProcess ja IsolateOrigins.

      Kui see reegel on lubatud, saab WebDriver alistada ühildumatud
      reeglid.
      Kui see reegel on keelatud või seadistamata, ei tohi WebDriver
      ühildumatuid reegleid alistada.</translation>
<translation id="3069958900488014740">Lubab teenuses <ph name="PRODUCT_NAME" /> WPAD-i (veebi puhverserveri automaatne avastamine) optimeerimise välja lülitada.

      Kui selle reegli väärtuseks on määratud Väär, on WPAD-i optimeerimine keelatud ja teenus <ph name="PRODUCT_NAME" /> peab DNS-põhiseid WPAD-i servereid kauem ootama. Kui reeglit pole määratud või see on lubatud, on WPAD-i optimeerimine lubatud.

      Olenemata sellest, kas ja kuidas see reegel on määratud, ei saa kasutajad WPAD-i optimeerimise seadet muuta.</translation>
<translation id="3072045631333522102">Ekraanisäästja, mida kasutatakse jaemüügirežiimis sisselogimiskuval</translation>
<translation id="3072847235228302527">Teenusetingimuste määramine seadmes kasutatava konto jaoks</translation>
<translation id="3077183141551274418">Lubab või keelab vahelehtede elutsüklid</translation>
<translation id="3086995894968271156">Cast'i vastuvõtja seadistamine teenuses <ph name="PRODUCT_NAME" />.</translation>
<translation id="3088796212846734853">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud kuvada pilte.

          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.

          Pange tähele, et reegel oli seni Androidis ekslikult lubatud, ent seda funktsiooni ei ole Androidis kunagi täielikult toetatud.</translation>
<translation id="3096595567015595053">Lubatud pistikprogrammide loend</translation>
<translation id="3101501961102569744">Valimine, kuidas määrata puhverserveri seaded</translation>
<translation id="3117676313396757089">Hoiatus. DHE eemaldatakse teenusest <ph name="PRODUCT_NAME" /> pärast versiooni 57 täielikult (umbes 2017. aasta märtsis) ja edaspidi see reegel enam ei tööta.

      Kui reegel on määramata või selle väärtuseks on määratud Väär, ei ole DHE šifreerimiskomplektid TLS-is lubatud. Selle väärtuseks võib olla määratud ka Tõene, et lubada DHE šifreerimiskomplektid ja et säilitada ühilduvus aegunud serveriga. See on ajutine meede ja server tuleks ümber seadistada.

      Serverid on soovitatav üle viia ECDHE šifreerimiskomplektidele. Kui need ei ole saadaval, lubage kindlasti RSA võtmevahetust kasutav šifreerimiskomplekt.</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="3171369832001535378">Seadme võrgu hostinime mall</translation>
<translation id="3185009703220253572">alates versioonist <ph name="SINCE_VERSION" /></translation>
<translation id="3187220842205194486">Androidi rakendused ei pääse juurde ettevõttevõtmetele. See reegel neid ei mõjuta.</translation>
<translation id="3201273385265130876">Võimaldab määrata rakenduse <ph name="PRODUCT_NAME" /> kasutatava puhverserveri ega lase kasutajatel puhverserveri seadeid muuta.

          Kui valite seade, mille puhul ei kasutata kunagi puhverserverit ja ühendus luuakse alati otse, eiratakse kõiki muid valikuid.

          Kui kasutate süsteemi puhverserveri seadeid, eiratakse kõiki muid valikuid.

          Kui seadistate puhverserveri automaatse tuvastamise, eiratakse kõiki muid valikuid.

          Kui valite fikseeritud serveri puhverrežiimi, saate määrata täpsemad valikud jaotistes „Puhverserveri aadress või URL” ja „Puhverserverist möödumise reeglite komaeraldusega loend”. ARC-rakenduste jaoks on saadaval vaid prioriteetne HTTP-puhverserver.

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

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

          Kui lubate selle seade, eiravad <ph name="PRODUCT_NAME" /> ja ARC-rakendused kõiki käsureal määratud puhverserveriga seotud valikuid.

          Kui jätate reegli määramata, saavad kasutajad ise puhverserveri seadeid määrata.</translation>
<translation id="3205825995289802549">Esmasel käivitamisel esimese brauseriakna maksimeerimine</translation>
<translation id="3211426942294667684">Brauserisse sisselogimise seaded</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="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="3219421230122020860">Saadaval on inkognito režiim</translation>
<translation id="3220624000494482595">Kui kioskirakendus on Androidi rakendus, ei juhi see operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> versiooni, isegi kui reegli väärtuseks on määratud <ph name="TRUE" />.</translation>
<translation id="3236046242843493070">URL-ide mustrid, millelt on lubatud installida laiendusi, rakendusi ja kasutaja skripte</translation>
<translation id="3240609035816615922">Printeri seadistuse juurdepääsu reegel.</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="3264793472749429012">Vaikeotsingupakkuja kodeeringud</translation>
<translation id="3273221114520206906">JavaScripti vaikeseade</translation>
<translation id="3284094172359247914">WebUSB API kasutuse juhtimine</translation>
<translation id="3288595667065905535">Väljastuskanal</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="3307746730474515290">Määrab, millist tüüpi rakendusi/laiendusi tohib installida, ja piirab käitusaja juurdepääsu.

          Seade loob lubatute loendi kõikidest laiendustest/rakendustest, mille tohib teenusesse <ph name="PRODUCT_NAME" /> installida, ja määrab, milliste hostidega need saavad suhelda. Väärtus on stringide loend, millest igaüks peab olema üks järgmistest: „extension”, „theme”, „user_script”, „hosted_app”, „legacy_packaged_app” või „platform_app”. Nende tüüpide kohta lisateabe saamiseks vaadake teenuse <ph name="PRODUCT_NAME" /> laienduste dokumente.

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

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

          Kui jätate seade seadistamata, ei rakendata kohaldatavatele laienduste/rakenduste tüüpidele piiranguid.</translation>
<translation id="3322771899429619102">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud kasutada võtmete loomist. Kui URL-i muster on loendis „KeygenBlockedForUrls”, alistab see need erandid.

          Kui jätate reegli määramata, kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultKeygenSetting”, kui see on määratud, või kasutaja isiklikku seadistust.</translation>
<translation id="332771718998993005">Määratakse nimi, mida esitatakse teenuse <ph name="PRODUCT_NAME" /> sihtkohana.

          Kui selle reegli väärtuseks määratakse mõni täidetud string, kasutatakse seda stringi teenuse <ph name="PRODUCT_NAME" /> sihtkohana. Muul juhul on sihtkoha nimeks seadme nimi. Kui see reegel jäetakse määramata, on sihtkoha nimeks seadme nimi ja seadme omanik (või seadet haldava domeeni kasutaja) saab seda muuta. Nimi tohib olla maksimaalselt 24 tähemärki.</translation>
<translation id="3335468714959531450">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud lisada küpsisefaile.

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

          Vaadake ka reegleid „CookiesBlockedForUrls” ja „CookiesSessionOnlyForUrls”. Pange tähele, et nende kolme reegli vahel ei tohi esineda URL-i mustrite konflikte, kuna eesõigusega reeglit ei ole määratud.</translation>
<translation id="3373364525435227558">Määrab hallatud seansi jaoks vähemalt ühe või mitu soovitatavat lokaati, mis võimaldab kasutajatel hõlpsasti lokaadi valida.

      Kasutajad saavad enne hallatud seansi alustamist valida lokaadi ja klaviatuuripaigutuse. Vaikimisi on kõik operatsioonisüsteemis <ph name="PRODUCT_OS_NAME" /> toetatud lokaadid loetletud tähestikulises järjekorras. Selle reegli abil saate teisaldada soovitatud lokaadid loendi ülaossa.

      Kui reegel on määramata, on praegune kasutajaliidese lokaat eelvalitud.

      Kui reegel on määratud, teisaldatakse soovitatavad lokaadid loendi ülaossa ja neid saab muudest lokaatidest visuaalselt eristada. Soovitatud lokaadid loetletakse samas järjekorras nagu reeglis. Esimene soovitatav lokaat on eelvalitud.

      Kui soovitatud lokaate on mitu, eeldatakse, et kasutaja soovib nende lokaatide hulgast valida. Lokaadi ja klaviatuuripaigutuse valik tõstetakse avaliku seansi alguses selgelt esile. Muidu eeldatakse, et enamik kasutajaid soovib kasutada eelvalitud lokaati. Lokaadi ja klaviatuuripaigutuse valik tõstetakse avaliku seansi alguses vähem märgatavalt esile.

      Kui reegel on määratud ja automaatne sisselogimine on lubatud (vt reegleid |DeviceLocalAccountAutoLoginId| ja |DeviceLocalAccountAutoLoginDelay|), kasutab automaatselt käivitatud avalik seanss esimest soovitatud lokaati ja selle kõige populaarsemat klaviatuuripaigutust.

      Eelvalitud klaviatuuripaigutus on alati kõige populaarsem paigutus, mis vastab eelvalitud lokaadile.

      Reegli saab määrata ainult soovitusena. Reegliga saab teisaldada soovitatud lokaadid loendi ülaossa, kuid kasutajad võivad alati seansi jaoks valida mis tahes muu lokaadi, mida operatsioonisüsteem <ph name="PRODUCT_OS_NAME" /> toetab.
      </translation>
<translation id="3381968327636295719">Kasuta vaikimisi hostbrauserit</translation>
<translation id="3414260318408232239">Kui seda reeglit pole seadistatud, siis kasutab teenus <ph name="PRODUCT_NAME" /> vaikimisi miinimumversiooni, milleks on TLS 1.0.

      Muul juhul võidakse see määrata ühele järgmistest väärtustest: „tls1”, „tls1.1” või „tls1.2”. Kui see on määratud, ei kasuta teenus <ph name="PRODUCT_NAME" /> SSL-i/TLS-i versioone, mis on määratud versioonist vanemad. Tundmatut väärtust eiratakse.</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="3418871497193485241">YouTube'is jõustatakse minimaalselt piiratud režiim ja kasutajatel ei lubata
      valida vähem piiratud režiimi.

      Kui selle seade väärtuseks on määratud Range, on rangelt piiratud režiim YouTube'is alati aktiivne.

      Kui selle seade väärtuseks on määratud Keskmine, saab kasutaja YouTube'is valida ainult keskmiselt piiratud režiimi
      ja rangelt piiratud režiimi, kuid ei saa piiratud režiimi keelata.

      Kui selle seade väärtuseks on määratud Väljas või väärtust pole määratud, siis teenus <ph name="PRODUCT_NAME" /> piiratud režiimi YouTube'is ei jõusta. Välised eeskirjad (nt YouTube'i eeskirjad) võivad piiratud režiimi siiski jõustada.</translation>
<translation id="3428247105888806363">Luba võrgu prognoos</translation>
<translation id="3437924696598384725">Kasutajal VPN-ühenduste haldamise lubamine</translation>
<translation id="3449886121729668969">Seadistab brauseri <ph name="PRODUCT_NAME" /> puhverserveri seaded. Need puhverserveri seaded on saadaval ka ARC-rakenduste jaoks.

      See reegel ei ole veel kasutamiseks valmis, ärge kasutage seda.</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="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="3478024346823118645">Kustuta kasutaja andmed väljalogimisel</translation>
<translation id="348495353354674884">Luba virtuaalne klaviatuur</translation>
<translation id="3487623755010328395">
        Kui see reegel on määratud, üritab teenus <ph name="PRODUCT_NAME" /> end registreerida ja rakendada seotud pilvepõhised reeglid kõikidele profiilidele.

        Selle reegli väärtus on registreerimismärk, mille saab Google'i administraatorikonsoolilt.</translation>
<translation id="3496296378755072552">Paroolihaldur</translation>
<translation id="3502555714327823858">Kõigi dupleksrežiimide lubamine</translation>
<translation id="350443680860256679">ARC reegli seadistamine</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="350797926066071931">Luba Tõlge</translation>
<translation id="3512226956150568738">Kui kliendi seadme mudel toetas ARC-d juba enne seda, kui üleminek ext4-le oli ARC käitamiseks vajalik, ja kui reegli ArcEnabled väärtuseks on määratud Tõene, siis toimib see valik sarnaselt väärtusega AskUser (väärtus 3). Kõigil muudel juhtudel (kui seadme mudel varem ARC-d ei toetanud või kui reegli ArcEnabled väärtuseks on määratud Väär) on see väärtus võrdne väärtusega DisallowArc (väärtus 0).</translation>
<translation id="3524204464536655762">Ära luba ühelgi seadmel taotleda WebUSB API kaudu juurdepääsu USB-seadmetele</translation>
<translation id="3526752951628474302">Ainult mustvalge printimine</translation>
<translation id="3528000905991875314">Luba alternatiivsed vealehed</translation>
<translation id="3545457887306538845">Võimaldab teil juhtida, kus saab kasutada arendaja tööriistu.

      Kui reegel on seatud väärtusele „DeveloperToolsDisallowedForForceInstalledExtensions” (väärtus 0, mis on vaikeseade ettevõtte kasutajate puhul), on arendaja tööriistad ja JavaScripti konsool üldiselt juurdepääsetavad, ent nendele ei pääse juurde ettevõtte reegli alusel installitud laienduste kontekstis.
      Kui reegel on seatud väärtusele „DeveloperToolsAllowed” (väärtus 1), on arendaja tööriistad ja JavaScripti konsool juurdepääsetavad ja kasutamiseks saadaval igas kontekstis, sealhulgas ettevõtte reegli alusel installitud laienduste puhul.
      Kui reegel on seatud väärtusele „DeveloperToolsDisallowed” (väärtus 2), ei ole arendaja tööriistad saadaval ja veebisaitide elemente ei saa enam uurida. Kõik arendaja tööriistade või JavaScripti konsooli avamiseks kasutatavad klaviatuuri otseteed ning menüü- ja kontekstimenüükirjed keelatakse.</translation>
<translation id="3547954654003013442">Puhverserveri seaded</translation>
<translation id="3556806727696701427">Lubab rakenduse <ph name="PRODUCT_NAME" /> Google'i ohutu sirvimise funktsiooni ja takistab kasutajaid seda muutmast.

      Seade lubamisel on Google'i ohutu sirvimine alati aktiivne.

      Seade keelamisel on Google'i ohutu sirvimine alati inaktiivne.

      Seade lubamisel või keelamisel ei saa kasutajad seadet „Andmepüügi- ja pahavaravastase kaitse lubamine” rakenduses <ph name="PRODUCT_NAME" /> muuta ega alistada.

      Kui reeglit ei määrata, siis see lubatakse, kuid kasutaja saab seda muuta.

      Vaadake Google'i ohutu sirvimise kohta lisateavet: https://developers.google.com/safe-browsing.

      See reegel ei ole saadaval Windowsi eksemplarides, mis pole domeeniga <ph name="MS_AD_NAME" /> liitunud.</translation>
<translation id="3577251398714997599">Sekkuvate reklaamidega saitide reklaamiseaded</translation>
<translation id="3591584750136265240">Sisselogimise autentimise käitumise seadistamine</translation>
<translation id="3627678165642179114">Õigekirjakontrolli veebiteenuse lubamine või keelamine</translation>
<translation id="3628480121685794414">Simpleksprintimise lubamine</translation>
<translation id="3646859102161347133">Ekraaniluubi tüübi määramine</translation>
<translation id="3653237928288822292">Vaikeotsingupakkuja ikoon</translation>
<translation id="3660562134618097814">SAML IdP küpsisefailide ülekandmine sisselogimisel</translation>
<translation id="3702647575225525306"><ph name="POLICY_NAME" /> (Üherealist välja enam ei toetata ja tulevikus see eemaldatakse. Hakake kasutama allolevat mitmerealist tekstivälja.)</translation>
<translation id="3709266154059827597">Laienduste installimise musta nimekirja seadistamine</translation>
<translation id="3711895659073496551">Peata</translation>
<translation id="3715569262675717862">Kliendi sertifikaatidel põhinev autentimine</translation>
<translation id="3736879847913515635">Kasutajahalduris inimese lisamise lubamine</translation>
<translation id="3746590506846867985">
      See reegel kehtib sisselogimiskuval. Vaadake ka reeglit <ph name="ISOLATE_ORIGINS_POLICY_NAME" />, mis kehtib kasutajaseansi puhul. Soovitatav on mõlemale reeglile määrata sama väärtus. Kui väärtused ei ühti, võib kasutajareegliga määratud väärtuse rakendamisel esineda kasutajaseanssi sisenemisel viivitusi.
      Kui reegel on lubatud, käitab iga komadega eraldatud loendis nimetatud lähtekoht oma protsesse. See isoleerib ka alamdomeenide nimetatud lähtekohad; nt aadressi https://example.com/ määramisel isoleeritakse saidi https://example.com/ osana ka aadress https://foo.example.com/.
      Kui reegel on keelatud, ei toimu selget saidi isoleerimist ning reeglite
IsolateOrigins ja SitePerProcess testid keelatakse. Kasutajad saavad reegli IsolateOrigins siiski käsitsi lubada.
      Kui reegel on seadistamata, kasutatakse sisselogimiskuval platvormi saitide isoleerimise vaikeseadeid.
      </translation>
<translation id="3748900290998155147">Määrab, kas äratuslukud on lubatud. Äratuslukke saavad taotleda laiendused toitehalduse laienduse API kaudu ja ARC-rakendused.

          Kui reegel on määramata või seatud väärtusele Tõene, järgitakse toitehalduse puhul äratuslukke.

          Kui reegel on seatud väärtusele Väär, eiratakse äratuslukutaotlusi.</translation>
<translation id="3750220015372671395">Blokeeri võtmete loomine nendel saitidel</translation>
<translation id="3756011779061588474">Arendaja režiimi blokeerimine</translation>
<translation id="3758089716224084329">Võimaldab määrata rakenduse <ph name="PRODUCT_NAME" /> kasutatava puhverserveri ega lase kasutajatel puhverserveri seadeid muuta.

      Kui te ei soovi puhverserverit kasutada ja ühendus luuakse alati otse, siis eiratakse kõiki muid valikuid.

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

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

      Seade lubamisel eiravad <ph name="PRODUCT_NAME" /> ja ARC-rakendused 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="3758249152301468420">Keela arendaja tööriistad</translation>
<translation id="3764248359515129699">Keelab sertifikaadi läbipaistvuse nõuete jõustamise loendisse lisatud pärandsertimisorganite puhul.

      Reegel võimaldab keelata sertifikaadi läbipaistvuse avalikustamise nõude sertifikaadiahelate puhul, mis hõlmavad mõnd määratud subjectPublicKeyInfo räsiga sertifikaati. See lubab jätkata ettevõtte hostide puhul selliste sertifikaatide kasutamist, mida peetaks muidu ebausaldusväärseks, kuna need ei ole sobival moel avalikustatud.

      Selleks et reegli määramisel sertifikaatide läbipaistvuse jõustamine keelata, peab räsi olema seotud atribuudiga subjectPublicKeyInfo, mis sisaldub pärandsertimisorgani väljastatud CA-sertifikaadis. Pärandsertimisorgan on asutus, mida teenuse <ph name="PRODUCT_NAME" /> toetatav operatsioonisüsteem vaikimisi usaldab, ent mida Androidi avatud lähtekoodiga projekt või <ph name="PRODUCT_OS_NAME" /> ei usalda.

      Atribuudi subjectPublicKeyInfo räsi määramiseks liidetakse räsialgoritmi nimi, märk „/” ja räsialgoritmi Base64 kodeering, mis on rakendatud asjakohase sertifikaadi DER-kodeeringuga atribuudile. Base64 kodeering on samas vormingus mis SPKI sõrmejälg, nagu on määratud dokumendi RFC 7469 jaotises 2.4. Tundmatuid räsialgoritme eiratakse. Praegu toetatakse ainult räsialgoritmi „sha256”.

      Kui reegel on määramata, peetakse ebausaldusväärseks kõiki sertifikaate, mille puhul on sertifikaadi läbipaistvuse avalikustamine nõutav, ent millel puudub läbipaistvuse reeglit järgiv avalikustamine.</translation>
<translation id="3765260570442823273">Jõudeolekus väljalogimise hoiatussõnumi kestus</translation>
<translation id="377044054160169374">Ahistava kasutuskogemuse tõttu sekkumise jõustamine</translation>
<translation id="3780152581321609624">Kaasa Kerberose SPN-i mittestandardne port</translation>
<translation id="3780319008680229708">Kui reegli väärtuseks on määratud Tõene, siis on Cast'i tööriistariba ikoon tööriistaribal või ületäitemenüüs alati kuvatud ja kasutajad ei saa seda eemaldada.

          Kui reegli väärtuseks on määratud Väär või see on määramata, saavad kasutajad ikooni selle kontekstimenüü kaudu kinnitada või eemaldada.

          Kui reegli „EnableMediaRouter” väärtuseks on määratud Väär, siis pole selle reegli väärtusel mõju ja tööriistariba ikooni ei kuvata.</translation>
<translation id="3788662722837364290">Toitehalduse seaded, kui kasutaja on tegevusetu</translation>
<translation id="3790085888761753785">Kui seade on lubatud, saavad kasutajad Smart Lockiga oma kontole sisse logida. See on vähem range kui Smart Locki tavapärane käitumine, mille puhul on kasutajatel lubatud ainult ekraani avada.

      Kui seade on keelatud, ei ole Smart Locki abil sisselogimine kasutajate jaoks lubatud.

      Kui reegel jäetakse seadistamata, on see hallatavate kasutajate puhul vaikimisi keelatud ja haldamata kasutajate puhul lubatud.</translation>
<translation id="379602782757302612">Võimaldab määrata, milliseid laiendusi kasutajad EI saa installida. Juba installitud laiendused eemaldatakse, kui need lisatakse musta nimekirja, ja kasutaja ei saa neid lubada. Kui musta nimekirja kuulumise tõttu keelatud laiendus sealt eemaldatakse, lubatakse see automaatselt uuesti.

          Musta nimekirja väärtus * tähendab, et kõik laiendused on mustas nimekirjas, kui need ei ole selgelt määratud lubatud nimekirja.

          Kui see reegel jäetakse määramata, saab kasutaja teenuses <ph name="PRODUCT_NAME" /> installida mis tahes laienduse.</translation>
<translation id="3800626789999016379">Seadistab kataloogi, mida <ph name="PRODUCT_NAME" /> kasutab failide allalaadimiseks.

      Kui määrate selle reegli, kasutab <ph name="PRODUCT_NAME" /> kataloogi olenemata sellest, kas kasutaja on selle määranud või on lubanud märgistuse, mis küsib iga kord allalaadimise asukohta.

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

      Kui seda reeglit ei määrata, kasutatakse allalaadimise vaikekataloogi ja kasutaja saab seda muuta.</translation>
<translation id="3805659594028420438">Luba TLS-i domeenisuunaliste sertifikaatide laiendus (pakkumine on peatatud)</translation>
<translation id="3808945828600697669">Keelatud pistikprogrammide loendi määramine</translation>
<translation id="3811562426301733860">Luba reklaamid kõikidel saitidel</translation>
<translation id="3816312845600780067">Pääsu klaviatuuri otsetee lubamine automaatseks sisselogimiseks</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="382476126209906314">TalkGadgeti eesliite seadistamine kaugjuurdepääsu hostidele</translation>
<translation id="3831376478177535007">Kui see seade on lubatud, lubab teenus <ph name="PRODUCT_NAME" /> ettevõtte Symantec Corporation PKI pärandtoimingute väljastatud sertifikaate usaldada, kui need õnnestub valideerida ja tuvastatud CA-sertifikaadiga siduda.

      Arvestage sellega, et see reegel oleneb sellest, kas operatsioonisüsteem tuvastab Symanteci pärandtaristu sertifikaadid. Kui OS-i värskendus muudab selliste sertifikaatide käsitlemist OS-is, siis see reegel enam ei kehti. Lisaks on see reegel ajutine lahendus, et anda ettevõtetele rohkem aega Symanteci pärandsertifikaatide kasutamisest loobumiseks. See reegel eemaldatakse 2019. aasta 1. jaanuari paiku.

      Kui seda reeglit pole määratud või selle olekuks on määratud Väär, siis järgib teenus <ph name="PRODUCT_NAME" /> avalikult väljakuulutatud toe katkestamise ajakava.

      Toe katkestamise kohta leiate lisateavet saidilt https://g.co/chrome/symantecpkicerts.</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="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="3851039766298741586">Saadab teavet kioski aktiivse seansi kohta
      (nt rakenduse ID ja versioon).

      Kui selle reegli väärtuseks määratakse Väär, siis teavet seansi kohta ei
      saadeta. Kui väärtuseks määratakse Tõene või seda ei määrata, saadetakse
      teavet seansi kohta.</translation>
<translation id="3858658082795336534">Vaikimisi kasutatav printimise dupleksrežiim</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="3863409707075047163">Minimaalne lubatud SSL-i versioon</translation>
<translation id="3864020628639910082">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.

          Google'i soovituste URL-iks võib määrata: <ph name="GOOGLE_SUGGEST_SEARCH_URL" />

          Reegel on jõus vaid juhul, kui reegel „DefaultSearchProviderEnabled” on lubatud.</translation>
<translation id="3866249974567520381">Kirjeldus</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="3874773863217952418">Funktsiooni Puuduta otsimiseks lubamine</translation>
<translation id="3877517141460819966">Integreeritud kahe teguriga autentimise režiim</translation>
<translation id="3879208481373875102">Sundinstallitud veebirakenduste loendi seadistamine</translation>
<translation id="388237772682176890">Selle reegli tugi katkestatakse versioonis M53 ja see eemaldatakse versioonis M54, kuna SPDY/3.1 tugi eemaldatakse.

      Keelab SPDY-protokolli kasutamise rakenduses <ph name="PRODUCT_NAME" />.

      Reegli lubamisel ei ole SPDY-protokoll rakenduses <ph name="PRODUCT_NAME" /> saadaval.

      Reegli keelamisel on SPDY kasutamine lubatud.

      Kui jätate selle reegli määramata, on SPDY saadaval.</translation>
<translation id="3890999316834333174">Kiiravamise reeglid</translation>
<translation id="3891357445869647828">Luba JavaScript</translation>
<translation id="3895557476567727016">Seadistab vaikekataloogi, mida brauser <ph name="PRODUCT_NAME" /> kasutab failide allalaadimiseks.

      Selle reegli määramisel muudetakse vaikekataloogi, kuhu brauser <ph name="PRODUCT_NAME" /> failid alla laadib. See reegel ei ole kohustuslik, seega saab kasutaja kataloogi muuta.

      Kui te seda reeglit ei määra, kasutab brauser <ph name="PRODUCT_NAME" /> oma tavapärast kataloogi (platvormipõhine).

      Saidil https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables näete loendit kasutatavatest muutujatest.</translation>
<translation id="3904459740090265495">See reegel juhib brauserisse sisselogimise käitumist. See võimaldab teil määrata, kas kasutaja saab teenusesse <ph name="PRODUCT_NAME" /> oma kontoga sisse logida ja kasutada kontoga seotud teenuseid, nagu Chrome'i sünkroonimine.

      Kui reegli väärtuseks on määratud „Keela brauserisse sisselogimine”, siis ei saa kasutaja brauserisse sisse logida ega kasutada kontopõhiseid teenuseid. Sellisel juhul ei saa brauseri tasemel funktsioone (nt Chrome'i sünkroonimine) kasutada ja need pole saadaval. Kui kasutaja oli sisse logitud ja reegli väärtuseks määratakse „Keelatud”, logitakse ta Chrome'i järgmisel käivitamisel välja, kuid tema kohalikud profiili andmed (nt järjehoidjad, paroolid jm) jäävad alles. Kasutaja saab siiski sisse logida Google'i veebiteenustesse (nt Gmaili) ja neid kasutada.

      Kui reegli väärtuseks on määratud „Luba brauserisse sisselogimine”, siis saab kasutaja brauserisse sisse logida ja ta logitakse automaatselt brauserisse sisse, kui ta logib sisse mõnda Google'i veebiteenusesse (nt Gmaili). Kui kasutaja on brauserisse sisse logitud, siis salvestab brauser tema kontoteabe. See aga ei tähenda, et Chrome'i sünkroonimine vaikimisi sisse lülitatakse. Kasutaja peab selle funktsiooni kasutamise eraldi lubama. Selle reegli lubamisel ei saa kasutaja välja lülitada seadet, mis lubab brauserisse sisselogimise. Chrome'i sünkroonimise kättesaadavuse juhtimiseks kasutage reeglit „SyncDisabled”.

      Kui reegli väärtuseks on määratud „Brauserisse sisselogimise nõudmine”, siis kuvatakse kasutajale kontovaliku dialoog ja ta peab valima, millisele kontole brauseri kasutamiseks sisse logida. See tagab, et hallatud kontode puhul rakendatakse ja jõustatakse kontoga seotud reeglid. Vaikimisi lülitab see Chrome'i sünkroonimise sellel kontol sisse (v.a juhul, kui sünkroonimine on domeeni administraatori poolt või reegliga „SyncDisabled” välja lülitatud). Reegli BrowserGuestModeEnabled vaikeväärtuseks määratakse Väär. Pange tähele, et olemasolevad allkirjastamata profiilid lukustatakse ja nendele ei pääse pärast selle reegli lubamist juurde. Lisateabe saamiseks lugege abikeskuse artiklit: https://support.google.com/chrome/a/answer/7572556.

      Kui see reegel jäetakse määramata, siis saab kasutaja otsustada, kas soovib brauserisse sisselogimise valiku lubada, ja seda kasutada siis, kui ise soovib.</translation>
<translation id="3911737181201537215">See reegel ei mõjuta Androidi logimist.</translation>
<translation id="391531815696899618">Keelab Google Drive'i sünkroonimise operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> rakenduses Failid, kui väärtuse olekuks on määratud Tõene. Sellisel juhul ei laadita Google Drive'i üles mingeid andmeid.

          Kui reeglit pole määratud või reegli olekuks on määratud Väär, siis saavad kasutajad teisaldada faile teenusesse Google Drive.</translation>
<translation id="3915395663995367577">Puhverserveri pac-faili URL</translation>
<translation id="3925020515212192040">Määrab failide eelseadistatud võrgu-ühiskasutuse loendi.

      Reegli iga loendiüksus on objekt, mis koosneb, kahest liikmest: „share_url” ja „mode”. Parameeter „share_url” peab olema hoidla URL ja „mode” peab olema „drop_down”, mis näitab, et „share_url” lisatakse ühiskasutuse sirvimise rippmenüüsse.</translation>
<translation id="3939893074578116847">Võrgupaketid saadetakse veebioleku jälgimiseks haldusserverisse, et
      server saaks tuvastada, kui seade pole võrguga ühendatud.

      Kui selle reegli väärtuseks on määratud Tõene, saadetakse jälgitavad võrgupaketid (nn <ph name="HEARTBEATS_TERM" />).
      Kui väärtuseks on määratud Väär või reeglit ei määrata, siis pakette ei saadeta.</translation>
<translation id="3950239119790560549">Ajapiirangute värskendamine</translation>
<translation id="3958586912393694012">Smart Locki kasutamise lubamine</translation>
<translation id="3963602271515417124">Kui selle väärtuseks on määratud Tõene, on seadme kaugatesteerimine lubatud ning sertifikaat luuakse ja laaditakse seadmehaldusserverisse üles automaatselt.

          Kui selle väärtuseks on määratud Väär või kui väärtus on määramata, siis sertifikaati ei looda ja kõned üksuse enterprise.platformKeys laienduse API-le ebaõnnestuvad.</translation>
<translation id="3965339130942650562">Ajalõpp kuni jõudeolekus kasutaja väljalogimiseni</translation>
<translation id="3973371701361892765">Ära peida hoidlat kunagi automaatselt</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="3997519162482760140">URL-id, millele antakse SAML-i sisselogimislehtedel juurdepääs videosalvestusseadmetele</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="4008507541867797979">Kui reegel on määratud väärtusele Tõene või seadistamata, kuvab <ph name="PRODUCT_OS_NAME" /> olemasolevad kasutajad sisselogimiskuval ja võimaldab ühe neist valida.

      Kui reegel on määratud väärtusele Väär, ei kuva <ph name="PRODUCT_OS_NAME" /> sisselogimiskuval olemasolevaid kasutajaid. Kuvatakse tavapärane sisselogimisekraan (kus palutakse kasutajal sisestada e-posti aadress ja parool või telefoninumber) või SAML-i vaheekraan (kui see on reegliga <ph name="LOGIN_AUTHENTICATION_BEHAVIOR_POLICY_NAME" /> lubatud), v.a juhul, kui hallatud seanss on seadistatud. Kui hallatud seanss on seadistatud, kuvatakse ainult hallatud seansi kontod, mille hulgast saab valida soovitud konto.

      Pange tähele, et reegel ei mõjuta seda, kas seade salvestab kohaliku kasutaja andmed või loobub neist.</translation>
<translation id="4010738624545340900">Failivalimisdialoogide avamise lubamine</translation>
<translation id="4012737788880122133">Kui seade on määratud väärtusele Tõene, on automaatsed värskendused keelatud.

      Kui seade pole seadistatud või see on määratud väärtusele Väär, siis otsivad teenuse <ph name="PRODUCT_OS_NAME" /> seadmed värskendusi automaatselt.

      Hoiatus. Soovitame automaatsed värskendused lubada, et kasutajad saaksid tarkvaravärskendusi ja kriitilisi turvapaikasid. Automaatsete värskenduste väljalülitamine võib kasutajad ohtu seada.</translation>
<translation id="4020682745012723568">Androidi rakendused ei pääse juurde kasutajaprofiilile ülekantud küpsisefailidele.</translation>
<translation id="402759845255257575">Keela kõigil saitidel JavaScripti käitamine</translation>
<translation id="4027608872760987929">Luba vaikeotsingupakkuja</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="4056910949759281379">Keela SPDY-protokoll</translation>
<translation id="4059515172917655545">See reegel juhib Google'i asukohateenuste kättesaadavust.

      Kui reegel on seadistamata või seatud väärtusele <ph name="GLS_DISABLED" />, on Google'i asukohateenused keelatud ja kasutaja ei saa neid lubada.

      Kui reegel on seatud väärtusele <ph name="GLS_UNDER_USER_CONTROL" />, palutakse kasutajal valida, kas ta soovib Google'i asukohateenuseid kaustada. See võimaldab Androidi rakendustel kasutada teenuseid seadme asukoha päringu esitamiseks, samuti lubatakse anonüümsete asukohaandmete saatmine Google'ile.

      Pange tähele, et reeglit eiratakse ja asukohateenused on alati keelatud, kui reegel <ph name="DEFAULT_GEOLOCATION_SETTING_POLICY_NAME" /> on seatud väärtusele <ph name="BLOCK_GEOLOCATION_SETTING" />.</translation>
<translation id="408029843066770167">Google'i kellaajateenuses päringute lubamine</translation>
<translation id="408076456549153854">Brauserisse sisselogimise lubamine</translation>
<translation id="4088589230932595924">Inkognito režiim on jõustatud</translation>
<translation id="4088983553732356374">Võimaldab teil seadistada, kas veebisaitidel on lubatud määrata kohalikke andmeid. Kohalike andmete määramise saab lubada või keelata kõigi veebisaitide jaoks.

          Kui selle reegli väärtuseks määratakse „Säilita küpsisefailid seansi ajaks”, siis kustutatakse küpsisefailid seansi lõppedes. Pange tähele, et kui teenus <ph name="PRODUCT_NAME" /> töötab „taustarežiimis”, ei pruugi seanss viimase akna sulgemisel lõppeda. Lisateavet sellise toimimise seadistamise kohta leiate reeglist „BackgroundModeEnabled”.

          Kui seda reeglit pole määratud, kasutatakse reeglit „AllowCookies” ja kasutaja saab seda muuta.</translation>
<translation id="4103289232974211388">Pärast kasutaja kinnitust SAML IdP-le ümbersuunamine</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="4105989332710272578">Sertifikaadi läbipaistvuse jõustamise keelamine URL-ide loendi jaoks</translation>
<translation id="4121350739760194865">Rakenduste reklaamide ilmumise takistamine uuel vahelehel</translation>
<translation id="412697421478384751">Nõrkade lukustuskuva PIN-koodide määramise lubamine</translation>
<translation id="4138655880188755661">Ajapiirang</translation>
<translation id="4157003184375321727">OS-ist ja püsivara versioonist teavitamine</translation>
<translation id="4157594634940419685">CUPS-i omaprinteritele juurdepääsu lubamine</translation>
<translation id="4183229833636799228">Pistikprogrammi <ph name="FLASH_PLUGIN_NAME" /> vaikeseade</translation>
<translation id="4192388905594723944">URL kaugjuurdepääsuga kliendi autentimismärgi kinnitamiseks</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="4203879074082863035">Kasutajatele kuvatakse ainult lubatute loendis olevad printerid</translation>
<translation id="420512303455129789">Sõnastik, mis vastendab URL-id kahendmuutuja märgistusega ja määrab, kas hostile tuleb juurdepääs lubada (Tõene) või blokeerida (Väär).

          Reegel on mõeldud tootele <ph name="PRODUCT_NAME" /> sisekasutuseks.</translation>
<translation id="4224610387358583899">Ekraaniluku viivitused</translation>
<translation id="423797045246308574">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel ei ole lubatud võtmeid luua. Kui URL-i muster on loendis „KeygenAllowedForUrls”, alistab see reegel need erandid.

          Kui jätate reegli määramata, kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultKeygenSetting”, kui see on määratud, või kasutaja isiklikku seadistust.</translation>
<translation id="4239720644496144453">Androidi rakenduste jaoks vahemälu ei kasutata. Kui mitu kasutajat installivad sama Androidi rakenduse, laaditakse see iga kasutaja puhul uuena alla.</translation>
<translation id="4243336580717651045">Lubab URL-i võtmetega anonüümsete andmete kogumise rakenduses <ph name="PRODUCT_NAME" /> ja takistab kasutajatel seade muutmist.
      URL-i võtmetega anonüümsete andmete kogumisel saadetakse kasutaja külastatud lehtede URL-id Google'ile, et otsinguid ja sirvimist paremaks muuta.

      Kui selle reegli lubate, on URL-i võtmetega anonüümsete andmete kogumine alati aktiivne.

      Kui selle reegli keelate, ei ole URL-i võtmetega anonüümsete andmete kogumine mitte kunagi aktiivne.

      Kui jätate selle reegli määramata, on URL-i võtmetega anonüümsete andmete kogumine lubatud, kuid kasutaja saab seda muuta.</translation>
<translation id="4250680216510889253">Ei</translation>
<translation id="4261820385751181068">Seadme sisselogimisekraani lokaat</translation>
<translation id="427220754384423013">Määrab printerid, mida kasutaja saab kasutada.

      Seda reeglit kasutatakse ainult siis, kui režiimis <ph name="BULK_PRINTERS_ACCESS_MODE" /> on valitud väärtus <ph name="PRINTERS_WHITELIST" />.

      Selle reegli kasutamisel on kasutajale saadaval ainult printerid, mille ID-d ühtivad selles reeglis olevate väärtustega. ID-d peavad ühtima reeglis <ph name="BULK_PRINTERS_POLICY" /> määratud failis olevate väljadega „id” või „guid”.
      </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="4285674129118156176">Seoseta kasutajatel ARC kasutamise lubamine</translation>
<translation id="4298509794364745131">Määratakse loend rakendustest, mille saab operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> lukustuskuval lubada märkmete tegemise rakendustena.

      Kui eelistatud märkmete tegemise rakendus on lukustuskuval lubatud, sisaldab lukustuskuva kasutajaliidese elementi eelistatud märkmete tegemise rakenduse käivitamiseks.
      Rakendus saab käivitamisel lukustuskuva peale luua rakenduse akna ja lukustuskuva kontekstis luua andmeüksusi (märkmeid). Rakendus saab loodud märkmed importida peamise kasutaja seanssi, kui see avatakse. Praegu toetatakse lukustuskuval ainult Chrome'i märkmete tegemise rakendusi.

      Kui see reegel on määratud, saab kasutaja rakenduse lukustuskuval lubada ainult siis, kui rakenduse laienduse ID on reeglite loendis olevas väärtuses olemas.
      Seega, kui reegli väärtuseks määratakse tühi loend, keelatakse märkmete tegemine lukustuskuval täielikult.
      Pange tähele, et reegel, mis sisaldab rakenduse ID-d, ei tähenda alati seda, et kasutaja saab rakenduse lubada lukustuskuval märkmete tegemise rakendusena. Näiteks Chrome'i versioonis 61 on saadaolevate rakenduste kogumi täiendavalt piiranud ka platvorm.

      Kui reegel jäetakse määramata, puuduvad piirangud rakenduste kogumile, mille kasutaja saab lukustuskuval reegliga lubada.</translation>
<translation id="4309640770189628899">Näitab, kas DHE šifreerimiskomplektid on TLS-is lubatud</translation>
<translation id="4322842393287974810">Luba automaatselt käivitatud viivituseta kioskirakendusel juhtida operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> versiooni</translation>
<translation id="4325690621216251241">Lisa väljalogimisnupp süsteemisalve</translation>
<translation id="4332177773549877617">Androidi rakenduse installimiste logisündmused</translation>
<translation id="4346674324214534449">Võimaldab teil määrata, kas blokeerida reklaamid sekkuvate reklaamidega saitidel.

      Kui selle reegli väärtuseks on määratud 2, blokeeritakse reklaamid sekkuvate reklaamidega saitidel.
      Kui aga reegli SafeBrowsingEnabled väärtuseks on määratud Väär, siis sellist käitumist ei käivitata.
      Kui selle reegli väärtuseks on määratud 1, ei blokeerita reklaame sekkuvate reklaamidega saitidel.
      Kui see reegel jäetakse määramata, kasutatakse väärtust 2.</translation>
<translation id="4347908978527632940">Kui see on tõene ja kasutaja on jälgitav kasutaja, siis saavad teised Androidi rakendused sisupakkuja kaudu esitada päringuid kasutaja veebipiirangute kohta.

          Kui see on väär või määramata, siis ei saada sisupakkuja teavet.</translation>
<translation id="435461861920493948">Sisaldab loendit mustritest, mida kasutatakse teenuses <ph name="PRODUCT_NAME" /> kontode nähtavuse juhtimiseks.

      Igat seadmes olevat Google'i kontot võrreldakse selles reeglis salvestatud mustritega, et määrata konto nähtavus teenuses <ph name="PRODUCT_NAME" />. Konto on nähtav, kui selle nimi ühtib mõne loendis oleva mustriga. Muul juhul konto peidetakse.

      Metamärki „*” saab kasutada juhuslike tähemärkide vastendamiseks, mis võivad, aga ei pruugi esineda. Paomärk on „\”, seega märgi „*” või „\” vastendamiseks peate nende ette lisama märgi „\”.

      Kui see reegel jäetakse määramata, siis on kõik seadmes olevad Google'i kontod teenuses <ph name="PRODUCT_NAME" /> nähtavad.</translation>
<translation id="436581050240847513">Seadme võrguliidestest teatamine</translation>
<translation id="4372704773119750918">Ärge lubage ettevõtte kasutajal olla osa multiprofiilist (esmane või teisene)</translation>
<translation id="4377599627073874279">Luba kõikidel saitidel kõikide kujutiste kuvamine</translation>
<translation id="437791893267799639">Reegel on määramata, keela andmete üleviimine ja ARC</translation>
<translation id="4389091865841123886">Kaugatesteerimine konfigureeritakse TPM-mehhanismi abil.</translation>
<translation id="4408428864159735559">Failide eelseadistatud võrgu-ühiskasutuse loend.</translation>
<translation id="4410236409016356088">Võrgu ribalaiuse piiramise lubamine</translation>
<translation id="441217499641439905">Operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> rakenduses Failid Google Drive'i kasutamise keelamine mobiilsidevõrgu ühenduse korral</translation>
<translation id="4418726081189202489">Kui selle reegli väärtuseks määratakse Väär, peatatakse teenusest <ph name="PRODUCT_NAME" /> päringute saatmine Google'i serverile täpse ajatempli saamiseks. Need päringud lubatakse, kui reegli väärtuseks on määratud Tõene või see on määramata.</translation>
<translation id="4423597592074154136">Puhverserveri seadete määramine käsitsi</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="4432762137771104529">Ohutu sirvimise laiendatud aruandluse lubamine</translation>
<translation id="443454694385851356">Pärandversioon (ebaturvaline)</translation>
<translation id="443665821428652897">Kustuta saidi andmed brauseri sulgemisel (toetamine lõpetatud)</translation>
<translation id="4439336120285389675">Määrab loendi katkestatud toega veebiplatvormi funktsioonide kohta, mis tuleb ajutiselt uuesti lubada.

      See reegel võimaldab administraatoritel piiratud ajaks uuesti lubada katkestatud toega veebiplatvormide funktsioonid. Funktsioonid tuvastatakse stringimärgenditega ja märgenditele vastavad funktsioonid, mis on lisatud selle reegliga määratud loendisse, lubatakse uuesti.

      Kui seda reeglit ei määrata või on loend tühi ega ole vastavuses ühegi toetatud stringimärgendiga, siis jäävad kõik katkestatud toega veebiplatvormi funktsioonid keelatuks.

      Reegel on küll toetatud ülalnimetatud platvormidel, kuid lubatud funktsioon ei pruugi olla saadaval kõikidel platvormidel. Kõiki katkestatud toega veebiplatvormi funktsioone ei saa uuesti lubada. Piiratud ajaks saab lubada ainult allnimetatud funktsioone ja iga funktsiooni ajalimiit on erinev. Stringimärgendi üldine vorming on [DeprecatedFeatureName]_EffectiveUntil[yyyymmdd]. Veebiplatvormi funktsiooni muudatuste eesmärgi kohta leiate lisateavet aadressilt https://bit.ly/blinkintents.
      </translation>
<translation id="4442582539341804154">Luba lukustamine, kui seade on ootel või peatatud</translation>
<translation id="4449545651113180484">Ekraani pööramine 270 kraadi päripäeva</translation>
<translation id="4454820008017317557">Teenuse <ph name="PRODUCT_NAME" /> tööriistariba ikooni kuvamine</translation>
<translation id="4467952432486360968">Blokeeri kolmanda osapoole küpsised</translation>
<translation id="4474167089968829729">Luba paroolide salvestamine paroolihaldurisse</translation>
<translation id="4476769083125004742">Kui reegel on määratud seadele <ph name="BLOCK_GEOLOCATION_SETTING" />, ei pääse Androidi rakendused asukohateabele juurde. Kui määrate sellele reeglile mõne teise väärtuse või jätate selle määramata, küsitakse kasutaja nõusolekut, kui Androidi rakendus soovib asukohateabele juurde pääseda.</translation>
<translation id="4480694116501920047">Jõusta SafeSearchi kasutamine</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="4483649828988077221">Automaatse värskendamise keelamine</translation>
<translation id="4485425108474077672">Uue vahelehe URL-i seadistamine</translation>
<translation id="4492287494009043413">Keela ekraanipiltide tegemine</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="4508686775017063528">Kui reegli väärtuseks on määratud Tõene või see on määramata, on teenus <ph name="PRODUCT_NAME" /> lubatud ning kasutajad saavad selle käivitada rakenduse menüüst, lehe kontekstimenüüdest, meedia juhtelementidelt Cast'i toega veebisaitidel ja Cast'i tööriistariba ikoonil (kui see on kuvatud).

          Kui reegli väärtuseks on määratud Väär, siis on teenus <ph name="PRODUCT_NAME" /> keelatud.</translation>
<translation id="4515404363392014383">Ohutu sirvimise lubamine usaldusväärsete allikate puhul</translation>
<translation id="4518251772179446575">Küsi iga kord, kui sait tahab jälgida kasutajate füüsilist asukohta</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="4531706050939927436">Androidi rakendused saab Google'i administraatorikonsoolil Google Play kaudu sundinstallida. Need ei kasuta seda reeglit.</translation>
<translation id="4534500438517478692">Androidi piirangu nimi:</translation>
<translation id="4541530620466526913">Seadmepõhised kontod</translation>
<translation id="4544079461524242527">Seadistab rakenduse <ph name="PRODUCT_NAME" /> laiendite haldamise seaded.

          Reegel juhib mitut seadet, sealhulgas seadeid, mida juhivad olemasolevad laiendustega seotud reeglid. Reegel alistab kõik pärandreeglid, kui mõlemad on määratud.

          Reegel vastendab laienduse ID või värskenduse URL-i seadistusega. Laienduse ID-ga rakendatakse seadistus ainult määratud laiendusele. Spetsiaalse ID <ph name="DEFAULT_SCOPE" /> jaoks saab määrata vaikeseadistuse, mis kehtib kõikide laienduste puhul, millele ei ole reeglis määratud kohandatud seadistust. Värskenduse URL-iga rakendatakse seadistus kõikidele laiendustele, mille täpne värskenduse URL on märgitud laienduse manifesti, nagu on kirjeldatud jaotises <ph name="LINK_TO_EXTENSION_DOC1" />.

          Vaadake reegli võimalike seadete ja struktuuri täielikku kirjeldust https://www.chromium.org/administrators/policy-list-3/extension-settings-full
          </translation>
<translation id="4554651132977135445">Kasutajareeglite tagastusliidese töötlemisrežiim</translation>
<translation id="4554841826517980623">Reegel määrab, kas teenuse <ph name="PRODUCT_NAME" /> failide võrguhoidlate funktsioon peab võrguhoidlate tuvastamiseks kasutama protokolli <ph name="NETBIOS_PROTOCOL" />.
      Kui reegel on seatud väärtusele Tõene, kasutab hoidlate tuvastamise funktsioon võrgus hoidlate tuvastamiseks protokolli <ph name="NETBIOS_PROTOCOL" />.
      Kui reegel on seatud väärtusele Väär, ei kasuta hoidlate tuvastamise funktsioon hoidlate tuvastamiseks protokolli <ph name="NETBIOS_PROTOCOL" />.
      Kui reegel jäetakse seadistamata, on seade ettevõtte hallatavate kasutajate puhul vaikimisi keelatud ja haldamata kasutajate puhul lubatud.</translation>
<translation id="4555850956567117258">Kasutajale kaugatesteerimise lubamine</translation>
<translation id="4557134566541205630">Otsingupakkuja uue vahelehe vaike-URL</translation>
<translation id="4567137030726189378">Arendaja tööriistade kasutamise lubamine</translation>
<translation id="4600786265870346112">Suure kursori lubamine</translation>
<translation id="4604931264910482931">Omasõnumside musta nimekirja seadistamine</translation>
<translation id="4613508646038788144">Kui reegel on määratud väärtusele Väär, on kolmanda osapoole tarkvaral lubatud sisestada Chrome'i protsessidesse täitmiskoodi. Kui reegel on määramata või seatud väärtusele Tõene, on kolmandal osapoolel keelatud täitmiskoodi Chrome'i protsessidesse sisestada.</translation>
<translation id="4617338332148204752">Metasildi kontrollimise vahelejätmine teenuses <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="4625915093043961294">Installimiseks lubatud laienduste loendi seadistamine</translation>
<translation id="4632343302005518762">Pistikprogrammil <ph name="PRODUCT_FRAME_NAME" /> loetletud sisutüüpide töötlemise lubamine</translation>
<translation id="4632566332417930481">Ettevõtte reegli alusel installitud laiendustes arendaja tööriistade kasutamise keelamine, arendaja tööriistade kasutamise lubamine muus kontekstis</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="4639407427807680016">Omasõnumside hostide nimed mustast nimekirjast välistamiseks</translation>
<translation id="4650759511838826572">Keela URL-i protokolli skeemid</translation>
<translation id="465099050592230505">Ettevõtte veebipoe URL (tugi on katkestatud)</translation>
<translation id="4665897631924472251">Laienduse haldamise seaded</translation>
<translation id="4668325077104657568">Kujutiste vaikeseaded</translation>
<translation id="4671708336564240458">Võimaldab määrata, kas ahistava kasutuskogemusega saitide avamist uues aknas või vahekaardil tuleks takistada.

      Kui reegel on seatud väärtusele Tõene, takistatakse ahistava kasutuskogemusega saitide avamist uues aknas või vahekaardil.
      Seda käitumist ei käivitata juhul, kui reegel SafeBrowsingEnabled on seatud väärtusele Väär.
      Kui reegel on seatud väärtusele Väär, on ahistava kasutuskogemusega saitide avamine uues aknas või vahekaardil lubatud.
      Kui reegel jäetakse määramata, kasutatakse väärtust Tõene.</translation>
<translation id="467236746355332046">Toetatud funktsioonid:</translation>
<translation id="4674167212832291997">Kohandab loendit URL-i mustritest, mida renderdatakse alati rakendusega <ph name="PRODUCT_FRAME_NAME" />.

          Kui jätate selle reegli määramata, 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="467449052039111439">Ava URL-ide loend</translation>
<translation id="4680936297850947973">Versioonis M68 on tugi katkestatud. Kasutage selle asemel reeglit DefaultPopupsSetting.

      Vaadake täielikku selgitust aadressilt https://www.chromestatus.com/features/5675755719622656.
      Kui reegel on lubatud, tohivad saidid samal ajal navigeerida ja uusi aknaid/vahelehti avada.
      Kui reegel on keelatud või määramata, ei ole saitidel lubatud samal ajal navigeerida ja uusi aknaid/vahelehti avada.</translation>
<translation id="4680961954980851756">Luba automaatne täitmine</translation>
<translation id="4703402283970867140">Nutika hämardamismudeli lubamine, et pikendada ekraani hämardamise viiteaega</translation>
<translation id="4722122254122249791">Saidi isoleerimise lubamine konkreetsete lähtekohtade puhul</translation>
<translation id="4722399051042571387">Kui see on vale, ei saa kasutajad määrata PIN-koode, mis on nõrgad ja hõlpsalt äraarvatavad.

          Mõned nõrga PIN-koodi näited: PIN-koodid, mis sisaldavad ainult ühte numbrit (1111); PIN-koodid, milles olevad numbrid suurenevad ühe võrra (1234); PIN-koodid, milles olevad numbrid vähenevad ühe võrra (4321); sageli kasutatavad PIN-koodid.

          Vaikimisi kuvatakse kasutajatele nõrga PIN-koodi korral hoiatus, mitte veateade.</translation>
<translation id="4723829699367336876">Luba tulemüüri läbimine kaugjuurdepääsu kliendist</translation>
<translation id="4725528134735324213">Androidi varundusteenuse lubamine</translation>
<translation id="4725801978265372736">Kohaliku kasutaja ja kaugjuurdepääsuhosti omaniku nimede ühtimise nõudmine</translation>
<translation id="4733471537137819387">Integreeritud HTTP autentimisega seotud reeglid</translation>
<translation id="4744190513568488164">Serverid, kuhu toode <ph name="PRODUCT_NAME" /> võib delegeerida.

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

          Kui jätate selle reegli määramata, ei delegeeri <ph name="PRODUCT_NAME" /> kasutaja mandaate isegi siis, kui server tuvastatakse intranetis olevana.</translation>
<translation id="4752880493649142945">Kliendi sertifikaat ühendamiseks reegliga RemoteAccessHostTokenValidationUrl</translation>
<translation id="4757671984625088193">Kui reegel on määramata või seatud väärtusele Tõene, soovitab teenus <ph name="PRODUCT_NAME" /> praeguse lehega seotud lehti.
      Need soovitused tuuakse kaugühenduse kaudu Google'i serveritest.

      Kui reegel on seatud väärtusele Väär, siis soovitusi ei tooda ega kuvata.</translation>
<translation id="4788252609789586009">Lubab rakenduse <ph name="PRODUCT_NAME" /> automaattäite funktsiooni ja võimaldab kasutajatel veebivormidel krediitkaardiandmeid automaatselt täita, kasutades selleks varem salvestatud teavet.

      Kui seade on keelatud, ei anna automaattäite funktsioon krediitkaardiandmete kohta soovitusi ega sisesta neid. Samuti ei salvesta see krediitkaardi lisateavet, mille kasutaja võib veebi sirvimisel esitada.

      Kui seade on lubatud või sellel puudub väärtus, saab kasutaja kasutajaliideses juhtida krediitkaardiandmete automaattäite funktsiooni.</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="4802905909524200151">Üksuse <ph name="TPM_FIRMWARE_UPDATE_TPM" /> püsivaravärskenduse käitumise seadistamine</translation>
<translation id="4807950475297505572">Kõige kauem aega tagasi kasutanud kasutajad eemaldatakse, kuni on piisavalt vaba ruumi</translation>
<translation id="4815725774537609998">Reegel on iganenud, kasutage selle asemel reeglit ProxyMode.

          Võimaldab määrata rakenduses <ph name="PRODUCT_NAME" /> kasutatava puhverserveri ega lase kasutajatel puhverserveri seadeid muuta.

          Kui otsustate puhverserverit mitte kasutada ja alati otse ühenduse luua, eiratakse kõiki muid valikuid.

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

          Kui valite puhverserveri seaded käsitsi, saate määrata täpsemad valikud jaotistes „Puhverserveri aadress või URL”, „Puhverserveri PAC-faili URL” ja „Puhverserverist möödumise reeglite komaeraldusega loend”. ARC-rakenduste jaoks on saadaval ainult prioriteetne HTTP-puhverserver.

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

          Kui lubate selle seade, eirab <ph name="PRODUCT_NAME" /> kõiki käsureal määratud puhverserveriga seotud valikuid.

          Kui jätate reegli määramata, saavad kasutajad ise puhverserveri seadeid määrata.</translation>
<translation id="4816674326202173458">Luba ettevõtte kasutajal olla nii peamine kui ka teisene kasutaja (vaikekäitumine haldamata kasutajate puhul)</translation>
<translation id="4826326557828204741">Toiming, mis rakendub siis, kui tegevusetuse viivitusaeg saab täis akutoite kasutamise ajal</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="4858735034935305895">Täisekraanrežiimi lubamine</translation>
<translation id="4861767323695239729">Kasutajaseansis lubatud sisestusmeetodite seadistamine</translation>
<translation id="487460824085252184">Üleviimine toimub automaatselt, kasutaja nõusolekut ei küsita.</translation>
<translation id="4874982543810021567">Reegli WebUSB blokeerimine nendel saitidel</translation>
<translation id="4876805738539874299">Maksimaalne lubatud SSL-i versioon</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="489803897780524242">Parameeter, mis juhib otsingutermini paigutust vaikeotsingupakkuja puhul</translation>
<translation id="4899708173828500852">Luba ohutu sirvimine</translation>
<translation id="4899802251198446659">Võimaldab teil juhtida, kas videoid saab teenuses <ph name="PRODUCT_NAME" /> automaatselt (ilma kasutaja nõusolekuta) koos helisisuga esitada

      Kui reegel on määratud väärtusele Tõene, lubatakse teenuses <ph name="PRODUCT_NAME" /> meedia automaatesitus.
      Kui reegel on määratud väärtusele Väär, ei lubata teenuses <ph name="PRODUCT_NAME" /> meedia automaatesitust. Reegel AutoplayWhitelist võimaldab selle teatud URL-i mustrite puhul alistada.
      Vaikimisi ei lubata teenuses <ph name="PRODUCT_NAME" /> meedia automaatesitust. Reegel AutoplayWhitelist võimaldab selle teatud URL-i mustrite puhul alistada.

      Pange tähele, et kui teenus <ph name="PRODUCT_NAME" /> töötab ja seda reeglit muudetakse, rakendatakse see ainult uutel avatud vahelehtedel. Seetõttu võite mõnel vahelehel siiski märgata eelmist käitumismustrit.
      </translation>
<translation id="4906194810004762807">Seadme reeglite värskendussagedus</translation>
<translation id="4917385247580444890">Tugev</translation>
<translation id="4923806312383904642">Reeglil WebDriver ühildumatute reeglite alistamise lubamine</translation>
<translation id="494613465159630803">Cast'i vastuvõtja</translation>
<translation id="4962262530309732070">Kui selle reegli väärtuseks määratakse Tõene või seda ei seadistata, lubab teenus <ph name="PRODUCT_NAME" /> kasutajahalduris funktsiooni Inimese lisamine.


      Kui selle reegli väärtuseks määratakse Väär, ei luba teenus <ph name="PRODUCT_NAME" /> kasutajahalduris uusi profiile luua.</translation>
<translation id="4970855112942626932">Brauserisse sisselogimise keelamine</translation>
<translation id="4971529314808359013">Võimaldab määrata URL-i mustrite loendi, mis täpsustab saidid, millele teenus <ph name="PRODUCT_NAME" /> peaks automaatselt valima kliendi sertifikaadi, kui sait sertifikaati taotleb.

          Väärtus peab olema rida stringideks jaotatud JSON-i sõnastikke. Igas sõnastikus peab olema vorm { "pattern": "$URL_PATTERN", "filter" : $FILTER }, kus $URL_PATTERN on sisuseadete muster. $FILTER piirab seda, milliste kliendisertifikaatide hulgast brauser automaatselt valib. Olenemata filtrist, valitakse ainult sertifikaadid, mis ühtivad serveri sertifikaadi taotlusega. Kui $FILTER on vormis { "ISSUER": { "CN": "$ISSUER_CN" } }, valitakse lisaks ainult kliendisertifikaadid, mille on väljastanud sertifikaat mustriga CommonName $ISSUER_CN. Kui $FILTER on tühi sõnastik {}, ei ole kliendisertifikaatide valik täiendavalt piiratud.

          Kui seda reeglit ei määrata, ei tehta ühegi saidi puhul automaatset valikut.</translation>
<translation id="4978405676361550165">Kui reegel „OffHours” on määratud, siis eiratakse määratud ajavahemikes seadmereegleid (kasutage nende reeglite vaikeseadeid). Chrome rakendab seadmereegleid uuesti iga sündmuse puhul, kui ajavahemik „OffHours” algab või lõpeb. Kui ajavahemik „OffHours” lõpeb ja seadmereeglite seadeid muudetakse, teavitatakse sellest kasutajat ning ta logitakse välja (näiteks kui kasutaja pole sisse logitud lubatud kontoga).</translation>
<translation id="4980635395568992380">Andmetüüp:</translation>
<translation id="4983201894483989687">Luba vananenud pistikprogrammide käitamine</translation>
<translation id="4988291787868618635">Tehtav toiming, kui möödub jõudeoleku viiteaeg</translation>
<translation id="4995548127349206948">Kas NTLMv2 autentimine on lubatud või mitte.</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="5056708224511062314">Ekraaniluup on keelatud</translation>
<translation id="5058573563327660283">Automaatse puhastamise ajal kettaruumi vabastamiseks kasutatava strateegia valimine (tugi on katkestatud)</translation>
<translation id="5067143124345820993">Kasutajate sisselogimise lubatud loend</translation>
<translation id="5068140065960598044">Teenuse <ph name="PRODUCT_NAME" /> pilve-eeskirjad alistavad seadme-eeskirjad.</translation>
<translation id="5085647276663819155">Printimise eelvaate keelamine</translation>
<translation id="5090209345759901501">Flash-sisu seade laiendamine kogu sisule</translation>
<translation id="5093540029655764852">Määrab sageduse (päevades), kui tihti klient seadme konto parooli muudab. Klient loob parooli juhuslikult ja see pole kasutajale nähtav.

      Sarnaselt kasutaja paroolidele tuleb seadme paroole regulaarselt muuta. Kui see reegel keelatakse või määratakse suur päevade arv, võib see turvalisusele negatiivselt mõjuda, kuna see annab võimalikele ründajatele rohkem aega seadme konto parool välja uurida ja seda kasutada.

      Kui reegel on määramata, muudetakse seadme konto parooli iga 30 päeva järel.

      Kui reegli väärtuseks on määratud 0, on seadme konto parooli muutmine keelatud.

      Pange tähele, et paroolid võivad saada vanemaks kui määratud päevade arv, kui klient on pikemat aega võrgust väljas olnud.</translation>
<translation id="5105313908130842249">Ekraani lukustamise viiteaeg akutoite kasutamisel</translation>
<translation id="5108031557082757679">Ettevõtte seadmete jaoks keelatud printerid</translation>
<translation id="5130288486815037971">Kas RC4 šifreerimiskomplektid TLS-is on lubatud?</translation>
<translation id="5141670636904227950">Lubage ekraaniluubi vaiketüüp sisselogimisekraanil</translation>
<translation id="5142301680741828703">Renderda alati rakenduses <ph name="PRODUCT_FRAME_NAME" /> järgmiste URL-ide mustrid</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="5159469559091666409">Jälgitavate võrgupakettide saatmise sagedus (millisekundites).

      Kui see reegel on määramata, on vaikeintervall kolm minutit. Minimaalne
      intervall on 30 sekundit ja maksimaalne intervall on 24 tundi – vahemikust
      väljapoole jäävad väärtused surutakse sellesse vahemikku.</translation>
<translation id="5163002264923337812">Vana veebipõhise sisselogimisvoo lubamine</translation>
<translation id="5182055907976889880">Google Drive'i seadistamine teenuses <ph name="PRODUCT_OS_NAME" />.</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="519247340330463721">Ohutu sirvimisega seotud reeglite seadistamine.</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="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="520403427390290017">Vahelehe elutsüklite funktsioon vabastab protsessoriressursid ja lõpuks ka mäluressursid, mis on seotud töötavate vahelehtedega, mida ei ole kaua kasutatud. Selleks piiratakse esmalt vahelehtede ressursikasutust, seejärel vahelehed külmutatakse ja lõpuks eemaldatakse.

      Kui reegel on seatud väärtusele Väär, on vahelehtede elutsüklid keelatud ja kõik vahelehed töötavad tavapärasel moel.

      Kui reegel on seatud väärtusele Tõene või jäetud määramata, on vahelehtede elutsüklid lubatud.</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="5219844027738217407">Androidi rakenduste puhul mõjutab see reegel ainult mikrofoni. Kui reegli väärtuseks on määratud Tõene, on mikrofon ilma eranditeta kõigi Androidi rakenduste puhul vaigistatud.</translation>
<translation id="5228316810085661003">Seadme kohaliku konto automaatse sisselogimise viivitus.

      Kui reegel |DeviceLocalAccountAutoLoginId| on määramata, ei ole sellel reeglil mingit mõju. Muidu on mõju järgmine.

      Kui reegel on määratud, määrab see kasutaja tegevusetuse aja, mille möödudes logitakse automaatselt sisse reegliga |DeviceLocalAccountAutoLoginId| määratud seadme kohalikule kontole.

      Kui reegel on määramata, kasutatakse ajalõpu väärtust 0 millisekundit.

      Reegel määratakse millisekundites.</translation>
<translation id="523505283826916779">Juurdepääsuseaded</translation>
<translation id="5247006254130721952">Blokeeri ohtlikud allalaadimised</translation>
<translation id="5248863213023520115">Määrab krüpteerimistüübid, mis lubatakse, kui teenuse <ph name="MS_AD_NAME" /> serverist taotletakse Kerberose pileteid.

      Kui reegli väärtuseks on määratud „All”, on lubatud nii AES-krüpteeringutüübid „aes256-cts-hmac-sha1-96” ja „aes128-cts-hmac-sha1-96” kui ka RC4-krüpteeringutüüp „rc4-hmac”. Kui server toetab mõlemat tüüpi, eelistatakse AES-küpteeringut. Pange tähele, et RC4 peetakse nõrgaks ja server tuleks võimaluse korral ümber seadistada, et see toetaks AES-krüpteeringut.

      Kui reegli väärtuseks määratakse „Strong” või see jäetakse määramata, on lubatud ainult AES-krüpteeringutüübid.

      Kui reegli väärtuseks määratakse „Legacy”, on lubatud ainult RC4-krüpteeringutüüp. See valik on ebaturvaline ja seda tuleks kasutada ainult erandjuhtudel.

      Lisateave: https://wiki.samba.org/index.php/Samba_4.6_Features_added/changed#Kerberos_client_encryption_types.</translation>
<translation id="5255162913209987122">Võib soovitada</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="5272684451155669299">Kui selle väärtuseks on määratud Tõene, saab kasutaja kasutada Chrome'i seadmete riistvara, et tõendada enda isikut distantsilt privaatsuse CA abil API <ph name="ENTERPRISE_PLATFORM_KEYS_API" /> kaudu, kasutades funktsiooni <ph name="CHALLENGE_USER_KEY_FUNCTION" />.

          Kui selle väärtuseks on määratud Väär või väärtus on määramata, siis kõned API-le ebaõnnestuvad ja saate vastuseks veakoodi.</translation>
<translation id="5277806246014825877">Lubab sellel kasutajal Crostinit käitada.

      Kui reegel on seatud väärtusele Väär, ei ole Crostini kasutaja jaoks lubatud.
      Kui reegel on määramata või seatud väärtusele Tõene, on Crostini kasutaja jaoks lubatud eeldusel, et muud seaded seda lubavad.
      Kõik kolm reeglit – VirtualMachinesAllowed, CrostiniAllowed ja DeviceUnaffiliatedCrostiniAllowed – peavad olema tõesed, et Crostini käitamine oleks lubatud.
      Kui reegel seatakse väärtusele Väär, kehtib see uute Crostini ümbriste käitamise puhul, ent ei lülita välja juba käivitatud ümbriseid.</translation>
<translation id="5283457834853986457">Pistikprogrammide leidja keelamine (tugi on katkestatud)</translation>
<translation id="5288772341821359899">Kui reegel on määratud, piiratakse WebRTC kasutatava UDP-pordi vahemikku määratud pordi intervalliga (sh lõpp-punktid).

      Kui reeglit ei ole määratud või kui see on määratud tühjale stringile või kehtetule pordivahemikule, on WebRTC-l lubatud kasutada mis tahes saadaolevat kohalikku UDP-porti.</translation>
<translation id="5290940294294002042">Määrake pistikprogrammide loend, mida kasutaja saab lubada või keelata</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="5307432759655324440">Inkognito režiimi saadavus</translation>
<translation id="5318185076587284965">Luba kaugjuurdepääsuhostil kasutada releeservereid</translation>
<translation id="5323128137188992869">Sisu lubatakse teenuse <ph name="PRODUCT_NAME" /> kaudu seadmesse üle kanda.

          Kui selle reegli väärtuseks on määratud Väär, ei saa kasutajad sisu oma seadmesse üle kanda. Kui selle reegli väärtuseks on määratud Tõene, lubatakse kasutajatel sisu üle kanda. Kui see reegel jäetakse määramata, ei lubata kasutajatel sisu registreeritud Chrome OS-i seadmetesse üle kanda, kuid registreerimata seadmete puhul saab seda teha.</translation>
<translation id="5329007337159326804">Hoiatus. Maksimaalse TLS-i versiooni reegel eemaldatakse rakendusest <ph name="PRODUCT_NAME" /> täielikult versioonis 72 (umbes juunis 2019).

      Kui see reegel on seadistamata, kasutab rakendus <ph name="PRODUCT_NAME" /> vaikemaksimumversiooni.

      Muul juhul võidakse määrata üks järgmistest väärtustest: „tls1.2” või „tls1.3”. Kui see on määratud, ei kasuta rakendus <ph name="PRODUCT_NAME" /> määratud versioonist uuemaid SSL-i/TLS-i versioone. Tuvastamatut väärtust eiratakse.</translation>
<translation id="5330684698007383292">Pistikprogrammil <ph name="PRODUCT_FRAME_NAME" /> järgmiste sisutüüpide töötlemise lubamine</translation>
<translation id="5365946944967967336">Kuva tööriistaribal nuppu Avaleht</translation>
<translation id="5366745336748853475">Võimaldab määrata URL-i mustrite loendi, mis täpsustab saidid, mille jaoks valitakse sisselogimisekraanil SAML-voogu hostivas raamis automaatselt kliendisertifikaat, kui sait nõuab sertifikaati. Näidiskasutus on seadistada seadmeülene sertifikaat, mis esitatakse SAML IdP-le.

      Väärtus peab olema rida stringideks jaotatud JSON-i sõnastikke. Igas sõnastikus peab olema vorm { "pattern": "$URL_PATTERN", "filter" : $FILTER }, kus $URL_PATTERN on sisuseadete muster. $FILTER piirab seda, milliste kliendisertifikaatide hulgast brauser automaatselt valib. Olenemata filtrist, valitakse ainult sertifikaadid, mis ühtivad serveri sertifikaadi taotlusega. Kui $FILTER on vormis { "ISSUER": { "CN": "$ISSUER_CN" } }, valitakse lisaks ainult kliendisertifikaadid, mille on väljastanud sertifikaat mustriga CommonName $ISSUER_CN. Kui $FILTER on tühi sõnastik {}, ei ole kliendisertifikaatide valik täiendavalt piiratud.

      Kui seda reeglit ei määrata, ei tehta ühegi saidi puhul automaatset valikut.</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="5369937289900051171">Ainult värviline printimine</translation>
<translation id="5370279767682621504">HTTP/0.9 toe lubamine mittevaikeportide puhul</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="538108065117008131">Teenusel <ph name="PRODUCT_FRAME_NAME" /> järgmist tüüpi sisu käsitsemise lubamine.</translation>
<translation id="5391388690191341203">Automaatsel sisselogimisel kasutatav seadme kohalik konto</translation>
<translation id="5392172595902933844">Androidi olekuteave saadetakse tagasi
      serverisse.

      Kui reegel on määratud väärtusele Väär või see on määramata, siis olekuteavet ei edastata.
      Kui reegel on määratud väärtusele Tõene, esitatakse olekuteavet.

      See reegel kehtib ainult juhul, kui Androidi rakendused on lubatud.</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="5396049152026347991">Lubab kasutajal VPN-ühendusi hallata.

      Kui reegel on seatud väärtusele Väär, keelatakse kõik rakenduse <ph name="PRODUCT_NAME" /> kasutajaliidesed, mis võimaldavad kasutajal VPN-ühendusi katkestada või muuta.

      Kui reegel jäetakse määramata või seatakse väärtusele Tõene, saavad kasutajad VPN-ühendusi tavapärasel moel katkestada ja muuta.

      Kui VPN-ühendus luuakse VPN-i rakenduse kaudu, ei mõjuta reegel rakenduses olevat kasutajaliidest. Seetõttu saab kasutaja rakenduse kaudu võib-olla VPN-ühendust muuta.

      Reegel on mõeldud koos kasutamiseks funktsiooniga „Alati sees VPN”, mis võimaldab administraatoril lubada käivitamisel VPN-ühenduse loomise.</translation>
<translation id="5405289061476885481">Seadistab, millised klaviatuuripaigutused on operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> sisselogimisekraanil lubatud.

      Kui see reegel on määratud sisestusmeetodi identifikaatorite loendile, on antud sisestusmeetodid sisselogimisekraanil saadaval. Esimene antud sisestusmeetod on eelnevalt valitud. Kui kasutajate kogum on sisselogimisekraanil fokuseeritud, on lisaks reegliga määratud sisestusmeetoditele saadaval ka kasutaja kõige viimasena kasutatud sisestusmeetod. Kui see reegel on määramata, tuletatakse sisselogimisekraanil saadaolevad sisestusmeetodid lokaadist, milles sisselogimisekraan kuvatakse. Väärtusi, mis pole kehtivad sisestusmeetodi identifikaatorid, eiratakse.</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="5423197884968724595">Android WebView' piirangu nimi:</translation>
<translation id="5424147596523390018">Kõigi värvirežiimide lubamine</translation>
<translation id="5442026853063570579">See reegel haldab ka juurdepääsu Androidi arendaja valikutele. Kui määrate reegli väärtuseks „DeveloperToolsDisallowed” (väärtus 2), ei pääse kasutajad arendaja valikutele juurde. Kui määrate reeglile muu väärtuse või jätate selle määramata, pääsevad kasutajad arendaja valikutele juurde, puudutades rakenduses Androidi seaded seitse korda järgunumbrit.</translation>
<translation id="5447306928176905178">Mäluteabe (JS kuhja maht) aruandluse lubamine lehele (iganenud)</translation>
<translation id="5457065417344056871">Külalisrežiimi lubamine brauseris</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="5464816904705580310">Hallatud kasutajate seadete konfigureerimine.</translation>
<translation id="546726650689747237">Ekraani hämardamise viiteaeg võrgutoite kasutamisel</translation>
<translation id="5469143988693423708">Kasutajal on lubatud Crostinit käitada</translation>
<translation id="5469825884154817306">Blokeeri kujutised nendel saitidel</translation>
<translation id="5475361623548884387">Luba printimine</translation>
<translation id="547601067149622666">Ära luba sekkuvate reklaamidega saitidel reklaame</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="5511702823008968136">Luba järjehoidjariba</translation>
<translation id="5512418063782665071">Avalehe URL</translation>
<translation id="551639594034811656">See reegel määrab loendi protsentidest, mis sätestavad OU operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> seadmete murdosa, mida alates värskenduse leidmisest kord nädalas värskendatakse. Avastamisaeg on hilisem kui värskenduse avaldamise aeg, kuna pärast värskenduse avaldamist võib seadmel kuluda värskenduste otsimiseks pisut aega.

      Iga paar (päev, protsent) määrab, milline protsent seadetest tuleb värskendada määratud päevade arvu jooksul pärast värskenduse leidmist. Näiteks paaride {(4, 40), (10, 70), (15, 100)] puhul peab 40% seadmetest olema värskendatud 4 päeva jooksul pärast värskenduse leidmist, 70% 10 päeva jooksul jne.

      Kui reegli väärtus on määratud, eiravad värskendused reeglit <ph name="DEVICE_UPDATE_SCATTER_FACTOR_POLICY_NAME" /> ja järgivad selle asemel seda reeglit.

      Kui loend on tühi, siis kontrollimist ei kasutata ja värskendused rakendatakse seadme muude eeskirjade alusel.

      Reegel ei kehti kanalivahetuste puhul.</translation>
<translation id="5526701598901867718">Kõik (ebaturvaline)</translation>
<translation id="5529037166721644841">Määrab perioodi millisekundites, mille jooksul seadme haldusteenusele esitatakse päring kasutajareegli teabe hankimiseks.

      Selle reegli määramisel alistatakse vaikeväärtus 3 tundi. Selle reegli kehtivad väärtused jäävad vahemikku 1 800 000 (30 minutit) kuni 86 400 000 (1 päev). Sellest vahemikust välja jäävad väärtused surutakse vastavatesse piiridesse.

      Kui see reegel jäetakse määramata, kasutab teenus <ph name="PRODUCT_OS_NAME" /> vaikeväärtust 3 tundi.

      Pange tähele, et kui platvorm toetab reeglite märguandeid, määratakse värskendamise viiteks 24 tundi (eirates kõiki vaikeväärtusi ja selle reegli väärtust), kuna eeldatakse, et reegli märguanded jõustavad reegli muutmisel automaatse värskendamise, mis muudab sagedasemad värskendused ebavajalikuks.</translation>
<translation id="5530347722229944744">Blokeeri potentsiaalselt ohtlikud allalaadimised</translation>
<translation id="5535973522252703021">Kerberose volitusserveri lubatud nimekiri</translation>
<translation id="555077880566103058">Luba kõigil saitidel pistikprogrammi <ph name="FLASH_PLUGIN_NAME" /> automaatne käitamine</translation>
<translation id="5559079916187891399">See reegel ei mõjuta Androidi rakendusi.</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="5561811616825571914">Sisselogimisekraanil valitakse nendele saitidele automaatselt kliendi sertifikaadid</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="557360560705413259">Kui see seade on lubatud, kasutab teenus <ph name="PRODUCT_NAME" /> serveri sertifikaadi reeglit commonName, et ühildada hostinimi, kui sertifikaadil puudub laiend subjectAlternativeName. Seda seni, kuni teenus kinnitab kohalikult installitud CA-sertifikaadid ja loob nendega ühenduse.

      Pange tähele, et me ei soovita seda teha, kuna see võib lubada möödumise laiendist nameConstraints, mis piirab hostinimesid, millele antud sertifikaadil võib olla volitus juurde pääseda.

      Kui see reegel on määramata või määratud väärtusele Väär, ei usaldata serveri sertifikaate, millel pole laiendit subjectAlternativeName koos DNS-i nime või IP-aadressiga.</translation>
<translation id="5581292529942108810">Võimaldab seadistada Chrome'i aruandluse laiendusega seotud reeglid.

      Reegel kehtib ainult juhul, kui <ph name="CHROME_REPORTING_EXTENSION_NAME" /> on lubatud ja seade on reeglis <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" /> registreeritud.</translation>
<translation id="5584132346604748282">Androidis Google'i asukohateenuste juhtimine</translation>
<translation id="5586942249556966598">Ära tee midagi</translation>
<translation id="5630352020869108293">Viimase seansi taastamine</translation>
<translation id="5645779841392247734">Luba küpsised nendel saitidel</translation>
<translation id="5689430183304951538">Prinditava lehe vaikesuurus</translation>
<translation id="5693469654327063861">Luba andmete üleviimine</translation>
<translation id="5694594914843889579">Kui reegli väärtuseks on määratud Tõene, siis ei ole väline salvestusseade 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 seadistamata, siis saab seadmes kasutada kõiki toetatud väliste salvestusseadmete tüüpe.</translation>
<translation id="5697306356229823047">Seadme kasutajatest teavitamine</translation>
<translation id="570062449808736508">Kui see reegel on määratud mittetühjale stringile, loeb WebView URL-i piiranguid antud volituse nimega sisupakkujalt.</translation>
<translation id="5701714006401683963">Kui reegli väärtuseks määratakse Väär või jäetakse see määramata, käitub hallatud külastajaseanss aadressil https://support.google.com/chrome/a/answer/3017014 kirjeldatud moel – standardse avaliku seansina.

      Kui reegli väärtuseks määratakse Tõene, käituvad hallatud külastajaseansid hallatud seanssidena, mille puhul puuduvad paljud piirangud, mis kehtivad tavapäraste avalike seansside puhul.

      Kui reegel on määratud, ei saa kasutaja seda muuta ega alistada.</translation>
<translation id="5722934961007828462">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 toode <ph name="PRODUCT_NAME" /> ei saa tühistamise oleku teavet hankida, siis käideldakse selliseid sertifikaate tühistatutena („hard-fail”).

      Kui seda reeglit pole määratud või on selle olekuks määratud Väär, siis kasutab <ph name="PRODUCT_NAME" /> olemasolevaid tühistamise kontrollimise veebiseadeid.</translation>
<translation id="5728154254076636808">Lubab teenuse <ph name="PRODUCT_NAME" /> profiiliandmete puhul rändluskoopiate loomise</translation>
<translation id="5732972008943405952">Esmakordsel käivitamisel vaikebrauserist automaatselt täidetud vormi andmete importimine</translation>
<translation id="5765780083710877561">Kirjeldus:</translation>
<translation id="5770738360657678870">Arendaja kanal (võib olla ebastabiilne)</translation>
<translation id="5774856474228476867">Vaikeotsingupakkuja otsingu URL</translation>
<translation id="5776485039795852974">Küsi iga kord, kui sait tahab näidata töölauateatisi</translation>
<translation id="5781412041848781654">Määrab GSSAPI kogu, mida kasutatakse HTTP autentimiseks. Võite määrata vaid kogu nime või kogu tee.

          Kui jätate seade määramata, siis kasutab rakendus <ph name="PRODUCT_NAME" /> kogu vaikenime.</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="5783009211970309878">Päiste ja jaluste printimine</translation>
<translation id="5809728392451418079">Määra seadmepõhiste kontode kuvatav nimi</translation>
<translation id="5814301096961727113">Sisselogimisekraanil suulise tagasiside vaikeoleku määramine</translation>
<translation id="5815129011704381141">Automaatne taaskäivitamine pärast värskendamist</translation>
<translation id="5815353477778354428">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="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="582857022372205358">Lühema külje dupleksprintimise lubamine</translation>
<translation id="583091600226586337">
      Kui reegel on lubatud, küsitakse kasutajalt enne allalaadimist, kuhu iga fail salvestada.
      Kui reegel on keelatud, algavad allalaadimised kohe ja kasutajalt ei küsita, kuhu fail salvestada.
      Kui reegel on seadistamata, saab kasutaja seda seadet muuta.
      </translation>
<translation id="5835124959204887277">Määrab URL-id ja domeenid, mille puhul viipa ei kuvata, kui turvavõtmetelt nõutakse atesteerimise sertifikaate. Lisaks saadetakse turvavõtmele signaal, mis näitab, et kasutada võib individuaalset atesteerimist. Ilma selleta esitatakse kasutajatele Chrome'i versioonis 65 ja uuemates versioonides viip, kui saidid nõuavad turvavõtmete atesteerimist.

      URL-id (nt https://example.com/mingi/tee) vastendatakse ainul U2F appID-dega. Domeenid (nt example.com) vastendatakse ainult webauthn RP ID-dena. Seega antud saidil nii U2F-i kui ka webauthn API-de kasutamiseks tuleb loendisse lisada nii appID URL kui ka domeen.</translation>
<translation id="5835412847081687053">Kasutajaseansis lubatud kasutajaliidese lokaatide seadistamine</translation>
<translation id="5836064773277134605">Piira kaugjuurdepääsuhosti kasutatavate UDP-portide vahemikku</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="5868414965372171132">Kasutaja tasemel võrgukonfiguratsioon</translation>
<translation id="5879014913445067283">Juhib võrguhoidlate tuvastamist teenuse <ph name="NETBIOS_NAME" /> kaudu</translation>
<translation id="5883015257301027298">Küpsiste vaikeseade</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="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="5898486742390981550">Kui sisse on loginud mitu kasutajat, saab Androidi rakendusi kasutada ainult peamine kasutaja.</translation>
<translation id="5901427587865226597">Ainult dupleksprintimine</translation>
<translation id="5906199912611534122">Võimaldab lubada või keelata võrguühenduse piiramise.
      See kehtib kõigi kasutajate ja seadme kõigi liideste puhul. Pärast määramist
      on piirang aktiivne, kuni see reeglis keelatakse.

      Kui reegel on määratud väärtusele Väär, ei ole võrguühendus piiratud.
      Kui reegel on määratud väärtusele Tõene, on süsteem piiratud, et järgida määratud üles- ja allalaadimiskiirust (kbit/s).</translation>
<translation id="5921713479449475707">Automaatsete allalaadimiste lubamine HTTP kaudu</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="5929855945144989709">Seadmetel Chrome OS-is virtuaalmasinate käitamise lubamine</translation>
<translation id="5932767795525445337">Seda reeglit saab kasutada ka Androidi rakenduste kinnitamiseks.</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="5946082169633555022">Beetakanal</translation>
<translation id="5950205771952201658">Kuna veebipõhised softfail-tühistamiskontrollid ei suurenda turvalisust, keelatakse need vaikimisi toote <ph name="PRODUCT_NAME" /> 19. versioonis ja hilisemates versioonides. Kui seate reegli olekuks Tõene, taastatakse varasem käitumine ja kasutatakse veebipõhiseid OCSP-/CRL-kontrolle.

      Kui jätate reegli määramata või seate selle olekuks Väär, ei tee <ph name="PRODUCT_NAME" /> 19. versioonis ja hilisemates versioonides toote <ph name="PRODUCT_NAME" /> veebipõhiseid tühistamiskontrolle.</translation>
<translation id="5966615072639944554">Kaugatesteerimise API kasutamiseks lubatud laiendused</translation>
<translation id="5983708779415553259">Mitte ühessegi sisupaketti kuuluvate saitide vaikekäitumine</translation>
<translation id="5997543603646547632">Vaikimisi 24-tunnise kella kasutamine</translation>
<translation id="5997846976342452720">Määramine, kas pistikprogrammide leidja tuleks keelata (tugi on katkestatud)</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="6022948604095165524">Toiming käivitamisel</translation>
<translation id="6023030044732320798">Määrab reeglite kogumi, mis edastatakse ARC käitusajale. Väärtus peab olema sobiv JSON.

      Selle reegli abil saab seadistada, millised Androidi rakendused automaatselt seadmesse installitakse:

      {
        "type": "object",
        "properties": {
          "applications": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "packageName": {
                  "description": "Androidi rakenduse identifikaator, nt „com.google.android.gm” Gmaili puhul",
                  "type": "string"
                },
                "installType": {
                  "description": "Määrab, kuidas rakendus installitakse. OPTIONAL: rakendust ei installita automaatselt, kuid kasutaja saab selle installida. Kui seda reeglit ei määrata, on see vaikeseade. PRELOAD: rakendus installitakse automaatselt, kuid kasutaja saab selle desinstallida. FORCE_INSTALLED: rakendus installitakse automaatselt ja kasutaja ei saa seda desinstallida. BLOCKED: rakendus on blokeeritud ja seda ei saa installida. Kui rakendus installiti eelmise reegli põhjal, siis see desinstallitakse.",
                  "type": "string",
                  "enum": [
                    "OPTIONAL",
                    "PRELOAD",
                    "FORCE_INSTALLED",
                    "BLOCKED"
                  ]
                },
                "defaultPermissionPolicy": {
                  "description": "Reegel rakendustele lubade taotluste andmiseks. PERMISSION_POLICY_UNSPECIFIED: reeglit pole määratud. Kui loa jaoks pole reeglit määratud mitte ühelgi tasemel, kasutatakse vaikimisi käitumist `PROMPT`. PROMPT: kasutajal palutakse luba anda. GRANT: luba antakse automaatselt. DENY: luba keelatakse automaatselt.",
                  "type": "string",
                  "enum": [
                    "PERMISSION_POLICY_UNSPECIFIED",
                    "PROMPT",
                    "GRANT",
                    "DENY"
                  ]
                },
                "managedConfiguration": {
                  "description": "Rakendusepõhine JSON-i konfiguratsiooniobjekt, millel on komplekt võtmeväärtuse paare, nt '"managedConfiguration": { "key1": value1, "key2": value2 }'. Võtmed määratakse rakenduse manifestis.",
                  "type": "object"
                }
              }
            }
          }
        }
      }

      Rakenduste kinnitamiseks käivitusprogrammi vaadake reeglit PinnedLauncherApps.</translation>
<translation id="602728333950205286">Vaikeotsingupakkuja Instant-URL</translation>
<translation id="603410445099326293">Parameetrid POST-meetodit kasutava soovituse URL-i jaoks</translation>
<translation id="6036523166753287175">Luba tulemüüri läbimine kaugjuurdepääsu hostist</translation>
<translation id="6070667616071269965">Seadme sisselogimisekraani klaviatuuripaigutused</translation>
<translation id="6074963268421707432">Keela kõigil saitidel töölaua märguannete kuvamine</translation>
<translation id="6074964551275531965">Värskendusmärguannete ajavahemiku määramine</translation>
<translation id="6076099373507468537">Luuakse loend USB-seadmetest, mis lubatakse eemaldada tuumadraiverist, et neid veebirakenduses otse chrome.usb API kaudu kasutada. Kirjed on USB teenusepakkuja ID-de ja toote ID-de paarid, mille abil konkreetne riistvara tuvastada.

      Kui see reegel jäetakse seadistamata, on eemaldatavate USB-seadmete loend tühi.</translation>
<translation id="6083631234867522991">Windows (Windowsi kliendid):</translation>
<translation id="6091233616732024397">Brauseri kasutamiseks sisselogimise nõudmine</translation>
<translation id="6093156968240188330">Lubab kaugkasutajatel kaugabiseanssides suhelda administraatoriõigusi nõudvate akendega</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="6097601282776163274">URL-i võtmetega anonüümsete andmete kogumise lubamine</translation>
<translation id="6099853574908182288">Vaikimisi kasutatav printimise värvirežiim</translation>
<translation id="6111936128861357925">Luba dinosauruse üllatusmäng</translation>
<translation id="6114416803310251055">iganenud</translation>
<translation id="6133088669883929098">Luba kõikidel saitidel võtmeid luua</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="614662973812186053">See reegel juhib ka Androidi kasutus- ja diagnostikaandmete kogumist.</translation>
<translation id="6155936611791017817">Sisselogimisekraanil suure kursori vaikeoleku määramine</translation>
<translation id="6157537876488211233">Puhverserveri möödumisreeglite komadega eraldatud loend</translation>
<translation id="6158324314836466367">Ettevõtte veebipoe nimi (tugi on katkestatud)</translation>
<translation id="6181608880636987460">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel ei ole lubatud pistikprogrammi <ph name="FLASH_PLUGIN_NAME" /> käitada.

          Kui jätate selle reegli määramata, kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultPluginsSetting” (kui see on määratud) või kasutaja isiklikust seadistusest.</translation>
<translation id="6190022522129724693">Hüpikakende vaikeseade</translation>
<translation id="6190367314942602985">Kasutaja identimisteabe edastamine</translation>
<translation id="6197453924249895891">Annab juurdepääsu laienduste ettevõttevõtmetele.

      Võtmed on mõeldud ettevõttes kasutamiseks, kui need luuakse hallatud kontol chrome.enterprise.platformKeys API-ga. Muul viisil imporditud või loodud võtmed pole määratud ettevõttes kasutamiseks.

      Juurdepääsu ettevõttes kasutamiseks määratud võtmetele juhib vaid see reegel. Kasutaja ei saa laiendustele anda ega keelata juurdepääsu ettevõttevõtmetele.

      Vaikimisi ei saa laiendus ettevõttes kasutamiseks määratud võtit kasutada. See on sama mis laienduse puhul reegli allowCorporateKeyUsage määramine väärtusele Väär.

      Ainult siis, kui reegel allowCorporateKeyUsage on laienduse puhul määratud väärtusele Tõene, saab laiendus ettevõttes kasutamiseks määratud mis tahes platvormivõtit kasutada mis tahes andmete allkirjastamiseks. See luba tuleks anda vaid siis, kui laienduse juurdepääs võtmele on usaldusväärne ja ründajate eest kaitstud.</translation>
<translation id="6208896993204286313">Rakenduse <ph name="PRODUCT_NAME" /> reegliteabe edastamine</translation>
<translation id="6210259502936598222">Operatsioonisüsteemi ja rakenduse <ph name="PRODUCT_NAME" /> versiooniteabe edastamine</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="6212868225782276239">Kuvatakse kõik printerid, v.a need, mis on keelatute loendis.</translation>
<translation id="6219965209794245435">Reegli lubamisel imporditakse automaatselt täidetud vormi andmed eelmisest vaikebrauserist. Lubamisel mõjutab reegel ka importimisdialoogi.

      Reegli keelamisel automaatselt täidetud vormi andmeid ei impordita.

      Kui jätate selle reegli määramata, siis võidakse kasutajalt küsida, kas ta soovib importida, või võib importimine toimuda automaatselt.</translation>
<translation id="6224304369267200483">URL-id/domeenid, millel on turvavõtme otsene atesteerimine automaatselt lubatud</translation>
<translation id="6233173491898450179">Määra allalaadimiskataloog</translation>
<translation id="6244210204546589761">Käivitamisel avatavad URL-id</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="6261643884958898336">Masina identimisteabe edastamine</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="6282799760374509080">Heli jäädvustamise lubamine või keelamine</translation>
<translation id="6284362063448764300">TLS 1.1</translation>
<translation id="6310223829319187614">Domeeni nime automaatse täitmise lubamine kasutaja sisselogimise ajal</translation>
<translation id="6315673513957120120">Chrome kuvab hoiatuslehe, kui kasutajad liiguvad SSL-i vigadega saitidele. Vaikimisi või siis, kui selle reegli väärtuseks määratakse Tõene, lubatakse kasutajatel nendelt hoiatuslehtedelt kliki abil edasi liikuda.
      Kui selle reegli väärtuseks määratakse Väär, ei lubata kasutajatel hoiatuslehelt kliki abil edasi liikuda.</translation>
<translation id="6352543686437322588">Seadme kohalik konto, kuhu pärast viivitust automaatselt sisse logida.

      Kui reegel on määratud, logitakse määratud seanssi automaatselt sisse, kui sisselogimiskuval on möödunud teatud ajavahemik, mille jooksul kasutaja ei tee ühtki toimingut. Seadme kohalik konto peab olema seadistatud (vt |DeviceLocalAccounts|).

      Kui reegel on määramata, ei toimu automaatset sisselogimist.</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="6367755442345892511">Määramine, kas kasutajal on võimalik versiooni kanalit seadistada</translation>
<translation id="6368011194414932347">Avalehe URL-i seadistamine</translation>
<translation id="6368403635025849609">Luba JavaScript nendel saitidel</translation>
<translation id="6376659517206731212">Võib olla kohustuslik</translation>
<translation id="6377355597423503887">Selle reegli tugi on katkestatud, kaaluge selle asemel reegli BrowserSignin kasutamist.

      Lubab kasutajal teenusesse <ph name="PRODUCT_NAME" /> sisse logida.

      Selle reegli määramisel saate seadistada, kas kasutajal lubatakse teenusesse <ph name="PRODUCT_NAME" /> sisse logida. Kui määrate reegli väärtuseks „Väär”, ei tööta rakendused ja laiendused, mis kasutavad chrome.identity API-t, seetõttu soovitame selle asemel kasutada reeglit SyncDisabled.</translation>
<translation id="6378076389057087301">Määrake, kas helitoimingud mõjutavad toitehaldust</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="6394350458541421998">Reegel on alates rakenduse <ph name="PRODUCT_OS_NAME" /> versioonist 29 kasutusest kõrvaldatud. Kasutage selle asemel reeglit PresentationScreenDimDelayScale.</translation>
<translation id="6401669939808766804">Kasutaja väljalogimine</translation>
<translation id="6426205278746959912">Te ei saa Androidi rakenduste puhul jõustada puhverserveri kasutamist. Androidi rakendustele on muudetud kättesaadavaks puhverserveri seadete alamkomplekt, mille kasutamine on vabatahtlik.

          Kui otsustate puhverserverit mitte kasutada, antakse Androidi rakendustele teada, et puhverserverit pole seadistatud.

          Kui otsustate kasutada süsteemi puhverserveri seadeid või fikseeritud puhverserverit, esitatakse Androidi rakendustele HTTP-protokolliga puhverserveri aadress ja port.

          Kui otsustate puhverserveri automaatselt tuvastada, esitatakse Androidi rakendustele URL „http://wpad/wpad.dat”. Ühtegi teist puhverserveri automaatse tuvastamise protokolli osa ei kasutata.

          Kui otsustate kasutada puhverserveri skripti .pac, esitatakse Androidi rakendustele skripti URL.</translation>
<translation id="6430366557948788869">Chrome'i aruandluse laiendus</translation>
<translation id="6440051664870270040">Saitidel samaaegse navigeerimise ja hüpikakende avamise lubamine</translation>
<translation id="6447948611083700881">Varundamine ja taastamine on keelatud</translation>
<translation id="645425387487868471">Teenusesse <ph name="PRODUCT_NAME" /> sundsisselogimise lubamine</translation>
<translation id="6464074037294098618">Aadresside automaattäite lubamine</translation>
<translation id="6473623140202114570">Seadistage loend domeenidest, kus Google'i ohutu sirvimise funktsioon hoiatusi ei käivita.</translation>
<translation id="6491139795995924304">Luba Bluetooth seadmes</translation>
<translation id="6520802717075138474">Impordi otsingumootorid vaikebrauserist esimesel käitamisel</translation>
<translation id="6525955212636890608">Selle seade lubamisel käitatakse kogu Flash-sisu, mis on manustatud veebisaitidele, kus Flash on sisu seadetes lubatud – seda nii kasutaja kui ka ettevõtte reegliga (sh muu päritoluga või väikesemahuline sisu).

      Kui soovite juhtida, millistel veebisaitidel on Flashi käitamine lubatud, vaadake reegleid „DefaultPluginsSetting”, „PluginsAllowedForUrls” ja „PluginsBlockedForUrls”.

      Kui see seade on keelatud või määramata, võidakse muu päritoluga või väikesemahuline Flash-sisu blokeerida.</translation>
<translation id="6532769014584932288">Äratuslukkude lubamine</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="6536600139108165863">Automaatne taaskäivitamine seadme väljalülitamisel</translation>
<translation id="6539246272469751178">See reegel ei mõjuta Androidi rakendusi. Androidi rakendused kasutavad alati allalaadimiste vaikekataloogi ega pääse juurde ühelegi failile, mille operatsioonisüsteem <ph name="PRODUCT_OS_NAME" /> on alla laadinud kataloogi, mis pole allalaadimiste vaikekataloog.</translation>
<translation id="654303922206238013">Süsteemi eCryptfs üleviimisstrateegia</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="6553143066970470539">Ekraani ereduse protsent</translation>
<translation id="6559057113164934677">Keela kõikidel saitidel juurdepääs kaamerale ja mikrofonile</translation>
<translation id="6561396069801924653">Juurdepääsuvalikute kuvamine süsteemisalve menüüs</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="6573305661369899995">URL-i piirangute välise allika seadistamine</translation>
<translation id="6598235178374410284">Kasutaja avatarkujutis</translation>
<translation id="6603004149426829878">Ajavööndi lahendamisel saada saadaolevad asukohasignaalid alati serverisse</translation>
<translation id="6628646143828354685">Võimaldab määrata, kas veebisaitidel on lubatud juurde pääseda läheduses asuvatele Bluetoothi seadmetele. Juurdepääsu saab täielikult blokeerida või kasutajalt võidakse iga kord küsida, kui veebisait soovib läheduses asuvatele Bluetoothi seadmetele juurde pääseda.

          Kui seda reeglit ei määrata, kasutatakse väärtust „3” ja kasutaja saab seda muuta.</translation>
<translation id="663685822663765995">Printimise värvirežiimi piiramine</translation>
<translation id="6641981670621198190">Keela 3D-graafika API-liideste tugi</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="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="6652197835259177259">Kohalikult hallatud kasutajaseaded</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="6665670272107384733">Kiire avamise puhul parooli sisestamise sageduse määramine</translation>
<translation id="6681229465468164801">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel ei ole lubatud küsida kasutajalt luba USB-seadmele juurdepääsemiseks.

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

          Selles reeglis olevad URL-i mustrid ei tohi olla vastuolus reeglitega, mis on seadistatud reegliga WebUsbAskForUrls. Määramata on see, millist kahest reeglist eelistatakse, kui URL ühtib mõlemaga.</translation>
<translation id="6689792153960219308">Riistvara oleku aruanne</translation>
<translation id="6698632841807204978">Mustvalge printimise lubamine</translation>
<translation id="6699880231565102694">Kahetasandilise autentimise lubamine kaugjuurdepääsu hostidele</translation>
<translation id="6724842112053619797">Kui lubate selle seade, kirjutatakse teenuse <ph name="PRODUCT_NAME" /> profiilide salvestatud seaded, näiteks järjehoidjad, automaatse täitmise andmed, paroolid jms, faili, mis talletatakse rändlust kasutava profiili kausta või asukohta, mille administraator määrab reegliga <ph name="ROAMING_PROFILE_LOCATION_POLICY_NAME" />. Reegli lubamine keelab pilveteenusega sünkroonimise.

      Kui keelate selle reegli või jätate selle määramata, kasutatakse ainult tavalisi kohalikke profiile.

      Reegel <ph name="SYNC_DISABLED_POLICY_NAME" /> keelab kogu andmete sünkroonimise, alistades reegli RoamingProfileSupportEnabled.</translation>
<translation id="6731757988219967594">Filtreeri täiskasvanutele mõeldud sisuga ülataseme saidid (kuid mitte manustatud iframe'id)</translation>
<translation id="6734521799274931721">Juhib Network File Shares for ChromeOS saadavalolekut</translation>
<translation id="6735701345096330595">Õigekirjakontrolli keelte sundlubamine</translation>
<translation id="673699536430961464">Seade võimaldab kasutajatel pärast operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> seadmesse sisselogimist vahetada Google'i kontosid brauseriakna sisualal.

      Kui reegel on seatud väärtusele Väär, ei ole mitte-inkognito brauseriakna sisualal lubatud muule kontole sisse logida.

      Kui reegel on määratama või seatud väärtusele Tõene, kasutatakse vaikekäitumist: brauseri sisualal on lubatud sisse logida muule kontole, v.a tütarkontode puhul, mille jaoks on funktsioon mitte-inkognito sisualal blokeeritud.

      Kui inkognito režiimi kaudu muule kontole sisselogimine peab olema keelatud, kaaluge režiimi blokeerimist reegliga IncognitoModeAvailability.

      Pange tähele, et kasutajad võivad küpsised blokeerida, et saada juurdepääs autentimata olekus Google'i teenustele.</translation>
<translation id="6738326937072482736">Seadistab teenuse <ph name="TPM_FIRMWARE_UPDATE_TPM" /> püsivaravärskenduse funktsiooni saadavaloleku ja käitumise.

      JSON-i atribuutides saab määrata üksikud seaded.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH" />: kui see on määratud väärtusele <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH_TRUE" />, saavad kasutajad teenuse <ph name="TPM_FIRMWARE_UPDATE_TPM" /> püsivaravärskenduse installimiseks käivitada Powerwashi voo.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE" />: kui see on määratud väärtusele <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE_TRUE" />, saavad kasutajad käivitada teenuse <ph name="TPM_FIRMWARE_UPDATE_TPM" /> püsivara värskendusvoo, mis säilitab kogu seadme oleku (sh ettevõtte registreerimise), ent eemaldab kasutajate andmed. See värskendusvoog on saadaval alates 68. versioonist.

      Kui reegel on määramata, ei ole teenuse <ph name="TPM_FIRMWARE_UPDATE_TPM" /> püsivaravärskenduse funktsioon saadaval.</translation>
<translation id="6757438632136860443">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud pistikprogrammi <ph name="FLASH_PLUGIN_NAME" /> käitada.

          Kui jätate selle reegli määramata, kasutatakse kõikide saitide puhul globaalset vaikeväärtust, mis pärineb reeglist „DefaultPluginsSetting” (kui see on määratud) või kasutaja isiklikust seadistusest.</translation>
<translation id="6762235610019366960">Võimaldab teil teenuses <ph name="PRODUCT_NAME" /> hallata kogu vahelehel esitatavat reklaam- ja/või hariduslikku sisu.

      Kui see on seadistamata või lubatud (valikul Tõene), võib teenus <ph name="PRODUCT_NAME" /> kuvada kasutajatele kogu vahelehel esitatavat sisu, et toote kohta teavet anda.

      Kui see on keelatud (valikul Väär), ei kuva teenus <ph name="PRODUCT_NAME" /> kasutajatele kogu vahelehel kuvatavat sisu, et toote kohta teavet anda.

      Selle seadega hallatakse tervituslehtede esitamist, mis aitavad kasutajatel teenusesse <ph name="PRODUCT_NAME" /> sisse logida, määrata selle vaikebrauseriks või muul viisil neid toote funktsioonidest teavitada.</translation>
<translation id="6766216162565713893">Luba saitidel paluda kasutajatelt juurdepääsu läheduses asuvatele Bloetoothi seadmetele</translation>
<translation id="6770454900105963262">Aruandeteave aktiivsete kioskiseansside kohta</translation>
<translation id="6786747875388722282">Laiendused</translation>
<translation id="6786967369487349613">Rändlusprofiili kataloogi määramine</translation>
<translation id="6810445994095397827">Blokeeri JavaScript nendel saitidel</translation>
<translation id="681446116407619279">Toetatud autentimisskeemid</translation>
<translation id="6816212867679667972">Võimaldab määrata DHCP-päringutes kasutatava seadme hostinime.

      Kui selle reegli väärtuseks määratakse mõni täidetud string, kasutatakse seda stringi DHCP-päringu ajal seadme hostinimena.

      String võib sisaldada muutujaid ${ASSET_ID}, ${SERIAL_NUM}, ${MAC_ADDR}, mis asendatakse seadmes väärtustega enne hostinimena kasutamist. Nende asendamisel peaks tekkima kehtiv hostinimi (eeskirja RFC 1035 jaotise 3.1 kohaselt).

      Kui see reegel on määramata või pärast asendamist tekkiv väärtus ei ole kehtiv hostinimi, siis DHCP-päringus hostinime ei määrata. </translation>
<translation id="6835883744948188639">Kuva kasutajale korduv viip, mis näitab, et taaskäivitamine on soovitatav</translation>
<translation id="6838056959556423778">Alistatakse rakenduse <ph name="PRODUCT_NAME" /> vaikeprinteri valimise reeglid.

      Selle reegliga määratakse reeglid rakenduses <ph name="PRODUCT_NAME" /> vaikeprinteri valimiseks, mis toimub esimesel korral, kui profiilil printimisfunktsiooni kasutatakse.

      Kui reegel on määratud, üritab rakendus <ph name="PRODUCT_NAME" /> leida printeri, mis vastab kõigile määratud atribuutidele, ja valib selle vaikeprinteriks. Valitakse esimene printer, mis reeglitele vastab. Kui reeglitele vastavaid printereid on mitu, saab nende avastamise järjekorrast olenevalt valida mis tahes sobiva printeri.

      Kui seda reeglit ei määrata või määratud aja jooksul ei leita reeglitele vastavat printerit, määratakse vaikimisi printeriks sisseehitatud PDF-printer. Kui PDF-printer pole saadaval, siis printerit ei valita.

      Väärtus sõelutakse JSON-objektina, mis vastab järgmisele skeemile:
      {
        "type": "object",
        "properties": {
          "kind": {
            "description": "Kas piirata sobiva printeri otsing konkreetse printerite komplektiga?",
            "type": {
              "enum": [ "local", "cloud" ]
            }
          },
          "idPattern": {
            "description": "Regulaaravaldis, mis ühtib printeri ID-ga.",
            "type": "string"
          },
          "namePattern": {
            "description": "Regulaaravaldis, mis ühtib printeri kuvatava nimega.",
            "type": "string"
          }
        }
      }

      Rakendusega <ph name="CLOUD_PRINT_NAME" /> ühendatud printerid loetakse gruppi <ph name="PRINTER_TYPE_CLOUD" /> kuuluvateks, ülejäänud printerid kuuluvad gruppi <ph name="PRINTER_TYPE_LOCAL" />.
      Välja vahelejätmine tähendab, et kõik väärtused ühtivad. Näiteks kui ühenduvust ei määrata, käivitab printimise eelvaade igat tüüpi printerite (nii kohalike kui ka pilvepõhiste printerite) otsimise.
      Regulaaravaldise mustrid peavad järgima atribuudi JavaScript RegExp süntaksit ja vasted on tõstutundlikud.</translation>
<translation id="684856667300805181">Reegel eemaldati operatsioonisüsteemist <ph name="PRODUCT_NAME" /> 68 ja see asendati reegliga <ph name="ARC_GLS_POLICY_NAME" />.</translation>
<translation id="6856743875250214792">Selle reegli tugi on katkestatud ja see on versioonist M66 eemaldatud, kuna seda kasutati ainult sisetestides ja see sisaldab turvaauku.

      Määrab seaded, mis tuleb rakendada teenuses <ph name="PRODUCT_NAME" /> selle käivitamisel. Määratud seaded rakendatakse ainult sisselogimiskuval. Selle reegliga määratud seaded ei rakendu kasutaja seanssides.</translation>
<translation id="685769593149966548">Jõusta YouTube'is rangelt piiratud režiim</translation>
<translation id="686079137349561371">Microsoft Windows 7 või uuem</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="6894178810167845842">Uue vahelehe URL</translation>
<translation id="6899705656741990703">Tuvasta puhverserveri seaded automaatselt</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="6908640907898649429">Seadistab vaikeotsingupakkuja. Saate määrata kasutajate jaoks vaikeotsingupakkuja või vaikeotsingu keelata.</translation>
<translation id="6913068954484253496">Teenuse <ph name="PRODUCT_NAME" /> ja Casti seadmete vahelise ühenduse lubamine kõigi IP-aadresside kaudu.</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="6916507170737609563">
      Soovitame teil vaadata reegli IsolateOriginsAndroid seadet, et kasutada nii isoleerimist kui ka piirata mõju kasutajate jaoks, kasutades reeglit IsolateOriginsAndroid saitide puhul, mille soovite isoleerida. Seade SitePerProcessAndroid isoleerib kõik saidid.
      Kui reegel on lubatud, käitab iga sait siiski oma protsesse.
      Kui reegel on keelatud, ei toimu selget saidi isoleerimist ning reeglite IsolateOriginsAndroid ja SitePerProcessAndroid testid keelatakse. Kasutajad saavad reegli SitePerProcess siiski käsitsi lubada.
      Kui reegel on seadistamata, saab kasutaja seda seadet muuta.

      MÄRKUS. Androidis on saidi isoleerimine katseline. Aja jooksul täiustatakse tuge, kuid praegu võib see toimivuses probleeme põhjustada.

      MÄRKUS. See reegel kehtib ainult Chrome'i Androidi versiooni puhul seadmetes, millel on rohkem kui 1 GB muutmälu. Reegli rakendamiseks muudel platvormidel kasutage seadet SitePerProcess.
      </translation>
<translation id="6922040258551909078">
      Kui selle reegli väärtuseks on määratud Tõene, alistavad pilve-eeskirjad konflikti puhul seadme-eeskirjad.
      Kui reegli väärtuseks on määratud Väär või see jäetakse määramata, alistavad seadme-eeskirjad konflikti puhul pilve-eeskirjad.
      Reeglite prioriteedi kohta lisateabe saamiseks minge saidile https://support.google.com/chrome?p=set_chrome_policies_for_devices

      See reegel ei ole saadaval Windowsi eksemplarides, mis ei ole liitunud domeeniga <ph name="MS_AD_NAME" />.
      </translation>
<translation id="6922884955650325312">Pistikprogrammi <ph name="FLASH_PLUGIN_NAME" /> blokeerimine</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="6926703471186170050">Pikema külje dupleksprintimise lubamine</translation>
<translation id="6931242315485576290">Keela andmete sünkroonimine Google'iga</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="6943577887654905793">Maci/Linuxi eelistuse nimi:</translation>
<translation id="6944167205014013774">Teave Linuxi rakenduste kasutuse kohta saadetakse tagasi
      serverisse.

      Kui reegel on määratud väärtusele Väär või see on määramata, siis kasutusteavet
      ei saadeta. Kui väärtuseks on määratud Tõene, siis kasutusteavet saadetakse.

      See reegel kehtib ainult juhul, kui Linuxi rakenduste tugi on lubatud.</translation>
<translation id="69525503251220566">Parameeter otsingu vaikepakkujale pildi järgi otsimise funktsiooni pakkumiseks</translation>
<translation id="6956272732789158625">Ära luba ühelgi saidil võtmeid luua</translation>
<translation id="6965859329738616662">Määrab, kas nutikal hämardamismudelil on lubatud ekraani hämardamise aega pikendada.

      Kui ekraani hämardamine algab, uurib nutikas hämardamismudel, kas ekraani hämardamine tuleks edasi lükata. Kui nutikas hämardamismudel lükkab ekraani hämardamise edasi, pikendatakse sisuliselt aega, mille möödudes ekraan hämardatakse. Sel juhul reguleeritakse ka ekraani väljalülitamise, lukustamise ja tegevusetuse viiteaegu, et järgida algselt seadistatud hämardamisviivitust.
      Kui reegel on määramata või seatud väärtusele Tõene, lubatakse nutikas hämardamismudel ja ekraani hämardamiseni kuluva aja pikendamine. Kui reegel on seatud väärtusele Väär, ei mõjuta nutikas hämardamismudel ekraani hämardamist.</translation>
<translation id="6994082778848658360">Määrab, kuidas kasutada sisseehitatud turvalist elementi kahe teguriga autentimise funktsiooni pakkumiseks, kui element ühildub selle funktsiooniga. Kasutaja füüsilise kohaloleku tuvastamiseks kasutatakse seadme toitenuppu.

      Kui valite väärtuse „Keelatud”, ei pakuta kahe teguriga autentimist.

      Kui valite väärtuse „U2F”, käitub integreeritud teine tegur FIDO U2F-i spetsifikatsiooni kohaselt.

      Kui valite väärtuse „U2F_EXTENDED”, pakub sisseehitatud teine tegur U2F-i funktsioone ja ka teatud laiendusi individuaalse atesteerimise jaoks.</translation>
<translation id="6997592395211691850">Kas OCSP/CRL-i onlain-kontroll on vajalikud kohalike usaldusvõtmete puhul või mitte</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="7003746348783715221">Rakenduse <ph name="PRODUCT_NAME" /> eelistused</translation>
<translation id="7006788746334555276">Sisu seaded</translation>
<translation id="7007671350884342624">Seadistab kataloogi, mida <ph name="PRODUCT_NAME" /> kasutab kasutajaandmete salvestamiseks.

      Kui määrate reegli, kasutab <ph name="PRODUCT_NAME" /> sisestatud kataloogi sellest olenemata, kas kasutaja on määranud märgistuse „--user-data-dir”. Andmekao ja muude ootamatute vigade vältimiseks ei tohi reegli jaoks valida ketta juurkataloogi ega muudel eesmärkidel kasutatavat kataloogi, kuna <ph name="PRODUCT_NAME" /> haldab selle kataloogi sisu.


      Vaadake kasutamiseks saadaolevate muutujate loendit aadressilt https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Kui jätate reegli määramata, kasutatakse profiili vaiketeed ja kasutaja saab selle alistada käsurea märgistusega „--user-data-dir”.</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="7040229947030068419">Näidisväärtus:</translation>
<translation id="7044883996351280650">Androidi varundus- ja taasteteenuse juhtimine</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="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="7063895219334505671">Luba hüpikaknad nendel saitidel</translation>
<translation id="706568410943497889">
      Kui reegli väärtuseks määratakse Tõene, võib <ph name="PRODUCT_NAME" /> koguda Google'i teenustest (nt Google Meet) WebRTC sündmuselogisid ja need Google'i serveritesse üles laadida.

      Kui reegli väärtuseks määratakse Väär või jäetakse see määramata, ei tohi <ph name="PRODUCT_NAME" /> logisid koguda ega üles laadida.

      Need logid sisaldavad diagnostikateavet, mis on kasulik Chrome'i hääl- või videokõnedega seotud probleemide silumisel. See hõlmab näiteks saadetud ja vastuvõetud RTP-pakettide kellaaja ja suuruse teavet, tagasisidet võrgu ummistuste kohta ja metaandmeid heli- ja videokaadrite aja ja kvaliteedi kohta. Logid ei sisalda kõne hääl- ega videosisu.

      Chrome'is saavad andmete kogumise käivitada ainult Google'i veebiteenused, nt Google Hangouts või Google Meet.
      Google võib seansi ID alusel seostada logid muude logidega, mida Google'i teenus kogub. Selle eesmärk on hõlbustada silumist.
      </translation>
<translation id="706669471845501145">Luba saitidel töölauateatiste näitamine</translation>
<translation id="7072208053150563108">Seadme parooli muutmise sagedus</translation>
<translation id="7074513465313721551">Seadistage loend domeenidest, mida ohutu sirvimise funktsioon usaldab. See tähendab järgmist.
      Ohutu sirvimise funktsioon ei kontrolli ohtlikke allikaid (nt andmepüük, pahavara või soovimatu tarkvara), kui nende URL-id ühtivad nende domeenidega.
      Ohutu sirvimise funktsiooni allalaadimiskaitseteenus ei kontrolli nendel domeenidel hostitud allalaadimisi.
      Ohutu sirvimise funktsiooni paroolikaitseteenus ei kontrolli parooli taaskasutamist, kui lehe URL ühtib nende domeenidega.

      Kui see seade on lubatud, usaldab ohutu sirvimise funktsioon neid domeene.
      Kui see seade on keelatud või seadistamata, siis rakendatakse ohutu sirvimise funktsiooni vaikekaitse kõikidele allikatele.
      See reegel ei ole saadaval Windowsi eksemplarides, mis pole domeeniga <ph name="MS_AD_NAME" /> liitunud.</translation>
<translation id="7079519252486108041">Blokeeri hüpikaknad nendel saitidel</translation>
<translation id="7085803328069945025">Võimaldab määrata URL-i mustrite loendi, mis määrab saidid, millel on lubatud küsida kasutajalt luba USB-seadmele juurdepääsemiseks.

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

          Selles reeglis olevad URL-i mustrid ei tohi olla vastuolus reeglitega, mis on seadistatud reegliga WebUsbBlockedForUrls. Määramata on see, millist kahest reeglist eelistatakse, kui URL ühtib mõlemaga.</translation>
<translation id="7106631983877564505">Lubage operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> seadmete lukustamine, kui need on peatatud või tegevusetud.

      Kui lubate seade, küsitakse kasutajatelt unerežiimis seadme avamiseks parooli.

      Kui keelate seade, ei küsita kasutajatelt unerežiimis seadme avamiseks parooli.

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

      Kui jätate reegli määramata, saavad kasutajad valida, kas nad soovivad seadme avamiseks parooli sisestada või mitte.</translation>
<translation id="7115494316187648452">Määrab, kas brauseri <ph name="PRODUCT_NAME" /> protsess käivitub operatsioonisüsteemi sisselogimisel ja jätkab töötamist pärast viimase brauseriakna sulgemist. Sel juhul võivad taustarakendused ja praegune sirvimisseanss, sh seansipõhised küpsisefailid, jääda aktiivseks. Taustaprotsess kuvab süsteemisalves ikooni, mis võimaldab protsessi igal ajal sulgeda.

      Kui reegel on seatud väärtusele Tõene, on taustarežiim lubatud ja kasutaja ei saa seda brauseri seadetes muuta.

      Kui reegel on seatud väärtusele Väär, on taustarežiim keelatud ja kasutaja ei saa seda brauseri seadetes muuta.

      Kui jätate reegli määramata, on taustarežiim vaikimisi keelatud ja kasutaja saab seda brauseri seadetes muuta.</translation>
<translation id="7126716959063786004">Lõpetamisprotsesside lubamine tegumihalduris</translation>
<translation id="7127892035367404455">Tagasiminek sihtversioonile</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="7132877481099023201">URL-id, millele antakse ilma küsimata juurdepääs videojäädvustusseadmetele</translation>
<translation id="7167436895080860385">Lubage kasutajatel paroolihalduris paroole kuvada (tugi on katkestatud)</translation>
<translation id="7173856672248996428">Kaduvad profiilid</translation>
<translation id="717630378807352957">Lubatakse kõik konfiguratsioonifailis olevad printerid.</translation>
<translation id="7176721759719212761">Määrab, kas ekraani äratuslukud on lubatud. Ekraani äratuslukke saavad taotleda laiendused toitehalduse laienduse API kaudu ja ARC-rakendused.

          Kui reegel on määramata või seatud väärtusele Tõene, järgitakse toitehalduse puhul ekraani äratuslukke, v.a juhul, kui AllowWakeLocks on seatud väärtusele Väär.

          Kui reegel on seatud väärtusele Väär, eiratakse äratuslukutaotlusi.</translation>
<translation id="7185078796915954712">TLS 1.3</translation>
<translation id="718956142899066210">Värskenduste jaoks lubatud ühenduse tüübid</translation>
<translation id="7194407337890404814">Vaikeotsingupakkuja nimi</translation>
<translation id="7202925763179776247">Luba allalaadimise piirangud</translation>
<translation id="7207095846245296855">Google SafeSearchi jõustamine</translation>
<translation id="7216442368414164495">Kasutajatel lubatakse ohutu sirvimise laiendatud aruannete lubamine</translation>
<translation id="7221822638060296742">Võimaldab määrata, kas veebisaitidel on lubatud automaatselt käitada pistikprogrammi <ph name="FLASH_PLUGIN_NAME" />. Pistikprogrammi <ph name="FLASH_PLUGIN_NAME" /> automaatne käitamine võib kõikide veebisaitide jaoks olla lubatud või keelatud.

          Funktsioon Klõpsa esitamiseks lubab pistikprogrammi <ph name="FLASH_PLUGIN_NAME" /> käitada, kuid kasutaja peab selle käivitamiseks klõpsama kohahoidjal.

          Automaatne taasesitus on lubatud ainult domeenidel, mis on reeglis <ph name="PLUGINS_ALLOWED_FOR_URLS_POLICY_NAME" /> selgesõnaliselt loetletud. Kui soovite lubada automaatse taasesituse kõigil saitidel, kaaluge sellesse loendisse protokollide http://* ja https://* lisamist.

          Kui see reegel on määramata, saab kasutaja seda seadet käsitsi muuta.</translation>
<translation id="7229975860249300121">Sisaldab regulaaravaldist, mis määrab, millised Google'i kontod saab teenuses <ph name="PRODUCT_NAME" /> brauseri peamisteks kontodeks seadistada.

      Kui kasutaja üritab määrata brauseri peamist kontot, mille kasutajanimi ei kattu mustriga, kuvatakse vastav veasõnum.

      Kui jätate reegli määramata või tühjaks, saavad kõik kasutajad teenuses <ph name="PRODUCT_NAME" /> mis tahes Google'i konto brauseri peamiseks kontoks määrata.</translation>
<translation id="723103540848640830">Lukustuskuva PIN-koodi miinimumpikkuse määramine</translation>
<translation id="7232816984286843471">Kui reegel on seatud väärtusele Väär, ei lubata seoseta kasutajatel Crostinit kasutada.

      Kui reegel on määramata või seatud väärtusele Tõene, tohivad kõik kasutajad Crostinit kasutada eeldusel, et ka muud seaded lubavad seda.
      Kõik kolm reeglit – VirtualMachinesAllowed, CrostiniAllowed ja DeviceUnaffiliatedCrostiniAllowed – peavad olema tõesed, et Crostini käitamine oleks lubatud.
      Kui reegel seatakse väärtusele Väär, kehtib see uute Crostini ümbriste käitamise puhul, ent ei lülita välja juba käivitatud ümbriseid.</translation>
<translation id="7234280155140786597">Keelatud omasõnumside hostide nimed (või väärtus * kõikide keelamiseks)</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="7249828445670652637">Luba ARC-rakenduste jaoks operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> CA-sertifikaatide kasutamine</translation>
<translation id="725322441686394886">Kui reegel on määramata ja Chrome Cleanup tuvastab soovimatu tarkvara, võib teenus edastada skanni metaandmed Google'ile, järgides atribuudiga SafeBrowsingExtendedReportingEnabled määratud reeglit. Chrome Cleanup küsib seejärel kasutajalt, kas ta soovib tuvastatud tarkvara eemaldada. Seejärel võib kasutaja jagada puhastuse tulemusi Google'iga, et täiustada soovimatu tarkvara tuvastamise funktsiooni. Tulemused sisaldavad faili metaandmeid, automaatselt installitud laiendusi ja registrivõtmeid, mida kirjeldatakse Chrome'i privaatsuse juhendis.

      Kui reegel on keelatud ja Chrome Cleanup tuvastab soovimatu tarkvara, ei edasta teenus skanni metaandmeid Google'ile, alistades atribuudiga SafeBrowsingExtendedReportingEnabled määratud reegli. Chrome Cleanup küsib kasutajalt, kas ta soovib tuvastatud tarkvara eemaldada. Puhastuse tulemusi ei edastata Google'ile ja kasutajale ei esitata sellekohast valikut.

      Kui reegel on lubatud ja Chrome Cleanup tuvastab soovimatu tarkvara, võib teenus edastada skanni metaandmed Google'ile, järgides atribuudiga SafeBrowsingExtendedReportingEnabled määratud reeglit. Chrome Cleanup küsib kasutajalt, kas ta soovib tuvastatud tarkvara eemaldada. Puhastuse tulemused edastatakse Google'ile ja kasutaja ei saa seda takistada.

      Reegel ei ole saadaval Windowsi eksemplarides, mis ei ole liidetud teenuse <ph name="MS_AD_NAME" /> domeeniga.</translation>
<translation id="7258823566580374486">Kaugjuurdepääsu hostide varjamise lubamine</translation>
<translation id="7260277299188117560">Lubatud p2p automaatne värskendamine</translation>
<translation id="7261252191178797385">Seadme taustapildi kujutis</translation>
<translation id="7264704483008663819">Selle reegli tugi on versioonis M68 katkestatud, kasutage selle asemel reeglit DeveloperToolsAvailability.

      Keelab arendaja tööriistad ja JavaScripti konsooli.

      Kui lubate seade, on juurdepääs arendaja tööriistadele keelatud ja veebisaitide elemente ei saa enam uurida. Kõik klaviatuuri otseteed ning arendaja tööriistade ja JavaScripti konsooli avamise käsud menüüdes ning kontekstimenüüdes keelatakse.

      Kui keelate valiku või jätate selle määramata, saab kasutaja arendaja tööriistu ja JavaScripti konsooli kasutada.

      Kui reegel DeveloperToolsAvailability on määratud, eiratakse reegli DeveloperToolsDisabled väärtust.</translation>
<translation id="7266471712301230894">See reegel on eemaldatud alates rakenduse <ph name="PRODUCT_NAME" /> versioonist 64.

      Puuduvate pistikprogrammide automaatset otsimist ja installimist enam ei toetata.</translation>
<translation id="7267809745244694722">Meediaklahvid on vaikimisi funktsiooniklahvid</translation>
<translation id="7271085005502526897">Kodulehe importimine vaikebrauseri esimesel käitamisel</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="7275334191706090484">Hallatud järjehoidjad</translation>
<translation id="7295019613773647480">Luba valvatavad kasutajad</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="7302043767260300182">Ekraani lukustamise viiteaeg võrgutoite kasutamisel</translation>
<translation id="7311458740754205918">Kui selle väärtuseks määratakse Tõene või seda ei määrata, võidakse uuel vahelehel näidata sisu soovitusi kasutaja sirvimisajaloo, huvide või asukoha põhjal.

      Kui selle väärtuseks määratakse Väär, ei näidata uuel vahelehel automaatselt loodud sisu soovitusi.</translation>
<translation id="7313793931637495417">Reegel määrab, kas edastada versiooniteavet, nagu operatsioonisüsteemi versioon, platvorm ja arhitektuur, rakenduse <ph name="PRODUCT_NAME" /> versioon ja rakenduse <ph name="PRODUCT_NAME" /> kanal.

      Kui reegel on määramata või seatud väärtusele Tõene, kogutakse versiooniteavet.
      Kui reegel on seatud väärtusele Väär, ei koguta versiooniteavet.

      Reegel kehtib ainult juhul, kui laiendus <ph name="CHROME_REPORTING_EXTENSION_NAME" /> on lubatud ja seade on reeglis <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" /> registreeritud.</translation>
<translation id="7323896582714668701">Rakenduse <ph name="PRODUCT_NAME" /> täiendavad käsureaparameetrid</translation>
<translation id="7326394567531622570">Sarnane väärtusega Wipe (väärtus 2), kuid see üritab säilitada sisselogimismärgid, et kasutaja ei peaks uuesti sisse logima.</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="7329968046053403405">Määrab üksuse <ph name="HTTP_NEGOTIATE" /> autentimist (nt Kerberose autentimine) toetava Androidi autentimisrakenduse kontode tüübi. See teave on saadaval autentimisrakenduse pakkuja kaudu. Vaadake lisateavet aadressilt https://goo.gl/hajyfN.

          Kui seadet ei määrata, on üksuse <ph name="HTTP_NEGOTIATE" /> autentimine Androidis keelatud.</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="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="7336878834592315572">Säilita küpsised seansi kestuse jooksul</translation>
<translation id="7337967786223261174">Seadistab printerite loendi.

      Reegel võimaldab administraatoritel kasutajatele printeriseadistusi
      pakkuda.

      <ph name="PRINTER_DISPLAY_NAME" /> ja <ph name="PRINTER_DESCRIPTION" /> on vabas vormis stringid, mida saab kohandada, et hõlbustada printeri valimist. <ph name="PRINTER_MANUFACTURER" /> ja <ph name="PRINTER_MODEL" /> hõlbustavad lõppkasutajate jaoks printerite tuvastamist. Need näitavad printeri tootjat ja mudelit. <ph name="PRINTER_URI" /> peab olema aadress, mida saab klientarvutist (sh <ph name="URI_SCHEME" />, <ph name="URI_PORT" /> ja <ph name="URI_QUEUE" />) külastada. <ph name="PRINTER_UUID" /> on valikuline. Selle olemasolul aitab see seadistus <ph name="ZEROCONF_DISCOVERY" /> printerite duplikaate eemaldada.

      <ph name="PRINTER_EFFECTIVE_MODEL" /> peab vastama ühele stringidest, mis on seotud rakenduses <ph name="PRODUCT_NAME" /> toetatud printeriga. Stringi kasutatakse printeri jaoks sobiva PPD tuvastamiseks ja installimiseks. Lisateavet leiate aadressilt https://support.google.com/chrome?p=noncloudprint.

      Printeri seadistamine viiakse lõpule printeri esimesel kasutamisel. PPD-d laaditakse alla siis, kui printerit kasutatakse. Pärast seda salvestatakse sageli kasutatavad PPD-d vahemällu.

      Reegel ei mõjuta seda, kas kasutajad saavad individuaalsetes seadmetes printereid seadistada. See on mõeldud individuaalsete kasutajate printerite seadistusi täiendama.

      Active Directory hallatavate seadmete puhul toetab see reegel seadme <ph name="MACHINE_NAME_VARIABLE" /> laiendamist Active Directory seadme nimele või selle alamstringile. Näiteks kui seadme nimi on <ph name="MACHINE_NAME_EXAMPLE" />, asendatakse <ph name="MACHINE_NAME_VARIABLE_EXAMPLE" /> nelja tähemärgiga pärast kuuendat märki. <ph name="MACHINE_NAME_PART_EXAMPLE" />. Pange tähele, et loendamist alustatakse nullist.
      Funktsiooni <ph name="MACHINE_NAME_VARIABLE_LOWERCASE" /> (väiketähtedega) tugi on versioonis M71 katkestatud ja funktsioon eemaldatakse versioonist M72.
      </translation>
<translation id="7340034977315324840">Saada teavet seadme aktiivsuse aja kohta</translation>
<translation id="7343497214039883642">Ettevõtte printerite konfiguratsioonifail seadmetele</translation>
<translation id="7349338075015720646">Määrab loendi veebisaitidest, mis installitakse märkamatult, ilma et kasutaja peaks sekkuma.

      Reegli iga loendiüksus on objekt, mis koosneb kahest liikmest: „url” ja „launch_container”. Väärtus „url” peab olema installitava veebirakenduse URL ja „launch_container” peab olema „window” või „tab”, mis näitab, kuidas veebirakendus pärast installimist avatakse. Kui väärtus „launch_container” jäetakse tühjaks ja Chrome peab rakendust progressiivseks veebirakenduseks, avaneb see aknas, muidu avaneb rakendus vahelehel.</translation>
<translation id="735902178936442460">Reegel määrab, kas koguda teavet, mille alusel saab masinaid identifitseerida, nagu masina nimi ja võrguaadressid.

      Kui reegel on määramata või seatud väärtusele Tõene, kogutakse teavet, mille alusel saab masinaid identifitseerida.
      Kui reegel on seatud väärtusele Väär, ei koguta teavet, mille alusel saab masinaid identifitseerida.

      Reegel kehtib ainult juhul, kui laiendus <ph name="CHROME_REPORTING_EXTENSION_NAME" /> on lubatud ja seade on reeglis <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" /> registreeritud.</translation>
<translation id="7367028210010532881">Kui kasutajad satuvad navigeerides saitidele, mis on märgistatud potentsiaalselt pahatahtlikuks, 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.

      Vaadake lisateavet ohutu sirvimise kohta aadressilt https://developers.google.com/safe-browsing.</translation>
<translation id="737655323154569539">Piirab prinditava lehe suurust. Määramata reeglit ja tühja hulka käsitletakse piirangu puudumisena.</translation>
<translation id="7417728346887499628">Kui reegel on keelatud, on Chrome Cleanupil keelatud süsteemi soovimatu tarkvara suhtes skannida ja puhastada. Chrome Cleanupi käsitsi käivitamine aadressil chrome://settings/cleanup on keelatud.

      Kui reegel on lubatud või määramata, skannib Chrome Cleanup regulaarselt süsteemi soovimatu tarkvara suhtes. Soovimatu tarkvara leidmisel küsitakse kasutajalt, kas ta soovib selle eemaldada. Chrome Cleanupi käsitsi käivitamine aadressil chrome://settings on lubatud.

      Reegel ei ole saadaval Windowsi eksemplarides, mis ei ole liidetud teenuse <ph name="MS_AD_NAME" /> domeeniga.</translation>
<translation id="7417972229667085380">Esitlusrežiimis tegevusetu oleku viivituse skaleerimise määr protsentides (tugi on katkestatud)</translation>
<translation id="7421483919690710988">Määrake meediumiketta vahemälu suurus baitides</translation>
<translation id="7424751532654212117">Keelatud pistikprogrammide loendi erandite loend</translation>
<translation id="7426112309807051726">Määrab, kas üksuse <ph name="TLS_FALSE_START" /> optimeerimine peaks olema keelatud. Ajaloolistel põhjustel on selle reegli nimi DisableSSLRecordSplitting.

      Kui reegel on määramata või selle väärtuseks on määratud Väär, siis <ph name="TLS_FALSE_START" /> lubatakse. Kui väärtuseks on määratud Tõene, siis <ph name="TLS_FALSE_START" /> keelatakse.</translation>
<translation id="7433714841194914373">Luba Instant</translation>
<translation id="7443061725198440541">Kui reegel on määramata või lubatud, saab kasutaja õigekirjakontrolli kasutada.

      Kui reegel on keelatud, ei ole kasutajal lubatud õigekirjakontrolli kasutada. Kui reegel on keelatud, eiratakse reeglit SpellcheckLanguage.
      </translation>
<translation id="7443616896860707393">Erineva päritoluga HTTP Basic Authi viibad</translation>
<translation id="7458437477941640506">Ära minge tagasi sihtversioonile, kui operatsioonisüsteemi versioon on uuem kui sihtversioon. Värskendused on samuti keelatud.</translation>
<translation id="7464991223784276288">Vastavatelt URL-idelt pärit küpsisefailide seansipõhine piiramine</translation>
<translation id="7469554574977894907">Luba otsingusoovitused</translation>
<translation id="7474249562477552702">Kas kohalike usaldusvõtmete väljastatud SHA-1 allkirjastatud sertifikaadid on lubatud?</translation>
<translation id="7485481791539008776">Vaikeprinteri valimise reeglid</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="7498946151094347510">Määrab printerid, mida kasutaja ei saa kasutada.

      Seda reeglit kasutatakse ainult siis, kui režiimis <ph name="DEVICE_PRINTERS_ACCESS_MODE" /> on valitud väärtus <ph name="PRINTERS_BLACKLIST" />.

      Selle reegli kasutamisel on kasutajale saadaval kõik printerid, v.a need, mille ID-d on selles reeglis loetletud. ID-d peavad ühtima reeglis <ph name="DEVICE_PRINTERS_POLICY" /> määratud failis olevate väljadega „id” või „guid”.
      </translation>
<translation id="7511361072385293666">Kui reegli väärtuseks määratakse Tõene või seda ei määrata, on QUIC-protokolli kasutamine teenuses <ph name="PRODUCT_NAME" /> lubatud.
      Kui reegli väärtuseks määratakse Väär, on QUIC-protokolli kasutamine keelatud.</translation>
<translation id="7517845714620372896">Määrab ekraani ereduse protsendi.
          Kui reegel on määratud, kohandatakse ekraani algset eredust reegli väärtuse alusel, ent kasutaja saab seda hiljem muuta. Automaatse ereduse funktsioonid keelatakse.
          Kui reegel on määramata, ei mõjuta see kasutaja ekraani juhtelemente ja automaatse ereduse funktsioone.
          Reegli väärtused tuleb määrata protsentidena vahemikus 0–100.</translation>
<translation id="7519251620064708155">Luba võtmete loomine nendel saitidel</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="7529144158022474049">Hajutusteguri automaatne värskendamine</translation>
<translation id="7534199150025803530">See reegel ei mõjuta Androidi Google Drive'i rakendust. Kui soovite keelata Google Drive'i kasutamise mobiilse andmesideühenduse kaudu, peaksite Androidi Google Drive'i rakenduse installimise keelama.</translation>
<translation id="7547549430720182663">Ühenda</translation>
<translation id="7553535237300701827">Kui see reegel on määratud, on sisselogimise autentimisvoog seade väärtusest olenevalt üks järgmistest:

      Kui määratud on GAIA, toimub sisselogimine tavapärase GAIA autentimisvoo kaudu.

      Kui valikuks on määratud SAML_INTERSTITIAL, kuvatakse sisselogimisel vaheekraan, kus kasutajale pakutakse autentimise jätkamist seadme registreerimisdomeeni SAML IdP kaudu või võimalust naasta tavapärasesse GAIA sisselogimisvoogu.</translation>
<translation id="755951849901630953">Kui reegel on määramata või seatud väärtusele Tõene, on teenuse <ph name="PRODUCT_NAME" /> kõigi komponentide värskendused lubatud.

      Kui reegel on seatud väärtusele Väär, on komponentide värskendused keelatud. Teatud komponendid aga ei allu reeglile: komponentide, mis ei sisalda täitmiskoodi või ei mõjuta brauseri käitumist või mis on brauseri turvalisuse seisukohalt hädavajalikud, värskendusi ei keelata.
      Sellised komponendid on näiteks sertifikaatide tühistusloendid ja ohutu sirvimise andmed.
      Vaadake lisateavet ohutu sirvimise kohta aadressilt https://developers.google.com/safe-browsing.</translation>
<translation id="7566878661979235378">SAML-i sisselogimise autentimise tüüp</translation>
<translation id="757395965347379751">Kui see seade on lubatud, lubab <ph name="PRODUCT_NAME" /> SHA-1 allkirjastatud sertifikaate seni, kuni need on valideeritud ja ühtivad kohalikult installitud CA-sertifikaatidega.

      Arvestage sellega, et see reegel oleneb operatsioonisüsteemi sertifikaadi kinnitamise virnast, mis lubab SHA-1 allkirju. Kui OS-i värskendus muudab OS-i SHA-1 sertifikaatide käsitlemist, ei pruugi see reegel enam kehtida.  Lisaks on see reegel ajutine lahendus, et anda ettevõtetele rohkem aega SHA-1-st lahkumiseks.  See reegel eemaldatakse 2019. aasta 1. jaanuari paiku.

      Kui seda reeglit pole määratud või on selle olekuks määratud Väär, siis järgib <ph name="PRODUCT_NAME" /> avalikult väljakuulutatud SHA-1 toe katkestamise graafikut.</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="759957074386651883">Ohutu sirvimise seaded</translation>
<translation id="7604169113182304895">Androidi rakendused võivad vabatahtlikult loendit järgida, ent te ei saa neid selleks sundida.</translation>
<translation id="7612157962821894603">Süsteemiülesed märgistused, mis rakendatakse toote <ph name="PRODUCT_NAME" /> käivitamisel</translation>
<translation id="7614663184588396421">Keelatud protokolliskeemide loend</translation>
<translation id="7617319494457709698">Reegel määrab lubatud laiendused, mis kasutavad kaugatesteerimisel API <ph name="ENTERPRISE_PLATFORM_KEYS_API" /> funktsiooni <ph name="CHALLENGE_USER_KEY_FUNCTION" />. API kasutamiseks tuleb laiendused sellesse loendisse lisada.

          Kui laiendust loendis pole või loendit pole koostatud, siis kõne API-le ebaõnnestub ja saate vastuseks veakoodi.</translation>
<translation id="7618907117929117943">Võimaldab naasta ja jääda sihtversioonile, kui operatsioonisüsteemi versioon on sihtversioonist uuem ja seadme tasemel seadistuse (sh võrgumandaat) saab tagasimineku kaudu üle viia, jättes pärast tagasiminekut vahele ka OOBE. Vältige tagasiminekut või tühistage tagasiminek juhul, kui see ei ole võimalik (kuna sihtversioon ei toeta andmete taastamist või muudatus ei ole tagasiühilduv).
          Seda toetatakse operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> 70. ja uuemates versioonides. Vanemate klientide puhul tähendab väärtus, et tagasiminek on keelatud.</translation>
<translation id="7625444193696794922">Määrab väljalaskekanali, millele seade tuleks lukustada.</translation>
<translation id="7632724434767231364">GSSAPI-teegi nimi</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="7641363659597330616">Seadistab allalaadimiste tüübid, mille <ph name="PRODUCT_NAME" /> täielikult blokeerib, ilma et kasutaja saaks turvaotsust alistada.

      Kui määrate reegli, keelab <ph name="PRODUCT_NAME" /> teatud tüüpi allalaadimised ega võimalda kasutajatel turvahoiatusi eirata.

      Kui valitud on seade „Blokeeri ohtlikud allalaadimised”, on lubatud kõik allalaadimised, v.a need, millega kaasneb ohutu sirvimise hoiatus.

      Kui valitud on seade „Blokeeri potentsiaalselt ohtlikud allalaadimised”, on lubatud kõik allalaadimised, v.a potentsiaalselt ohtlikud ja ohutu sirvimise hoiatusega allalaadimised.

      Kui valitud on seade „Blokeeri kõik allalaadimised”, on kõik allalaadimised blokeeritud.

      Kui reegel on määramata (või valitud on seade „Eripiirangud puuduvad”), kehtivad allalaadimiste puhul tavapärased turvapiirangud, mis põhinevad ohutu sirvimise analüüsi tulemustel.

      Pange tähele, et piirangud kehtivad nii kontekstimenüü valikuga „laadi link alla …” kui ka veebisisust käivitatud allalaadimiste puhul. Piirangud ei kehti praegu kuvatava lehe salvestamise/allalaadimise puhul ega printimisvalikutes PDF-failina salvestamisel.

      Vaadake ohutu sirvimise kohta lisateavet aadressilt https://developers.google.com/safe-browsing.</translation>
<translation id="7643883929273267746">Teenuses <ph name="PRODUCT_NAME" /> nähtavate kontode piiramine</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="7673194325208122247">Ajavahemik (millisekundites)</translation>
<translation id="7676708657861783864">Nendele URL-i mustritele vastavate lehtede seatud küpsisefailid kehtivad ainult praeguse seansi jooksul, st need kustutatakse brauseri sulgemisel.

          Siin määratud mustritele mittevastavate URL-ide (või määramata reegli korral kõikide URL-ide) puhul kasutatakse globaalset vaikeväärtust, mis pärineb reeglist „DefaultCookiesSetting” (kui see on määratud), või kasutaja isiklikku seadistust.

          Pange tähele, et kui <ph name="PRODUCT_NAME" /> töötab taustarežiimis, ei pruugita viimase brauseriakna sulgemisel seanssi katkestada, vaid see jääb aktiivseks, kuni brauser sulgub. Vaadake selle käitumise seadistamise kohta lisateavet reeglist „BackgroundModeEnabled”.

          Vaadake ka reegleid „CookiesAllowedForUrls” ja „CookiesBlockedForUrls”. Pange tähele, et nende kolme reegli vahel ei tohi esineda URL-i mustrite konflikte, kuna eesõigusega reeglit ei ole määratud.

          Kui reegel „RestoreOnStartup” on seadistatud nii, et eelmiste seansside URL-id taastatakse, ei võeta seda reeglit arvesse ja nende saitide küpsisefailid talletatakse jäädavalt.</translation>
<translation id="7683777542468165012">Dünaamiline reeglivärskendus</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="7701341006446125684">Rakenduste ja laienduste vahemälu mahu määramine (baitides)</translation>
<translation id="7709537117200051035">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 tootele <ph name="PRODUCT_NAME" /> sisekasutuseks.</translation>
<translation id="7712109699186360774">Küsi iga kord, kui sait soovib pääseda kaamera ja/või mikrofoni juurde</translation>
<translation id="7713608076604149344">Allalaadimise piirangud</translation>
<translation id="7715711044277116530">Esitlusrežiimis ekraani tumenduse viivituse skaleerimise määr protsentides</translation>
<translation id="7717938661004793600">Seadistage teenuse <ph name="PRODUCT_OS_NAME" /> juurdepääsufunktsioonid.</translation>
<translation id="7724994675283793633">See reegel lubab HTTP/0.9 portides, mis ei ole HTTP puhul 80 ja HTTPS-i puhul 443.

      See reegel on vaikimisi keelatud. Kui see on lubatud, võivad kasutajad kokku puutuda turvaprobleemiga https://crbug.com/600352.

      Selle reegli eesmärk on anda ettevõtetele võimalus eemaldada olemasolevad serverid üksusest HTTP/0.9. See reegel eemaldatakse tulevikus.

      Kui see reegel on määramata, keelatakse HTTP/0.9 mittevaikeportides.</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="7750991880413385988">Ava uus vaheleht</translation>
<translation id="7754704193130578113">Küsi enne iga faili allalaadimist, kuhu see salvestada.</translation>
<translation id="7761446981238915769">Sisselogimisekraanil olevate installitud rakenduste loendi seadistamine</translation>
<translation id="7763479091692861127"> Ü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="7763614521440615342">Kuva uuel vahelehel sisu soovitused</translation>
<translation id="7765879851993224640">Smart Locki kaudu sisselogimise lubamine.</translation>
<translation id="7774768074957326919">Kasuta süsteemi puhverserveri seadeid</translation>
<translation id="7775831859772431793">Siin saate määrata puhverserveri URL-i.

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

          Kui valisite puhverserveri reeglite seadistamiseks muu viisi, jätke see reegel määramata.

          Vaadake lisavalikuid ja üksikasjalikke näiteid siit:
          <ph name="PROXY_HELP_URL" /></translation>
<translation id="7781069478569868053">Uus vaheleht</translation>
<translation id="7788511847830146438">Profiilipõhine</translation>
<translation id="7788872453000173219">
      Soovitame teil vaadata reegli IsolateOrigins seadet, et kasutada nii isoleerimist kui ka piirata mõju kasutajate jaoks, kasutades reeglit IsolateOrigins saitide puhul, mille soovite isoleerida. Seade SitePerProcess isoleerib kõik saidid.
      Kui reegel on lubatud, käitab iga sait siiski oma protsesse.
      Kui reegel on keelatud, ei toimu selget saidi isoleerimist ning reeglite IsolateOrigins ja SitePerProcess testid keelatakse. Kasutajad saavad reegli SitePerProcess siiski käsitsi lubada.
      Kui reegel on seadistamata, saab kasutaja seda seadet muuta.
      Teenuses <ph name="PRODUCT_OS_NAME" /> on soovitatav seadistada ka seadmereegel <ph name="DEVICE_LOGIN_SCREEN_SITE_PER_PROCESS_POLICY_NAME" /> samale väärtusele. Kui kahes reeglis määratud väärtused ei ühti, võib kasutajareegliga määratud väärtuse rakendamisel esineda kasutajaseanssi sisenemisel viivitusi.

      MÄRKUS. Androidis see reegel ei kehti. Androidis reegli SitePerProcess lubamiseks kasutage reegli SitePerProcessAndroid seadet.
      </translation>
<translation id="780603170519840350">Keelab sertifikaadi läbipaistvuse nõuete jõustamise loendisse lisatud atribuudi subjectPublicKeyInfo räside jaoks.

      Reegel võimaldab keelata sertifikaadi läbipaistvuse avalikustamise nõude sertifikaadiahelate puhul, mis hõlmavad mõnd määratud subjectPublicKeyInfo räsiga sertifikaati. See lubab jätkata ettevõtte hostide puhul selliste sertifikaatide kasutamist, mida peetaks muidu ebausaldusväärseks, kuna need ei ole sobival moel avalikustatud.

      Selleks et reegli määramisel sertifikaadi läbipaistvuse jõustamine keelata, peab olema täidetud üks järgmistest tingimustest.
      1. Räsi on seotud serveri sertifikaadi atribuudiga subjectPublicKeyInfo.
      2. Räsi on seotud atribuudiga subjectPublicKeyInfo, mis sisaldub sertifikaadiahela CA-sertifikaadis, CA-sertifikaat on piiratud laiendiga X.509v3 nameConstraints, jaotis permittedSubtrees hõlmab vähemalt üht atribuuti directoryName nameConstraints ja directoryName sisaldab atribuuti organizationName.
      3. Räsi on seotud atribuudiga subjectPublicKeyInfo, mis sisaldub sertifikaadiahela CA-sertifikaadis, CA-sertifikaadi jaotises Subject on vähemalt üks atribuut organizationName ja serveri sertifikaadis on sama palju atribuute organizationName, need on samas järjekorras ja täiesti identsete väärtustega.

      Atribuudi subjectPublicKeyInfo räsi määramiseks liidetakse räsialgoritmi nimi, märk „/” ja räsialgoritmi Base64 kodeering, mis on rakendatud asjakohase sertifikaadi DER-kodeeringuga atribuudile. Base64 kodeering on samas vormingus mis SPKI sõrmejälg, nagu on määratud dokumendi RFC 7469 jaotises 2.4. Tundmatuid räsialgoritme eiratakse. Praegu toetatakse ainult räsialgoritmi „sha256”.

      Kui reegel on määramata, peetakse ebausaldusväärseks kõiki sertifikaate, mille puhul on sertifikaadi läbipaistvuse avalikustamine nõutav, ent millel puudub läbipaistvuse reeglit järgiv avalikustamine.</translation>
<translation id="7818131573217430250">Määrab sisselogimisekraanil kõrge kontrastsusega režiimi vaikeoleku</translation>
<translation id="7822837118545582721">Kui reegel seatakse väärtusele Tõene, ei saa kasutajad välistele salvestusseadmetele kirjutada.

      Kui seade on määratud väärtusele Väär või pole seadistatud, siis saavad kasutajad luua ja muuta faile välistes salvestusseadmetes, mis on füüsiliselt kirjutatavad.

      Reeglil ExternalStorageDisabled on selle reegli suhtes eesõigus – kui reegli ExternalStorageDisabled väärtuseks on määratud Tõene, siis on keelatud kogu juurdepääs välisele salvestusruumile ja reeglit eiratakse.

      Selle reegli dünaamilist värskendamist toetatakse versioonis M56 ja uuemates versioonides.</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="7841880500990419427">Minimaalne TLS-i versioon, millele tagasi minna</translation>
<translation id="7842869978353666042">Google Drive'i valikute seadistamine</translation>
<translation id="787125417158068494">Kui määratud on reegel SyncDisabled või seda ei määrata, pole operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> sertifikaadid ARC-rakenduste jaoks saadaval.

      Kui reegliks on määratud CopyCaCerts, on kõik üksusega <ph name="WEB_TRUSTED_BIT" /> ONC installitud CA-sertifikaadid ARC-rakenduste jaoks saadaval.</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="7882857838942884046">Google'i sünkroonimise keelamisel ei tööta Androidi varunduse ja taastamise funktsioonid korralikult.</translation>
<translation id="7882890448959833986">Toetuseta OS-is hoiatuse blokeerimine</translation>
<translation id="7892077286206685156">
      See reegel kehtib sisselogimiskuval. Vaadake ka reeglit <ph name="SITE_PER_PROCESS_POLICY_NAME" />, mis kehtib kasutajaseansi puhul. Soovitatav on mõlemale reeglile määrata sama väärtus. Kui väärtused ei ühti, võib kasutajareegliga määratud väärtuse rakendamisel esineda kasutajaseanssi sisenemisel viivitusi.
      Soovitame teil vaadata reegli IsolateOrigins seadet, et kasutada nii isoleerimist kui ka piirata mõju kasutajate jaoks, kasutades reeglit IsolateOrigins saitide puhul, mille soovite isoleerida. Seade SitePerProcess isoleerib kõik saidid.
      Kui reegel on lubatud, käitab iga sait siiski oma protsesse.
      Kui reegel on keelatud, ei toimu selget saidi isoleerimist ning reeglite IsolateOrigins ja SitePerProcess testid keelatakse. Kasutajad saavad reegli SitePerProcess siiski käsitsi lubada.
      Kui reegel on seadistamata, saab kasutaja seda seadet muuta.
      </translation>
<translation id="7902255855035461275">Selles loendis olevaid mustreid võrreldakse taotleva URL-i
      algse turvalisusega. Vaste leidmisel antakse juurdepääs
      videosalvestusseadmetele ilma küsimata.

      MÄRKUS. Versioonini 45 toetati seda reeglit ainult kioskirežiimis.</translation>
<translation id="7912255076272890813">Seadista lubatud rakenduste/laienduste tüübid</translation>
<translation id="7915236031252389808">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.

          Kui valisite puhverserveri reeglite seadistamiseks muu viisi, jätke see reegel määramata.

          Vaadake üksikasjalikke näiteid siit:
          <ph name="PROXY_HELP_URL" /></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="7933141401888114454">Järelevalvega kasutajate loomise lubamine</translation>
<translation id="793473937901685727">Sertifikaatide saadavuse määramine ARC-rakenduste jaoks</translation>
<translation id="7937766917976512374">Video jäädvustamise lubamine või keelamine</translation>
<translation id="7941975817681987555">Ära ennusta võrgutoiminguid ühegi võrguühenduse puhul</translation>
<translation id="7952880400776676958">
      Kui reegel on lubatud, käitab iga komadega eraldatud loendis nimetatud lähtekoht
      oma protsesse. See isoleerib ka alamdomeenide
      nimetatud lähtekohad; nt aadressi https://example.com/ määramisel
      isoleeritakse saidi https://example.com/ osana ka aadress
      https://foo.example.com/.
      Kui reegel on keelatud, ei toimu selget saidi isoleerimist ning reeglite IsolateOrigins ja SitePerProcess testid keelatakse. Kasutajad saavad reegli IsolateOrigins siiski käsitsi lubada.
      Kui reegel on seadistamata, saab kasutaja seda seadet muuta.

      MÄRKUS. Androidis on saidi isoleerimine katseline. Aja jooksul täiustatakse tuge, kuid praegu võib see toimivuses probleeme põhjustada.

      MÄRKUS. Reegel kehtib ainult Chrome'i Androidi versiooni puhul seadmetes, millel on rohkem kui 1 GB muutmälu. Androidi-välistel platvormidel reegli kehtestamiseks kasutage reeglit IsolateOriginis.
      </translation>
<translation id="7953256619080733119">Kasutaja käsitsi sisestatavate hostide erandite haldamine</translation>
<translation id="7961779417826583251">Sertifikaadi läbipaistvuse jõustamise keelamine pärandsertimisorganite loendi jaoks</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="7976157349247117979">Teenuse <ph name="PRODUCT_NAME" /> sihtkoha nimi</translation>
<translation id="7980227303582973781">Eripiirangud puuduvad</translation>
<translation id="7985242821674907985"><ph name="PRODUCT_NAME" /></translation>
<translation id="7992136759457836904">Võimaldab juhtida, kas virtuaalsete masinate käitamine Chrome OS-is on lubatud.

      Kui reegel on määratud väärtusele Tõene, lubatakse seadmes käitada virtuaalseid masinaid.
      Kui reegel on määratud väärtusele Väär, ei lubata seadmes virtuaalseid masinaid käitada.
      Kõik kolm reeglit – VirtualMachinesAllowed, CrostiniAllowed ja DeviceUnaffiliatedCrostiniAllowed – peavad olema tõesed, et Crostini käitamine oleks lubatud.
      Kui reegli seade muudetakse väärtusele Väär, kehtib see uute virtuaalsete masinate käivitamisel, ent juba töötavaid virtuaalseid masinaid välja ei lülitata.
      Kui reegel jäetakse hallatavas seadmes määramata, on seadmes virtuaalsete masinate käitamine keelatud.
      Haldamata seadmetes on virtuaalsete masinate käitamine lubatud.</translation>
<translation id="8001701200415781021">Võimaldab piirata, milliseid Google'i kontosid saab määrata teenuses <ph name="PRODUCT_NAME" /> brauseri peamisteks kontodeks</translation>
<translation id="802147957407376460">Ekraani pööramine 0 kraadi</translation>
<translation id="8033913082323846868">See reegel on versioonist M70 eemaldatud, kasutage selle asemel reegleid AutofillAddressEnabled and AutofillCreditCardEnabled.

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="8044493735196713914">Teabe saatmine seadme käivitusrežiimi kohta</translation>
<translation id="8050080920415773384">Printimise omaprotsess</translation>
<translation id="8053580360728293758">Alistab printimisel vaikimisi kasutatava värvirežiimi. Reeglit eiratakse, kui režiim ei ole saadaval.</translation>
<translation id="8059164285174960932">URL, kust kaugjuurdepääsuga kliendid peaksid saama autentimismärgi</translation>
<translation id="8078366200175825572">Võimaldab teil määrata URL-i mustrite loendi, mis määrab saidid, millel on keelatud küpsisefaile 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 seadistust.

Vaadake ka reegleid „CookiesAllowedForUrls” ja „CookiesSessionOnlyForUrls”. Pange tähele, et nende kolme reegli vahel ei tohi esineda URL-i mustrite konflikte, kuna eesõigusega reeglit ei ole määratud.</translation>
<translation id="8099880303030573137">Jõudeoleku viiteaeg akutoite kasutamisel</translation>
<translation id="8102913158860568230">Meediavoo vaikeseade</translation>
<translation id="8104186956182795918">Võimaldab määrata, kas veebisaitidel on lubatud pilte kuvada. Piltide kuvamise võib kõikidel veebisaitidel lubada või keelata.

          Kui seda reeglit ei määrata, siis kasutatakse atribuuti „AllowImages” ja kasutaja saab seda muuta.

          Pange tähele, et reegel oli seni Androidis ekslikult lubatud, ent seda funktsiooni ei ole Androidis kunagi täielikult toetatud.</translation>
<translation id="8104962233214241919">Valige automaatselt kliendi sertifikaadid nendele saitidele</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="8114382167597081590">Ära jõusta YouTube'is piiratud režiimi</translation>
<translation id="8118665053362250806">Määra meediaketta vahemälu maht</translation>
<translation id="8124468781472887384">Seadmete printerite seadistuse juurdepääsu reegel.</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="8138009212169037227">Reegel määrab, kas edastada reegli andmed ja reegli toomise aeg.

      Kui reegel on määramata või seatud väärtusele Tõene, kogutakse reegli andmed ja reegli toomise aeg.
      Kui reegel on seatud väärtusele väär, ei koguta reegli andmeid ja reegli toomise aega.

      Reegel kehtib ainult juhul, kui laiendus <ph name="CHROME_REPORTING_EXTENSION_NAME" /> on lubatud ja seade on reeglis <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" /> registreeritud.</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="8141795997560411818">See reegel ei takista kasutajatel Androidi Google Drive'i rakenduse kasutamist. Kui soovite keelata juurdepääsu Google Drive'ile, peaksite ka Androidi Google Drive'i rakenduse installimise keelama.</translation>
<translation id="8142894094385450823">Hallatud seansi jaoks soovitatavate lokaatide määramine</translation>
<translation id="8146727383888924340">Lubage kasutajatel pakkumisi lunastada Chrome OS-i registreerimise kaudu</translation>
<translation id="8148785525797916822">Blokeerib hoiatuse, mis kuvatakse, kui teenust <ph name="PRODUCT_NAME" /> käitatakse arvutis või operatsioonisüsteemis, mida enam ei toetata.</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="815061180603915310">Kui reegel on lubatud, sunnib see aktiveerima profiili ajutise režiimi. Kui reegel määratakse operatsioonisüsteemi reeglina (nt GPO Windowsis), rakendatakse see süsteemi kõikidele profiilidele. Kui aga reegel määratakse pilvereeglina, rakendatakse see ainult hallatud kontoga sisse logitud profiilile.

      Selles režiimis säilitatakse profiiliandmeid kettal ainult kasutajaseansi ajal. Pärast brauseri sulgemist ei säilitata sirvimisajalugu, laiendeid, nende andmeid ega veebiandmeid, näiteks küpsisefaile või veebiandmebaase. See aga ei takista kasutajal andmeid kettale käsitsi alla laadida, lehti salvestada ega neid printida.

      Kui kasutaja on sünkroonimise lubanud, säilitatakse kõik need andmed tema sünkroonimisprofiilil, täpselt nagu tavapäraste profiilide puhul. Ka inkognito režiim on saadaval, kui see ei ole reegliga sõnaselgelt keelatud.

      Kui keelate reegli või jätate selle määramata, suunatakse kasutaja sisselogimisel tavapärasele profiilile.</translation>
<translation id="8158758865057576716">Lubatakse teenuse <ph name="PRODUCT_NAME" /> profiiliandmete puhul rändluskoopiate loomine.</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="8176035528522326671">Luba ettevõtte kasutajal olla ainult peamine mitme profiiliga kasutaja (vaikekäitumine ettevõtte hallatud kasutajate puhul)</translation>
<translation id="8214600119442850823">Seadistatakse paroolihaldur.</translation>
<translation id="8244525275280476362">Maksimaalne toomisviivitus pärast reegli kehtetuks tunnistamist</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="8259375588339409826">Nii Chromium kui ka Google Chrome toetavad sama reeglite komplekti. Pange tähele, et see dokument võib sisaldada avaldamata reegleid (seega kirje „toetatud versioonis” viitab rakenduse <ph name="PRODUCT_NAME" /> veel avaldamata versioonile) ja sellised reeglid võivad ette teatamata muutuda või need võidakse eemaldada ning nende puhul ei pakuta mingeid garantiisid (sh turvalisuse ja privaatsusega seotud garantiid).


Need reeglid on mõeldud ainult teie organisatsioonisiseste teenuse <ph name="PRODUCT_NAME" /> eksemplaride seadistamiseks. Nende reeglite kasutamist väljaspool organisatsiooni (nt avalikult levitatavas programmis) loetakse pahavaraks ja tõenäoliselt märgivad selle pahavaraks ka Google ja viirusetõrjepakkujad.

Neid seadeid ei pea käsitsi seadistama. Hõlpsalt kasutatavad mallid Windowsile, Macile ja Linuxile on allalaadimiseks saadaval siin: <ph name="POLICY_TEMPLATE_DOWNLOAD_URL" />.

Soovituslik viis selle reegli seadistamiseks Windowsis on GPO kaudu, kuigi reegli varustamist registri kaudu toetatakse endiselt Windowsi eksemplarides, mis on liidetud domeeniga <ph name="MS_AD_NAME" />.</translation>
<translation id="8264653492961233132">Määrab loendi rakendustest ja laiendustest, mis installitakse vaikimisi
          ning kasutajaga suhtlemata ja mida kasutaja ei saa desinstallida
          ega keelata. Kõik rakenduste/laienduste taotletud
          load antakse vaikimisi ning kasutajaga suhtlemata
          (sh kõik lisaload, mida rakenduse/laienduse tulevased versioonid
          taotlevad). Load antakse ka laienduste API-dele enterprise.deviceAttributes
          ja enterprise.platformKeys. (Need kaks API-t pole saadaval
          rakendustele/laiendustele, mis pole sundinstallitud.)

          See reegel seatakse ettepoole potentsiaalselt konfliktsest reeglist <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" />. Kui rakendus või laiendus, mis varem sundinstalliti, sellest loendist eemaldatakse, siis desinstallib rakendus <ph name="PRODUCT_NAME" /> selle automaatselt.

          Windowsi eksemplaride puhul, mis ei ole ühendatud domeeniga <ph name="MS_AD_NAME" />, saab sundinstallida vaid Chrome’i veebipoes olevaid rakendusi ja laiendusi.

          Pange tähele, et arendaja tööriistadega saavad kasutajad muuta iga laienduse lähtekoodi (mis võib põhjustada laienduse väärtalitlust). Kui see on probleem, tuleb määrata reegel <ph name="DEVELOPER_TOOLS_POLICY_NAME" />.

          Reegli iga loendiüksus 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, mis kuvatakse näiteks arendajarežiimis aadressil <ph name="CHROME_EXTENSIONS_LINK" />. „Värskenduse” URL peab viitama XML-dokumendi värskendusmanifestile, nagu on kirjeldatud jaotises <ph name="LINK_TO_EXTENSION_DOC1" />. Vaikimisi kasutatakse Chrome'i veebipoe värskenduse URL-i (praegu „https://clients2.google.com/service/update2crx”). Pange tähele, et reeglis määratud „värskenduse” URL-i kasutatakse vaid algsel installimisel ja laienduse tulevased värskendused kasutavad laienduse manifestis märgitud värskenduse URL-i. Samuti pange tähele, et selgesõnalise „värskenduse” URL-i määramine oli kuni rakenduse <ph name="PRODUCT_NAME" /> 67. versioonini kohustuslik.

          Näiteks reegel <ph name="EXTENSION_POLICY_EXAMPLE" /> installib rakenduse <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME" /> standardselt Chrome’i veebipoe „värskenduse” URL-ilt. Lisateavet hostimise laienduste kohta leiate siit: <ph name="LINK_TO_EXTENSION_DOC2" />.

          Kui see reegel jäetakse määramata, ei installita automaatselt mitte ühtegi rakendust ega laiendust ja kasutaja saab iga rakenduse või laienduse desinstallida rakenduses <ph name="PRODUCT_NAME" />.</translation>
<translation id="8274603902181597201">Kasutaja süsteemi eCryptfs juurkataloogi tühjendamine ja uue ext4-krüpteeringuga juurkataloogiga alustamine.</translation>
<translation id="8285435910062771358">Täisekraani luup on lubatud</translation>
<translation id="8288199156259560552">Androidi Google'i asukohateenuse lubamine</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="8300455783946254851">Keelab Google Drive’i sünkroonimise operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> rakenduses Failid, kui kasutatakse mobiilset andmesidet ja reegli olekuks on määratud Tõene. Sellisel juhul sünkroonitakse andmeid Google Drive’iga ainult siis, kui seade on ühendatud WiFi või Etherneti kaudu.

          Kui reegel on määramata või seatud väärtusele Väär, saavad kasutajad teisaldada faile Google Drive’i, kasutades mobiilset andmesidet.</translation>
<translation id="8300992833374611099">Määrake, kus saab arendaja tööriistu kasutada</translation>
<translation id="8312129124898414409">Võimaldab määrata, kas veebisaitidel on lubatud võtmeid luua. Võtmete loomise saab kõikide veebisaitide jaoks lubada või keelata.

          Kui jätate reegli määramata, kasutatakse reeglit „BlockKeygen” ja kasutaja saab seda muuta.</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="8339420913453596618">Teine tegur on keelatud</translation>
<translation id="8344454543174932833">Impordi järjehoidjad vaikebrauserist esmakordsel käitamisel</translation>
<translation id="8359734107661430198">Luba ExampleDeprecatedFeature API kuni 02.09.2008</translation>
<translation id="8367209241899435947">Chrome Cleanupi lubamine Windowsis</translation>
<translation id="8369602308428138533">Ekraani väljalülitamise viiteaeg võrgutoite kasutamisel</translation>
<translation id="8371178326720637170">Lubab hallatud laiendustel kasutada ettevõtte riistvara platvormi API-t</translation>
<translation id="8382184662529825177">Kaugatesteerimise lubamine seadme sisu kaitsmiseks</translation>
<translation id="838870586332499308">Luba andmeside rändlusteenus</translation>
<translation id="8390049129576938611">Keelab sisemise PDF-vaaturi rakenduses <ph name="PRODUCT_NAME" />. Selle asemel koheldakse seda allalaadimisena ja kasutaja saab PDF-faile vaikerakendusega avada.

      Kui keelate reegli või jätate selle määramata, kasutatakse PDF-failide avamiseks PDF-i pistikprogrammi, välja arvatud juhul, kui kasutaja selle keelab.</translation>
<translation id="8402079500086185021">Ava PDF-failid alati väliselt</translation>
<translation id="8412312801707973447">Kontrolli võrgus OCSP-d/CRL-i</translation>
<translation id="8417305981081876834">Lukustuskuva PIN-koodi maksimumpikkuse määramine</translation>
<translation id="841977920223099909">Paroolikaitse hoiatuse käivitaja</translation>
<translation id="8424255554404582727">Määratakse ekraani vaikepöördenurk, mis rakendatakse uuesti igal taaskäivitamisel</translation>
<translation id="8426231401662877819">Ekraani pööramine 90 kraadi päripäeva</translation>
<translation id="8433423491036718210">Seadistage ettevõtte sisselogimis-URL-ide loend, kus paroolikaitseteenus peaks parooli sõrmejälje jäädvustama.</translation>
<translation id="8451988835943702790">Kasuta avalehena Uut vahelehte</translation>
<translation id="8459216513698220096">Määrab, kas ja kuidas töödeldakse arvuti GPO-st pärinevaid kasutajareegleid.

      Kui reegli väärtuseks määratakse „Default” või see jäetakse määramata, loetakse kasutajareegleid ainult kasutaja GPO-dest (arvuti GPO-sid eiratakse).

      Kui reegli väärtuseks määratakse „Merge”, liidetakse kasutaja GPO-des olevad kasutajareeglid arvuti GPO-des olevate kasutajareeglitega (eelistatakse arvuti GPO-sid).

      Kui reegli väärtuseks määratakse „Replace”, asendatakse kasutaja GPO-des olevad kasutajareeglid arvuti GPO-des olevate kasutajareeglitega (kasutaja GPO-sid eiratakse).</translation>
<translation id="8465065632133292531">Parameetrid Instant-URL-i jaoks, mis kasutab POST-meetodit</translation>
<translation id="847472800012384958">Keela kõikidel saitidel hüpikakende näitamine</translation>
<translation id="8477885780684655676">TLS 1.0</translation>
<translation id="8483004350080020634">Eemaldatakse protokolli https:// URL-ide privaatsuse ja turvalisusega seotud tundlikud osad enne, kui need saadetakse PAC-skriptidele (puhverserveri automaatne seadistamine), mida teenus <ph name="PRODUCT_NAME" /> puhverserveri lahendamisel kasutab.

      Kui reegli väärtuseks määratakse Tõene, on turvafunktsioon lubatud ja protokolli
      https:// URL-id eemaldatakse enne nende saatmist PAC-skriptidele. Sel viisil
      ei näe PAC-skriptid andmeid, mida tavaliselt kaitseb krüpteeritud kanal
      (nt URL-i tee ja päring).

      Kui reegli väärtuseks määratakse Väär, on see turvafunktsioon keelatud
      ja PAC-skriptid näevad protokolli https:// URL-i kõiki komponente.
      See seade kehtib kõikide PAC-skriptide puhul, olenemata nende päritolust
      (sh need, mis tuuakse ebaturvalise transportimise käigus või avastatakse
      ebaturvaliselt WPAD kaudu).

      Selle vaikeväärtus on Tõene (turvafunktsioon on lubatud).

      Soovitatav on selle väärtuseks määrata Tõene. Ainus põhjus, mis selle väärtuseks
      määrata Väär, on see, kui see põhjustab olemasolevate PAC-skriptidega ühilduvusprobleeme.

      Reegel eemaldatakse versioonis M75.</translation>
<translation id="8484458986062090479">Kohandab loendit URL-i mustritest, mille peab alati renderdama hostbrauser.

          Kui seda reeglit ei määrata, 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="8493645415242333585">Keela brauseri ajaloo salvestamine</translation>
<translation id="8498293625012059298">Seadistage parooli muutmise URL (ainult HTTP- ja HTTPS-skeemid). Kui kasutaja näeb brauseris hoiatust, saadab paroolikaitseteenus ta sellele URL-ile, et ta saaks oma parooli muuta.
      Selleks et <ph name="PRODUCT_NAME" /> talletaks parooli muutmise lehel uue parooli sõrmejälje õigesti, peab teie parooli muutmise leht järgima aadressil https://www.chromium.org/developers/design-documents/create-amazing-password-forms olevaid juhiseid.

      Kui see seade on lubatud, saadab paroolikaitseteenus brauseris hoiatust näinud kasutajad sellele URL-ile, et nad saaksid oma parooli muuta.
      Kui see seade on keelatud või määramata, saadab paroolikaitseteenus kasutajad parooli muutmiseks saidile https://myaccounts.google.com.
      See reegel ei ole saadaval Windowsi eksemplarides, mis pole domeeniga <ph name="MS_AD_NAME" /> liitunud.</translation>
<translation id="8499172469244085141">Vaikeseaded (kasutajad saavad alistada)</translation>
<translation id="8507835864888987300">Määrab automaatsete värskenduste sihtversiooni.

      Määrab eesliite sihtversioonile, millele operatsioonisüsteem <ph name="PRODUCT_OS_NAME" /> peaks värskendama. Kui seadmes käitatakse versiooni, mis on määratud eesliitest varasem, värskendatakse see uusimale antud eesliitega versioonile. Kui seadmes käitatakse juba uusimat versiooni, olenevad mõjud üksuse <ph name="DEVICE_ROLLBACK_TO_TARGET_VERSION_POLICY_NAME" /> väärtusest. Eesliite vorming toimib komponendipõhiselt, nagu järgmises näites näha võib.

      "" (seadistamata): saadaval on värskendus uusimale versioonile.
      "1412.": värskendus mis tahes 1412 uuemale versioonile (nt 1412.24.34 või 1412.60.2)
      "1412.2.": värskendus mis tahes 1412.2 uuemale versioonile (nt 1412.2.34 või 1412.2.2)
      "1412.24.34": värskendus ainult sellele konkreetsele versioonile

      Hoiatus. Me ei soovita versioonide piiranguid seadistada, kuna need võivad takistada kasutajatel tarkvaravärskendusi ja kriitilisi turvapaikasid vastu võtmast. Kui lubate vaid teatud versiooni eesliite, võib see kasutajad ohtu seada.</translation>
<translation id="8519264904050090490">Kasutaja käsitsi sisestatavate URL-ide erandite haldamine</translation>
<translation id="8538235451413605457">Seadistab rakenduse <ph name="PRODUCT_NAME" /> minimaalse lubatud versiooni nõude. Sellest vanemad versioonid loetakse aegunuks ja seade ei luba kasutajal sisse logida enne, kui OS-i on värskendatud.
      Kui praegune versioon aegub kasutaja seansi ajal, logitakse kasutaja välja.

      Kui see reegel on määramata, siis piiranguid ei rakendata ja kasutaja saab sisse logida rakenduse <ph name="PRODUCT_NAME" /> versioonist olenemata.

      Siin võib „versioon” tähendada nii täpset versiooninumbrit „61.0.3163.120” kui ka versiooni eesliidet „61.0”  </translation>
<translation id="8544375438507658205">Rakenduse <ph name="PRODUCT_FRAME_NAME" /> HTML-i vaikerenderdaja</translation>
<translation id="8544465954173828789">SMS-ide sünkroonimise lubamine telefoni ja Chromebooki vahel</translation>
<translation id="8548832052135586762">Lubab ainult värvilise või mustvalge printimise või eemaldab värvirežiimi piirangu. Määramata reeglit käsitletakse piirangu puudumisena.</translation>
<translation id="8549772397068118889">Hoiatamine sisupakettidest väljaspool olevate saitide külastamisel</translation>
<translation id="8566842294717252664">Veebipoe peitmine uuel vahelehel ja rakenduste käivitajas</translation>
<translation id="857369585509260201">Selle reegli tugi on katkestatud, kaaluge selle asemel reegli BrowserSignin kasutamist.

      Kui reegel määratakse väärtusele Tõene, peab kasutaja enne brauseri kasutamist teenusesse <ph name="PRODUCT_NAME" /> oma profiiliga sisse logima. Samuti määratakse reegli BrowserGuestModeEnabled vaikeväärtuseks Väär. Pange tähele, et olemasolevad allkirjastamata profiilid lukustatakse ja nendele ei pääse pärast selle reegli lubamist juurde. Lisateavet leiate abikeskuse artiklist.

      Kui reegel määratakse väärtusele Väär või jäetakse seadistamata, saab kasutaja brauserit kasutada teenusesse <ph name="PRODUCT_NAME" /> sisse logimata.</translation>
<translation id="8586528890725660268">Määrab printerid, mida kasutaja ei saa kasutada.

      Seda reeglit kasutatakse ainult siis, kui režiimis <ph name="BULK_PRINTERS_ACCESS_MODE" /> on valitud väärtus <ph name="PRINTERS_BLACKLIST" />.

      Selle reegli kasutamisel on kasutajale saadaval kõik printerid, v.a need, mille ID-d on selles reeglis loetletud. ID-d peavad ühtima reeglis <ph name="BULK_PRINTERS_POLICY" /> määratud failis olevate väljadega „id” või „guid”.
      </translation>
<translation id="8587229956764455752">Luba uute kasutajakontode loomine</translation>
<translation id="8598350264853261122">Kui reegli olekuks on määratud Väär, ei lubata seoseta kasutajatel ARC-i kasutada.

      Kui reegel on määramata või määratud väärtusele Tõene, tohivad kõik kasutajad ARC-i kasutada (kui ARC ei ole muul viisil keelatud).

      Reegli muudatused rakendatakse ainult siis, kui ARC ei tööta, st Chrome OS-i käivitamisel.</translation>
<translation id="8615400197788843468">Lubab rakenduse <ph name="PRODUCT_NAME" /> piiratud sisselogimise funktsiooni G Suite'is ja takistab kasutajaid seadet muutmast.

      Kui määrate selle seade, pääseb kasutaja Google'i rakendustele
      juurde ainult määratud domeenide kontodega (pange tähele, et
      domeeni gmail.com/googlemail.com kontode lubamiseks tuleb teil lisada
      domeenide loendisse kirje „consumer_accounts” (ilma jutumärkideta)).

      Seade EI takista kasutajat sisse logimast hallatud seadmes,
      mis nõuab Google'i autentimist. Kasutajal on lubatud muudelt
      domeenidelt pärit kontodele sisse logida, ent nende kontodega
      G Suite'i kasutades kuvatakse veateade.

      Kui jätate seade tühjaks/seadistamata, on G Suite'i kasutamine
      lubatud kõikide kontodega.

      Reegli kasutamisel lisatakse kõigile google.com-i domeenidele edastatavate
      HTTP- ja HTTPS-taotlustele päis X-GoogApps-Allowed-Domains, nagu on
      kirjeldatud aadressil https://support.google.com/a/answer/1668854.

      Kasutajad ei saa seadet muuta ega alistada.</translation>
<translation id="8631434304112909927">versioonini <ph name="UNTIL_VERSION" /></translation>
<translation id="863319402127182273">Androidi rakenduste puhul mõjutab see reegel ainult sisseehitatud kaamerat. Kui selle reegli väärtuseks on määratud Tõene, on kaamera ilma eranditeta keelatud kõigi Androidi rakenduste puhul.</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="8650974590712548439">Windowsi registri asukoht Windowsi klientide puhul:</translation>
<translation id="8654286232573430130">Määrab, millised serverid tuleb integreeritud autentimiseks lisada lubatud üksuste loendisse. Integreeritud autentimine on saadaval vaid siis, kui toode <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 <ph name="PRODUCT_NAME" /> tuvastada, kas server on intranetis, ja alles siis vastab IWA taotlustele. Kui server tuvastatakse Internetis, siis eirab <ph name="PRODUCT_NAME" /> sealt tulevaid IWA taotlusi.</translation>
<translation id="8669669491594628013">Võimaldab teil juhtida paroolikaitse hoiatuse käivitamist. Paroolikaitse hoiatab kasutajaid, kui nad kasutavad oma kaitstud parooli potentsiaalselt kahtlastel saitidel.

      Kaitstava parooli määramiseks võite kasutada reegleid „PasswordProtectionLoginURLs” ja „PasswordProtectionChangePasswordURL”.


      Kui reegli väärtuseks määratakse „PasswordProtectionWarningOff”, siis paroolikaitse hoiatusi ei kuvata.
      Kui reegli väärtuseks määratakse „PasswordProtectionWarningOnPasswordReuse”, kuvatakse paroolikaitse hoiatused siis, kui kasutajad kasutavad oma kaitstud parooli saitidel, mis ei kuulu lubatud saitide loendisse.
      Kui reegli väärtuseks määratakse „PasswordProtectionWarningOnPhishingReuse”, kuvatakse paroolikaitse hoiatus siis, kui kasutajad kasutavad oma kaitstud parooli andmepüügisaitidel.
      Kui see reegel jäetakse määramata, kaitseb paroolikaitse ainult Google'i paroole, ent kasutaja saab seda seadet muuta.</translation>
<translation id="8672321184841719703">Automaatse värskendamise sihtversioon</translation>
<translation id="867410340948518937">U2F (universaalne teine tegur)</translation>
<translation id="8682611302223077049">Võimaldab määrata ajavahemiku (millisekundites), mille jooksul antakse kasutajatele teada, et ootel oleva värskenduse rakendamiseks tuleb <ph name="PRODUCT_NAME" /> või operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> seade taaskäivitada.

      Selle vahemiku jooksul teavitatakse kasutajat värskendusest korduvalt. Operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> seadmete puhul kuvatakse värskenduse tuvastamisel taaskäivituse märguanne süsteemisalves. Brauseri <ph name="PRODUCT_NAME" /> puhul rakenduse menüü muutub, kui kolmandik ajavahemikust on möödunud, ja näitab, et rakendus on vaja taaskäivitada. Märguanne muudab esimest korda värvi siis, kui möödunud on kaks kolmandikku ajavahemikust, ja teist korda ajavahemiku lõpus. Reegliga <ph name="RELAUNCH_NOTIFICATION_POLICY_NAME" /> lubatud lisamärguanded järgivad sama ajakava.

      Kui reegel on määramata, kasutatakse vaikeperioodi, mis on operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> seadmete puhul 345 600 000 millisekundit (neli päeva) ja brauseri <ph name="PRODUCT_NAME" /> puhul 604 800 000 millisekundit (üks nädal).</translation>
<translation id="8685024486845674965">Paroolikaitse hoiatuse käivitab parooli uuesti kasutamine</translation>
<translation id="8693243869659262736">Kasuta sisseehitatud DNS-i klienti</translation>
<translation id="8704831857353097849">Keelatud pistikprogrammide loend</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="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="8733448613597049197">Lubab teenuse <ph name="PRODUCT_NAME" /> ohutu sirvimise laiendatud aruandluse ega luba kasutajatel seadet muuta.

      Laiendatud aruandlus saadab Google'i serveritesse teatud süsteemiteavet ja lehe sisu, et aidata tuvastada ohtlikke rakendusi ja saite.

      Kui seade on määratud väärtusele Tõene, siis luuakse ja saadetakse aruanded vajaduse korral (näiteks kui kuvatakse turvalisust puudutav vahekuva).

      Kui seade on määratud väärtusele Väär, siis aruandeid ei saadeta.

      Kui reegel on määratud väärtusele Tõene või Väär, ei saa kasutaja seda seadet muuta.

      Kui see reegel jäetakse määramata, saab kasutaja seadet muuta ja otsustada, kas aruandeid saata või mitte.

      Vaadake ohutu sirvimise kohta lisateavet aadressilt https://developers.google.com/safe-browsing.</translation>
<translation id="8736538322216687231">Jõusta YouTube'is minimaalselt piiratud režiim</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="8759829385824155666">Lubatud Kerberose krüpteerimistüübid</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="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="8798099450830957504">Vaikimisi</translation>
<translation id="8801680448782904838">Kasutaja teavitamine brauseri või seadme soovitatavast või kohustuslikust taaskäivitamisest</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="8818768076343557335">Ennustage võrgutegevus kõigis võrkudes peale mobiilsidevõrgu.
          (Iganenud alates versioonist 50, eemaldatud alates versioonist 52. Kui hilisemas kui 52. versioonis määratakse väärtus 1, tõlgendatakse seda kui väärtust 0 – võrgutegevuste ennustamine mis tahes võrguühenduse puhul.)</translation>
<translation id="8825782996899863372">Paroolikaitse hoiatuse käivitab parooli uuesti kasutamine andmepüügilehel</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="8833109046074170275">GAIA vaikevoo kaudu autentimine</translation>
<translation id="8838303810937202360">Operatsioonisüsteem <ph name="PRODUCT_OS_NAME" /> lisab rakendused ja laiendused mitme kasutaja jaoks installimiseks seadme vahemällu, et vältida iga kasutaja puhul uuesti allalaadimist.
      Kui see reegel on seadistamata või väärtus on väiksem kui 1 MB, kasutab operatsioonisüsteem <ph name="PRODUCT_OS_NAME" /> vaikimisi vahemälu mahtu.</translation>
<translation id="8858642179038618439">YouTube’i ohutu režiimi jõustamine</translation>
<translation id="8860342862142842017">Sertifikaadi läbipaistvuse jõustamise keelamine atribuudi subjectPublicKeyInfo räside loendi jaoks</translation>
<translation id="8864975621965365890">Keelab tagasilükkamisviiba, mis kuvatakse, kui saiti renderdab <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="8867464911288727016">Lubab brauseris <ph name="PRODUCT_NAME" /> Google'i tõlke integreeritud teenuse.

      Kui selle seade lubate, pakub <ph name="PRODUCT_NAME" /> kasutajale tõlkefunktsiooni, kuvades paremklõpsu kontekstimenüüs integreeritud tõlke tööriistariba (võimaluse korral) ja tõlkevaliku.

      Kui selle seade keelate, keelatakse kõik sisseehitatud tõlkefunktsioonid.

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

      Kui see seade jäetakse seadistamata, saab kasutaja otsustada, kas funktsiooni kasutada või mitte.</translation>
<translation id="8870318296973696995">Avaleht</translation>
<translation id="8876188741456358123">Alistab printimisel vaikimisi kasutatava dupleksrežiimi. Reeglit eiratakse, kui režiim ei ole saadaval.</translation>
<translation id="8882006618241293596">Blokeeri nendel saitidel pistikprogramm <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="890403179930035128">Sundlubab õigekirjakontrolli keeled. Loendis olevaid tundmatuid keeli eiratakse.

      Kui lubate reegli, lubatakse õigekirjakontroll määratud keelte jaoks, mis lisanduvad keeltele, mille jaoks kasutaja on õigekirjakontrolli lubanud.

      Kui jätate reegli määramata või keelate selle, ei mõjuta see kasutaja õigekirjakontrolli eelistusi.

      Kui reegel SpellcheckEnabled on keelatud, ei ole sellel mingit mõju.

      Praegu toetatakse järgmisi keeli: af, bg, ca, cs, da, de, el, en-AU, en-CA, en-GB, en-US, es, es-419, es-AR, es-ES, es-MX, es-US, et, fa, fo, fr, he, hi, hr, hu, id, it, ko, lt, lv, nb, nl, pl, pt-BR, pt-PT, ro, ru, sh, sk, sl, sq, sr, sv, ta, tg, tr, uk, vi.</translation>
<translation id="8906768759089290519">Luba külastajarežiim</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="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="891435090623616439">kodeeritud JSON-stringina. Lisateavet vaadake saidilt <ph name="COMPLEX_POLICIES_URL" /></translation>
<translation id="8934944553121392674">Juhib, millised printerid on reegli <ph name="DEVICE_PRINTERS_POLICY" /> puhul kasutajatele saadaval.

      Määrab, millist juurdepääsureeglit kasutatakse printerite hulgiseadistamiseks. Kui valitud on väärtus <ph name="PRINTERS_ALLOW_ALL" />, kuvatakse kõik printerid. Kui valitud on väärtus <ph name="PRINTERS_BLACKLIST" />, kasutatakse määratud printeritele juurdepääsu piiramiseks reeglit <ph name="DEVICE_PRINTERS_BLACKLIST" />. Kui valitud on väärtus <ph name="PRINTERS_WHITELIST" />, määrab reegel <ph name="DEVICE_PRINTERS_WHITELIST" /> ainult need printerid, mida saab valida.

      Kui see reegel on määramata, kasutatakse väärtust <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="8938932171964587769">Reegel on versioonist M69 eemaldatud. Kasutage selle asemel reeglit
      OverrideSecurityRestrictionsOnInsecureOrigin.

      Reegel määrab lähtekohtade (URL-id) või hostinimede mustrid (nt
      „*.example.com”), mille puhul ei kehti ebaturvaliste lähtekohtade
      turvapiirangud.

      Selle eesmärk on võimaldada organisatsioonidel lisada lubatud loendisse 
      pärandrakendusi, mis ei saa TLS-i juurutada, või seadistada sisese
      veebiarenduse jaoks kontrollserveri, et arendajad saaksid testida turvalist
      konteksti nõudvaid funktsioone ilma kontrollserverisse TLS-i juurutamata.
      Reegel takistab ka omnikastikeses lähtekohale märke „Ebaturvaline” lisamist.

      Selles reeglis URL-ide loendi määramisel on sama mõju mis samadest
      URL-idest koosnevale komaeraldusega loendile käsurea märgistuse
      „--unsafely-treat-insecure-origin-as-secure” määramisel. Kui reegel on
      määratud, alistab see käsurea märgistuse.

      Reegel on versioonis M69 asendatud reegliga
      OverrideSecurityRestrictionsOnInsecureOrigin. Kui mõlemad reeglid on
      kasutusel, alistab OverrideSecurityRestrictionsOnInsecureOrigin selle
      reegli.

      Turvaliste kontekstide kohta saate lisateavet aadressilt
      https://www.w3.org/TR/secure-contexts/
      </translation>
<translation id="8942616385591203339">Reegel määrab, kas kasutajale võib esimesel sisselogimisel kuvada sünkroonimise nõusoleku. Kui kasutaja ei pea kunagi sünkroonimiseks nõusolekut andma, tuleb reegli väärtuseks määrata Väär.
      Kui reegel on seatud väärtusele Väär, ei kuvata sünkroonimise nõusolekut.
      Kui reegel on määramata või seatud väärtusele Tõene, võidakse kuvada sünkroonimise nõusolek.</translation>
<translation id="8947415621777543415">Esita seadme asukoht</translation>
<translation id="8951350807133946005">Vahemälu kataloogi seadmine</translation>
<translation id="8952317565138994125">Keelab teenuses <ph name="PRODUCT_NAME" /> andmete sünkroonimise Google'i hostitavate sünkroonimisteenuste kaudu ja takistab kasutajaid seda seadet muutmast.

      Kui lubate selle seade, ei saa kasutajad seda teenuses <ph name="PRODUCT_NAME" /> muuta ega alistada.

      Kui jätate reegli määramata, saavad kasutajad valida, kas nad soovivad Google Synci kasutada.

      Google Synci täielikuks keelamiseks on soovitatav keelata Google Synci teenus Google'i administraatorikonsoolil.

      Reeglit ei tohi lubada juhul, kui reegel <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> on lubatud, kuna sellel on samad kliendipoolsed funktsioonid. Google'i hostitav sünkroonimine keelatakse sel juhul täielikult.</translation>
<translation id="8955719471735800169">Tagasi üles</translation>
<translation id="8959992920425111821">Vaikeseadistus</translation>
<translation id="8960850473856121830">Selles loendis olevaid mustreid võrreldakse taotleva URL-i
      algse turvalisusega. Vaste leidmisel antakse juurdepääs
      helisalvestusseadmetele ilma küsimata.

      MÄRKUS. Versioonini 45 toetati seda reeglit ainult kioskirežiimis.</translation>
<translation id="8970205333161758602">Toote <ph name="PRODUCT_FRAME_NAME" /> tagasilükkamisviiba keelamine</translation>
<translation id="8976248126101463034">Gnubby autentimise lubamine kaugjuurdepääsuhostidele</translation>
<translation id="8976531594979650914">Kasuta vaikeseadena süsteemi vaikeprinterit</translation>
<translation id="898520305112996948">Võimaldab luua URL-i mustrite loendi, mis määrab saidid, millele antakse automaatselt luba määratud tootja ja toote ID-ga USB-seadmetele juurdepääsemiseks. Selleks et reegel kehtiks, peab iga loendis olev üksus olema kehtiv. Iga seadmete hulgas olev üksus võib hõlmata tootja ID ja toote ID välja. Väljajäetud ID-sid koheldakse metamärgina ühe erandiga: toote ID-d ei saa ilma tootja ID-ta määrata. Muidu on reegel kehtetu. Kehtetuid väärtusi eiratakse.

        Kui reegel jäetakse määramata, kasutatakse kõigi saitide puhul globaalset vaikeväärtust, mis põhineb reeglil „DefaultWebUsbGuardSetting” (kui see on määratud) või kasutaja isiklikul konfiguratsioonil.

        Selle reegli URL-i mustrid ei tohi olla vastuolus reegli WebUsbBlockedForUrls kaudu seadistatud mustritega. Vastuolu korral alistab see reegel reeglid WebUsbBlockedForUrls ja WebUsbAskForUrls.</translation>
<translation id="8992176907758534924">Keela kõigil saitidel kujutiste näitamine</translation>
<translation id="9012851181124311976">Seadistage ettevõtte sisselogimis-URL-ide loend (ainult HTTP- ja HTTPS-skeemid). Parooli sõrmejälg jäädvustatakse nendel URL-idel ja seda kasutatakse parooli uuesti kasutamise tuvastamiseks.
      Selleks et <ph name="PRODUCT_NAME" /> jäädvustaks paroolide sõrmejäljed õigesti, veenduge, et teie sisselogimislehed järgiksid aadressil https://www.chromium.org/developers/design-documents/create-amazing-password-forms olevaid juhiseid.

      Kui see seade on lubatud, jäädvustab paroolikaitseteenus nendel URL-idel parooli sõrmejälje, et tuvastada parooli uuesti kasutamine.
      Kui seade on keelatud või määramata, jäädvustab paroolikaitseteenus parooli sõrmejälje ainult saidil https://accounts.google.com.
      See reegel ei ole saadaval Windowsi eksemplarides, mis pole domeeniga <ph name="MS_AD_NAME" /> liitunud.</translation>
<translation id="9035964157729712237">Mustast nimekirjast välistatud laienduste ID-d</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="9077227880520270584">Seadme kohaliku konto automaatse sisselogimise taimer</translation>
<translation id="9084985621503260744">Määrake, kas videotoimingud mõjutavad toitehaldust</translation>
<translation id="9088433379343318874">Jälgitava kasutaja sisupakkuja lubamine</translation>
<translation id="9088444059179765143">Ajavööndi automaatse tuvastamise viisi seadistamine</translation>
<translation id="9094064873808699479">Võimaldab naasta ja jääda sihtversioonile, kui operatsioonisüsteemi versioon on sihtversioonist uuem. Proovige võimaluse korral seadme tasemel seadistus (sh võrgumandaat) tagasiminekuprotsessi kaudu üle viia, ent tehke seejuures täielik Powerwash, isegi kui andmete taastamine ei ole võimalik (kuna sihtversioon ei toeta andmete taastamist või muudatus ei ole tagasiühilduv).
          Seda toetatakse alates operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> 70. versioonist. Vanemate klientide puhul tähendab väärtus, et tagasiminek on keelatud.</translation>
<translation id="9096086085182305205">Autentimisserveri lubatud nimekiri</translation>
<translation id="9098553063150791878">HTTP autentimise reeglid</translation>
<translation id="9105265795073104888">Androidi rakendustele muudetakse kättesaadavaks ainult puhverserveri seadistuse valikute alamkomplekt. Androidi rakenduste jaoks on puhverserveri kasutamine vabatahtlik. Te ei saa puhverserveri kasutamist sundida.</translation>
<translation id="9106865192244721694">Reegli WebUSB lubamine nendel saitidel</translation>
<translation id="9112727953998243860">Ettevõtte printerite konfiguratsioonifail</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="9123211093995421438">Määrab teenuse <ph name="PRODUCT_OS_NAME" /> verstapostide miinimumarvu alates millal tahes välja lastud stabiilsest versioonist, mille puhul on tagasiminek lubatud.

      Vaikeväärtus tarbija jaoks on 0, ettevõttes registreeritud seadmete puhul 4 (ligikaudu pool aastat).

      Reegli määramine takistab tagasiminekukaitse rakendumist vähemalt selle verstapostide arvu puhul.

      Reegli jaoks väiksema väärtuse määramisel on püsiv mõju: seadmes EI pruugi olla võimalik minna tagasi varasemate versioonide juurde isegi pärast suurema väärtuse määramist.

      Tegelikud tagasimineku võimalused olenevad ka emaplaadist ja kriitiliste turvaaukude paikadest.</translation>
<translation id="913195841488580904">URL-ide loendile juurdepääsu blokeerimine</translation>
<translation id="9135033364005346124">Teenuse <ph name="CLOUD_PRINT_NAME" /> puhverserveri lubamine</translation>
<translation id="9136399279941091445">Väljalülitatud aegade intervallid, kui määratud seadme reeglid avaldatakse</translation>
<translation id="9147029539363974059">Saadab süsteemilogid haldusserverisse, et administraatorid
      saaksid süsteemilogisid jälgida.

      Kui reegel seatakse väärtusele Tõene, saadetakse süsteemilogid serverisse. Kui reegel seatakse
      väärtusele Väär või jäetakse määramata, ei saadeta süsteemilogisid.</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="915194831143859291">Kui reegel on määramata või seatud väärtusele Väär, lubab <ph name="PRODUCT_OS_NAME" /> kasutajal seadme välja lülitada.
      Kui reegel on seatud väärtusele Tõene ja kasutaja lülitab seadme välja, taaskäivitab <ph name="PRODUCT_OS_NAME" /> seadme. <ph name="PRODUCT_OS_NAME" /> asendab kasutajaliidese kõik väljalülitamisnupud taaskäivitusnuppudega. Kui kasutaja lülitab seadme toitenupuga välja, ei taaskäivitata seda automaatselt, isegi kui reegel on lubatud.</translation>
<translation id="9152473318295429890">Seotud veebilehtede kontekstipõhiste soovituste lubamine</translation>
<translation id="9158929520101169054">Brauseris mitmele kontole sisselogimise lubamine</translation>
<translation id="9159126470527871268">Võimaldab anda kasutajatele teada, et ootel oleva värskenduse rakendamiseks tuleb <ph name="PRODUCT_NAME" /> või <ph name="PRODUCT_OS_NAME" /> taaskäivitada.

      See reegli seade lubab märguanded, mis annavad kasutajale teada, et brauseri või seadme taaskäivitamine on soovitatav või kohustuslik. Kui reegel on määramata, teavitab <ph name="PRODUCT_NAME" /> kasutajat menüüs ilmuvate väikeste muutuste abil, <ph name="PRODUCT_OS_NAME" /> kasutab teavitamiseks süsteemisalves kuvatavat märguannet. Kui reegel on seatud väärtusele „Soovitatav”, kuvatakse kasutajale korduvalt soovitatava taaskäivitamise hoiatus. Kasutaja saab taaskäivitamise edasilükkamiseks hoiatusest loobuda. Kui reegel on seatud väärtusele „Nõutav”, kuvatakse kasutajale korduvalt hoiatus, mis annab teada, et brauser sundtaaskäivitatakse pärast märguandeperioodi möödumist. Vaikeperiood on rakenduse <ph name="PRODUCT_NAME" /> puhul seitse päeva ja operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> puhul neli päeva ning seda saab reegli <ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" /> seade abil muuta.

      Pärast taaskäivitamist kasutaja seanss taastatakse.</translation>
<translation id="9165792353046089850">Võimaldab määrata, kas veebisaitidel on juurdepääs ühendatud USB-seadmetele. Juurdepääsu saab täielikult blokeerida või küsida kasutaja käest iga kord luba, kui veebisait soovib juurdepääsu ühendatud USB-seadmetele.

          Selle reegli saab teatud URL-i mustrite puhul alistada, kasutades reegleid „WebUsbAskForUrls” ja „WebUsbBlockedForUrls”.

          Kui reegel jäetakse määramata, kasutatakse väärtust „3” ja kasutaja saab seda muuta.</translation>
<translation id="9167719789236691545">Drive'i keelamine operatsioonisüsteemi <ph name="PRODUCT_OS_NAME" /> rakenduses Failid</translation>
<translation id="9187743794267626640">Keela välismäluseadmete ühendamine</translation>
<translation id="9197740283131855199">Ekraani tumenduse viivituse skaleerimise määr protsentides, kui kasutaja muutub pärast tumendamist aktiivseks.</translation>
<translation id="9200828125069750521">Parameetrid POST-meetodit kasutava kujutise URL-i jaoks</translation>
<translation id="920209539000507585">Saate printimisdialoogis päised ja jalused sundlubada või -keelata.

      Kui reegel on määramata, saab kasutaja otsustada, kas printida päised ja jalused.

      Kui reegel on seatud väärtusele Väär, ei ole seade „Päised ja jalused” printimise eelvaate dialoogis valitud ja kasutaja ei saa seda muuta.

      Kui reegel on seatud väärtusele Tõene, on seade „Päised ja jalused” printimise eelvaate dialoogis valitud ja kasutaja ei saa seda muuta.</translation>
<translation id="9210953373038593554">Seadistab SAML-i sisselogimiste autentimise tüübi.

      Kui reegel on määramata või seatud vaikeväärtusele (0), määrab brauser olenevalt muudest teguritest SAML-i sisselogimiste käitumise. Kõige tavapärasema stsenaariumi korral põhineb kasutajate autentimine ja vahemällu talletatud kasutajaandmete kaitse paroolidel, mille kasutajad käsitsi sisestavad.

      Kui reegel on seatud väärtusele ClientCertificate (1), kasutatakse äsja lisatud ja SAML-i kaudu sisse logivate kasutajate puhul kliendi sertifikaadi autentimist. Selliste kasutajate puhul ei kasutata paroole ja nende vahemällu talletatud kohalikke andmeid kaitstakse vastavate krüptovõtmetega. See seade võimaldab näiteks seadistada kiipkaardipõhise autentimise (pange tähele, et kiipkaardi vaherakendused tuleb installida reegli DeviceLoginScreenAppInstallList kaudu).

      Reegel mõjutab ainult kasutajaid, kes kasutavad autentimiseks SAML-i.</translation>
<translation id="9213347477683611358">Seadistage seadmetasemel taustapildi kujutis, mis kuvatakse sisselogimisekraanil, kui ükski kasutaja pole veel seadmesse sisse loginud. Selle reegli määramiseks tuleb määrata URL, kust Chrome OS-i seade saab alla laadida taustapildi kujutise ja krüptograafilise räsiväärtuse, mida kasutatakse allalaadimise terviklikkuse kontrollimiseks. Kujutis peab olema JPEG-vormingus ja faili suurus ei tohi ületada 16 MB. URL peab olema autentimiseta juurdepääsetav. Taustapildi kujutis laaditakse alla ja salvestatakse vahemällu. See laaditakse uuesti alla iga kord, kui URL või räsiväärtus muutub.

      Reegel tuleks määrata stringina, mis näitab URL-i ja räsiväärtust JSON-vormingus, nt
      {
        "url": "https://example.com/device_wallpaper.jpg",
        "hash": "examplewallpaperhash"
      }

      Kui seadme taustapildi reegel on määratud, laadib Chrome OS-i seade taustapildi kujutise alla ja kasutab seda sisselogimisekraanil, kui ükski kasutaja pole veel seadmesse sisse loginud. Kui kasutaja sisse logib, rakendatakse kasutaja taustapildi reeglit.

      Kui seadme taustapildi reegel on määramata, otsustab kasutaja taustapildi reegel, mida näidata, kui kasutaja taustapildi reegel on määratud.</translation>
<translation id="9217154963008402249">Võrgupakettide jälgimise sagedus</translation>
<translation id="922540222991413931">Seadistage laienduste, rakenduste ja kasutaja skriptide installimise allikad</translation>
<translation id="924557436754151212">Impordi salvestatud paroolid vaikebrauserist esimesel käitamisel</translation>
<translation id="930930237275114205">Määra rakenduse <ph name="PRODUCT_FRAME_NAME" /> kasutaja andmekataloog</translation>
<translation id="944817693306670849">Ketta vahemälu mahu määramine</translation>
<translation id="981346395360763138">Google'i asukohateenused on keelatud</translation>
<translation id="982497069985795632">Õigekirjakontrolli lubamine</translation>
<translation id="988537626274109600">See reegel juhib ajaperioode, mille jooksul ei tohi operatsioonisüsteemiga <ph name="PRODUCT_OS_NAME" /> seade automaatselt värskendusi kontrollida.
      Kui selle reegli väärtuseks on määratud mis tahes ajavahemikud, toimub järgmine.
      Seadmed ei saa nendel konkreetsetel ajavahemikel automaatselt värskendusi kontrollida. Seadmeid, mis tuleb viia vanemale versioonile või mis kasutavad vanemat kui minimaalset nõutavat versiooni <ph name="PRODUCT_OS_NAME" />, see reegel võimalike turvaohtude tõttu ei mõjuta. Lisaks ei blokeeri see reegel kasutajate või administraatorite taotletud värskenduste kontrolle.
      Kui see reegel on määramata või ei sisalda ajavahemikke, toimub järgmine.
      See reegel automaatseid värskenduste kontrolle ei blokeeri, kuid muud reeglid võivad seda teha.</translation>
</translationbundle>