<?xml version="1.0" ?>
<!DOCTYPE translationbundle>
<translationbundle lang="sl">
<translation id="1002439864875515590">Če je ta pravilnik nastavljen na prazen niz ali ni konfiguriran, sistem <ph name="PRODUCT_OS_NAME" /> med potekom prijave uporabnika ne bo prikazal možnosti samodokončanja.
      Če je ta pravilnik nastavljen na niz, ki predstavlja ime domene, bo <ph name="PRODUCT_OS_NAME" /> pri prijavi uporabnika prikazal možnost samodokončanja, s čimer bo uporabniku omogočeno, da vnese samo uporabniško ime brez končnice imena domene.  Uporabnik bo lahko prepisal končnico tega imena domene.
      Če vrednost pravilnika ni veljavna domena, pravilnik ne bo uporabljen.</translation>
<translation id="101438888985615157">Sukanje zaslona za 180 stopinj</translation>
<translation id="1016912092715201525">Konfigurira privzeta preverjanja brskalnika v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom preprečuje, da bi jih spremenili.

      Če omogočite to nastavitev, bo brskalnik <ph name="PRODUCT_NAME" /> ob zagonu vedno preveril, ali je privzeti brskalnik, in se samodejno registriral, če bo to mogoče.

      Če je ta nastavitev onemogočena, brskalnik <ph name="PRODUCT_NAME" /> ne bo nikoli preveril, ali je privzeti brskalnik, in bo onemogočil uporabniške kontrolnike za nastavitev te možnosti.

      Če ta nastavitev ni nastavljena, bo brskalnik <ph name="PRODUCT_NAME" /> uporabniku omogočal nadzor nad tem, ali je privzeti brskalnik in ali naj bodo uporabniku prikazana obvestila, če ni privzeti brskalnik.

      Opomba za skrbnike sistema <ph name="MS_WIN_NAME" />: omogočanje te nastavitve bo delovalo samo za računalnike s sistemom Windows 7. Pri različicah sistema Windows od različice 8 naprej morate uvesti datoteko s »povezavami s privzetimi programi«, ki poskrbi, da je <ph name="PRODUCT_NAME" /> rutina za obravnavo protokolov <ph name="HHTPS_PROTOCOL" /> in <ph name="HTTP_PROTOCOL" /> (in, izbirno, protokola <ph name="FTP_PROTOCOL" /> ter oblik datotek, kot so <ph name="HTML_EXTENSION" />, <ph name="HTM_EXTENSION" />, <ph name="PDF_EXTENSION" />, <ph name="SVG_EXTENSION" />, <ph name="WEBP_EXTENSION" /> ipd.). Več informacij je na voljo tukaj: <ph name="SUPPORT_URL" />.</translation>
<translation id="1017967144265860778">Upravljanje porabe na zaslonu za prijavo</translation>
<translation id="1019101089073227242">Nastavitev imenika za uporabniške podatke</translation>
<translation id="1022361784792428773">ID-ji razširitev, katerih namestitev je treba uporabniku preprečiti (ali * za vse)</translation>
<translation id="102492767056134033">Nastavitev privzetega stanja zaslonske tipkovnice na zaslonu za prijavo</translation>
<translation id="1027000705181149370">Določi, ali se piškotki za preverjanje pristnosti, ki jih pri prijavi nastavi SAML IdP, prenesejo v uporabnikov profil.

      Ko uporabnik pri prijavi potrdi pristnost prek SAML IdP, se piškotki, ki jih nastavi IdP, najprej zapišejo v začasni profil. Te piškotke je mogoče prenesti v uporabnikov profil, da ohranijo stanje preverjanja pristnosti.

      Če je ta pravilnik omogočen, se piškotki, ki jih nastavi IdP, v uporabnikov profil prenesejo vsakič, ko uporabnik pri prijavi potrdi pristnost prek SAML IdP.

      Če je ta pravilnik onemogočen ali ni nastavljen, se piškotki, ki jih nastavi IdP, prenesejo v uporabnikov profil samo pri prvi prijavi uporabnika v napravi.

      Ta pravilnik vpliva na uporabnike, katerih domena se ujema samo z domeno za včlanitev naprave. Pri vseh drugih uporabnikih se piškotki, ki jih nastavi IdP, prenesejo v uporabnikov profil samo pri prvi prijavi uporabnika v napravi.</translation>
<translation id="1029052664284722254">Vsili vnovični zagon ob odjavi uporabnika</translation>
<translation id="1030120600562044329">Omogoča anonimno sporočanje podatkov o uporabi in zrušitvah brskalnika <ph name="PRODUCT_NAME" /> Googlu in uporabnikom preprečuje spreminjanje te nastavitve.

      Če je ta nastavitev omogočena, se bodo podatki o uporabi in zrušitvah
      anonimno pošiljali Googlu.  Če je onemogočena, se ti podatki ne bodo
      pošiljali Googlu.  Uporabniki v obeh primerih nastavitve ne morejo spremeniti ali preglasiti.
      Če ta pravilnik ni nastavljen, bo veljala nastavitev, ki jo je uporabnik
      izbral ob namestitvi oziroma prvem zagonu.

      Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.
      (Za OS Chrome glejte pravilnik DeviceMetricsReportingEnabled.)</translation>
<translation id="1035385378988781231">Ta pravilnik nadzira, ali bo funkcija omrežnih naprav za skupno rabo datotek za brskalnik <ph name="PRODUCT_NAME" /> uporabljala protokol NTLM za preverjanje pristnosti.

      Če je ta pravilnik omogočen, bo protokol NTLM po potrebi uporabljen za preverjanje pristnosti datotečnih sredstev SMB v skupni rabi.
      Če je ta pravilnik onemogočen, bo protokol NTLM za datotečna sredstva SMB v skupni rabi onemogočen.

      Če pravilnik ni nastavljen, bo funkcija privzeto onemogočena za uporabnike, ki jih upravlja podjetje, in omogočena za uporabnike, ki niso upravljani.</translation>
<translation id="1040446814317236570">Omogočanje odstranjevanja elementov iz URL-jev za skripte PAC (za https://)</translation>
<translation id="1044878202534415707">Poročanje statističnih podatkov o strojni opremi, kot je poraba CPE-ja/RAM-a.

      Če je pravilnik onemogočen, se statistični podatki ne poročajo.
      Če je pravilnik omogočen ali ni nastavljen, se statistični podatki poročajo.</translation>
<translation id="1046484220783400299">Začasno omogočanje zastarelih funkcij spletnega okolja</translation>
<translation id="1047128214168693844">Nobenemu mestu ne dovoli spremljanja fizične lokacije uporabnika</translation>
<translation id="1049138910114524876">Konfigurira jezik, uveljavljen na zaslonu za prijavo brskalnika <ph name="PRODUCT_OS_NAME" />.

      Če je ta pravilnik nastavljen, bo zaslon za prijavo vedno prikazan v jeziku, ki ga posreduje prva vrednost tega pravilnika (pravilnik je opredeljen kot seznam za združljivost vnaprej). Če ta pravilnik ni nastavljen ali je nastavljen na prazen seznam, je zaslon za prijavo prikazan v jeziku zadnje uporabniške seje. Če je ta pravilnik nastavljen na vrednost, ki ni veljaven jezik, bo zaslon za prijavo prikazan v rezervnem jeziku (trenutno je to ameriška angleščina, en-US).</translation>
<translation id="1052499923181221200">Ta pravilnik ne vpliva na nič, če ni omogočen pravilnik SamlInSessionPasswordChangeEnabled.
      Če je omogočen tisti pravilnik, ta pravilnik pa nastavljen (na primer) na 14, bodo uporabniki prijave SAML obveščeni o poteku gesla 14 dni pred določenim datumom poteka.
      Nato lahko takoj odpravijo težavo, tako da med sejo opravijo spremembo gesla in posodobijo geslo, preden poteče.
      Toda ta obvestila bodo prikazana samo, če podatke o poteku gesla v napravo pošlje ponudnik identitete za prijavo SAML med potekom prijave SAML.
      Če nastavite ta pravilnik na nič, uporabniki ne bodo vnaprej obveščeni – obveščeni bodo šele po poteku gesla.

      Če je ta pravilnik nastavljen, ga uporabniki ne morejo spremeniti ali preglasiti.</translation>
<translation id="1062011392452772310">Omogoči oddaljeno potrditev naprave</translation>
<translation id="1062407476771304334">Zamenjaj</translation>
<translation id="1079801999187584280">Prepoved uporabe orodij za razvijalce</translation>
<translation id="1087437665304381368">Ta pravilnik nadzira samo način za razvijalce sistema <ph name="PRODUCT_OS_NAME" />. Če želite preprečiti dostop do možnosti za razvijalce za Android, morate nastaviti pravilnik <ph name="DEVELOPER_TOOLS_DISABLED_POLICY_NAME" />.</translation>
<translation id="1093082332347834239">Če je ta nastavitev omogočena, se gostitelj za oddaljeno pomoč izvaja v procesu z dovoljenji <ph name="UIACCESS_PERMISSION_NAME" />. Tako lahko oddaljeni uporabniki uporabljajo okna s skrbniškimi pravicami na namizju lokalnega uporabnika.

          Če je ta nastavitev onemogočena ali ni konfigurirana, se gostitelj za oddaljeno pomoč izvaja v uporabnikovem kontekstu in oddaljeni uporabniki ne morejo uporabljati oken s skrbniškimi pravicami na namizju.</translation>
<translation id="1096105751829466145">Privzeti iskalnik</translation>
<translation id="1099282607296956954">Omogočanje osamitve spletnega mesta za vsako spletno mesto</translation>
<translation id="1100570158310952027">
      Pravilnik določa seznam izvorov (URL-jev) ali vzorcev imen gostitelja (na primer
      »*.example.com«), za katere se varnostne omejitve v izvorih, ki niso varni,
      ne uporabljajo.

      Namen tega je omogočiti organizacijam nastavitev izvorov, uvrščenih na seznam dovoljenih, za starejše
      aplikacije, ki ne morejo uvesti šifriranja TLS, ali nastavitev preizkusnega produkcijskega strežnika
      za notranje spletno razvijanje, tako da lahko razvijalci preizkušajo funkcije,
      ki zahtevajo varne kontekste, ne da bi bilo treba uvesti TLS v preizkusnem produkcijskem
      strežniku. Ta pravilnik prav tako prepreči, da bi imel izvor v naslovni vrstici
      oznako »Ni varno«.

      Nastavitev seznama URL-jev v tem pravilniku ima enak učinek kot nastavitev
      zastavice ukazne vrstice »--unsafely-treat-insecure-origin-as-secure« na seznamu,
      ločenemu z vejicami, istih URL-jev. Če je pravilnik nastavljen,
      preglasi zastavico ukazne vrstice.

      Ta pravilnik preglasi pravilnik UnsafelyTreatInsecureOriginAsSecure, če je na voljo.

      Več informacij o varnih kontekstih je na voljo na
      https://www.w3.org/TR/secure-contexts/.
      </translation>
<translation id="1107764601871839136">Določa življenjsko dobo predpomnjenja (v urah) predmetov pravilnika skupine (GPO). Namesto vnovičnega prenosa GPO-jev pri vsakem prenosu pravilnika, lahko sistem znova uporabi predpomnjene GPO-je, če se njihova različica ne spremeni. Ta pravilnik določa najdaljši dovoljen čas, v katerem se sme uporabiti predpomnjene GPO-je, preden so znova preneseni. Ob vnovičnem zagonu in odjavi se predpomnilnik izbriše.

      Če pravilnik ni nastavljen, je mogoče predpomnjene uporabnike znova uporabiti v obdobju do 25 ur.

      Če je pravilnik nastavljen na 0, je predpomnjenje GPO izklopljeno. Upoštevajte, da se s tem poveča obremenjenost strežnika, saj so GPO-ji znova preneseni ob vsakem prenosu pravilnika, tudi če se niso spremenili.</translation>
<translation id="1117462881884985156"><ph name="PRODUCT_NAME" /> bo obšel vse strežnike proxy za seznam gostiteljev, naveden tukaj.

          Ta pravilnik velja le, če ste v »Izberite, kako določiti nastavitve strežnika proxy« izbrali ročne nastavitve strežnika proxy in če pravilnik <ph name="PROXY_SETTINGS_POLICY_NAME" /> ni bil določen.

          Če ste za nastavitve pravilnikov za strežnik proxy izbrali drug način, tega pravilnika ne nastavljajte.

          Če želite podrobnejše primere, obiščite:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="1117535567637097036">Rutine za obravnavo protokolov, nastavljene s tem pravilnikom, se ne uporabljajo pri obravnavi namer za Android.</translation>
<translation id="1118093128235245168">Dovoli spletnim mestom, da od uporabnika zahtevajo, da omogoči dostop do povezane naprave USB</translation>
<translation id="1128903365609589950">Konfigurira imenik, ki ga bo <ph name="PRODUCT_NAME" /> uporabljal za shranjevanje predpomnjenih datotek na disk.

      Če ta pravilnik nastavite, bo <ph name="PRODUCT_NAME" /> uporabljal navedeni imenik ne glede na to, ali je uporabnik določil zastavico »--disk-cache-dir« ali ne. Če se želite izogniti izgubi podatkov ali drugim nepričakovanim napakam, tega pravilnika ne nastavite na korenski imenik pogona ali imenik, ki ga uporabljate za druge namene, ker <ph name="PRODUCT_NAME" /> upravlja njegovo vsebino.

      Seznam spremenljivk, ki jih je mogoče uporabiti, si lahko ogledate na https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Če tega pravilnika ne nastavite, bo uporabljen privzeti imenik za shranjevanje predpomnjenih datotek in uporabnik ga bo lahko preglasil z zastavico »--disk-cache-dir« v ukazni vrstici.</translation>
<translation id="113521240853905588">Konfigurira jezike, ki jih je mogoče uporabiti kot prednostne jezike sistema <ph name="PRODUCT_OS_NAME" />.

      Če je ta pravilnik nastavljen, lahko uporabnik na seznam prednostnih jezikov doda samo en jezik, naveden v tem pravilniku. Če ta pravilnik ni nastavljen ali je nastavljen na prazen seznam, lahko uporabnik določi jezike po želji. Če je ta pravilnik nastavljen na seznam neveljavnih vrednosti, so vse neveljavne vrednosti prezrte. Če je uporabnik na seznam prednostnih jezikov dodal nekatere jezike, ki jih ta pravilnik ne dovoljuje, bodo ti odstranjeni. Če je uporabnik konfiguriral sistem <ph name="PRODUCT_OS_NAME" /> tako, da je prikazan v enem od jezikov, ki jih ta pravilnik ne dovoljuje, bo prikazni jezik ob naslednji prijavi uporabnika preklopljen na dovoljen jezik uporabniškega vmesnika. V nasprotnem primeru bo sistem <ph name="PRODUCT_OS_NAME" /> preklopil na prvo veljavno vrednost, ki jo določa ta pravilnik, ali na rezervni jezik (trenutno je to ameriška angleščina, en-US), če ta pravilnik vsebuje samo neveljavne vnose.</translation>
<translation id="1135264353752122851">Konfigurira, katere postavitve tipkovnice so dovoljene za uporabniške seje sistema <ph name="PRODUCT_OS_NAME" />.

      Če je ta pravilnik nastavljen, lahko uporabnik izbere samo enega od načinov vnosa, ki jih določa ta pravilnik. Če ta pravilnik ni nastavljen ali je nastavljen na prazen seznam, lahko uporabnik izbere vse podprte načine vnosa. Če trenutnega načina vnosa pravilnik ne dovoljuje, bo način vnosa preklopljen na strojno postavitev tipkovnice (če je dovoljena) ali prvi veljaven vnos na tem seznamu. Vsi neveljavni ali nepodprti načini vnosa na tem seznamu bodo prezrti.</translation>
<translation id="1138294736309071213">Ta pravilnik je aktiven samo v maloprodajnem načinu.

      Določa trajanje, preden se za naprave v maloprodajnem načinu na zaslonu za prijavo pokaže phranjevalnik zaslona.

      Vrednost pravilnika mora biti v milisekundah.</translation>
<translation id="1141767714195601945">Ta pravilnik nadzira parametre ukazne vrstice za zagon Chroma iz Internet Explorerja.

      Če dodatek za Internet Explorer »Podpora za starejše brskalnike« ni nameščen, ta pravilnik nima vpliva.

      Če ta pravilnik ni nastavljen, Internet Explorer zgolj posreduje URL Chromu kot parameter ukazne vrstice.

      Če je ta pravilnik nastavljen na seznam nizov, so nizi združeni s presledki in posredovani Chromu kot parametri ukazne vrstice.

      Če kateri element vsebuje ${url}, ga nadomesti URL strani, ki naj bo odprta.

      Če noben element ne vsebuje ${url}, je URL pripet na koncu ukazne vrstice.

      Spremenljivke okolja so razširjene. V sistemu Windows %ABC% nadomesti vrednost spremenljivke okolja ABC.</translation>
<translation id="1151353063931113432">Dovoli slike na teh mestih</translation>
<translation id="1152117524387175066">Poročanje o stanju stikala za razvijalce naprave ob zagonu.

      Če je pravilnik nastavljen na »False«, se o stanju stikala za razvijalce ne poroča.</translation>
<translation id="1160479894929412407">Dovoli protokol QUIC</translation>
<translation id="1160939557934457296">Onemogoči nadaljevanje z opozorilne strani varnega brskanja</translation>
<translation id="1189817621108632689">Omogoča nastavitev seznama vzorcev URL-jev, s katerim so določena spletna mesta, ki jim ni dovoljeno prikazovati slik.

         Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena globalna privzeta vrednost iz pravilnika »DefaultImagesSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.

          Ta pravilnik je bil prej zmotno omogočen v Androidu, vendar ta funkcija ni bila nikoli v celoti podprta v Androidu.</translation>
<translation id="1194005076170619046">Če je ta pravilnik omogočen, je v sistemski vrstici prikazan velik rdeč gumb za odjavo, ko je seja aktivna in zaslon ni zaklenjen.

      Če je ta pravilnik onemogočen ali ni določen, v sistemski vrstici ni velikega rdečega gumba za odjavo.</translation>
<translation id="1197437816436565375">Aplikacij za Android ni mogoče prisiliti, da bi uporabljale strežnik proxy. Aplikacije za Android imajo na voljo podnabor nastavitev strežnika proxy, ki jih lahko prostovoljno upoštevajo. Če želite več podrobnosti, glejte pravilnik <ph name="PROXY_MODE_POLICY_NAME" />.</translation>
<translation id="1198465924256827162">Kako pogosto se pošljejo nalaganja stanja naprave (v milisekundah).

      Če ta pravilnik ni nastavljen, je vrednost privzete pogostosti 3 ure. Najmanjša
      dovoljena vrednost pogostosti je 60 sekund.</translation>
<translation id="1204263402976895730">Omogočeni tiskalniki v podjetjih</translation>
<translation id="1216919699175573511">Omogočanje podpore za podpisano izmenjavo HTTP (SXG)</translation>
<translation id="1219695476179627719">Določa, ali naj se naprava povrne na različico, ki jo določa pravilnik <ph name="DEVICE_TARGET_VERSION_PREFIX_POLICY_NAME" />, če se v njej že izvaja novejša različica.

      Privzeta nastavitev je RollbackDisabled (povrnitev onemogočena).</translation>
<translation id="1221359380862872747">Naloži določene URL-je v predstavitveni seji</translation>
<translation id="1223789468190631420">Omogočeno stanje Varnega brskanja za zaupanja vredne vire</translation>
<translation id="122899932962115297">Seznam dovoljenih, ki upravlja, katere hitre načine odklepanja lahko uporabnik nastavi in uporablja za odklepanje zaklenjenega zaslona.

          Ta vrednost je seznam nizov; veljavni vnosi na seznamu so: "all" (vsi), "PIN" (koda PIN), "FINGERPRINT" (prstni odtis). Če na seznam dodate vnos "all" (vsi), so uporabniku na voljo vsi hitri načini odklepanja, vključno s tistimi, ki bodo uvedeni v prihodnosti. V nasprotnem primeru bodo na voljo samo hitri načini odklepanja s seznama.

          Če želite na primer dovoliti vse hitre načine odklepanja, uporabite ["all"] (vsi). Če želite dovoliti samo odklepanje s kodo PIN, uporabite ["PIN"] (koda PIN). Če želite dovoliti odklepanje s kodo PIN in prstnim odtisom, uporabite ["PIN", "FINGERPRINT"]. Če želite onemogočiti vse hitre načine odklepanja, uporabite [].

          Za upravljane naprave privzeto ni na voljo noben hiter način odklepanja.</translation>
<translation id="123081309365616809">Omogočanje predvajanje vsebine v napravi</translation>
<translation id="1231349879329465225">Omogoča omogočanje ali onemogočanje hitrega prehoda.
      To velja za vse uporabnike in vse vmesnike v napravi.
      Če želite uporabiti možnost hitrega prehoda, morate omogočiti to nastavitev in lastnost ONC za posamezno omrežje.
      Ko je možnost hitrega prehoda nastavljena, ostane omogočena, dokler je ne onemogočite s spremembo pravilnika.

      Če pravilnik ni nastavljen ali je onemogočen, se možnost hitrega prehoda ne uporablja.
      Če je omogočen, se možnost hitrega prehoda uporablja, ko ga podpira brezžična dostopna točka.</translation>
<translation id="1243570869342663665">Upravljanje filtriranja vsebine za odrasle s filtrom SafeSites</translation>
<translation id="1257550411839719984">Določi privzeti imenik za prenos</translation>
<translation id="1265053460044691532">Omejitev časa, ki je uporabniku, katerega pristnost je preverjena prek SAML-ja, na voljo za prijavo brez internetne povezave</translation>
<translation id="1290634681382861275">Nadzira razne nastavitve, vključno z USB-jem, Bluetoothom, osveževanjem pravilnika, razvijalskim načinom in drugimi.</translation>
<translation id="1291880496936992484">Opozorilo: RC4 bo v celoti odstranjen iz programa <ph name="PRODUCT_NAME" /> po različici 52 (okoli septembra 2016) in ta pravilnik bo takrat prenehal delovati.

      Če pravilnik ni nastavljen ali je onemogočen, šifrirane zbirke v protokolu TLS ne bodo omogočene, sicer pa je lahko omogočen zaradi ohranjanja združljivosti z zastarelim strežnikom. To je začasen ukrep in strežnik je treba na novo konfigurirati.</translation>
<translation id="1297182715641689552">Uporabi skript .pac za proxy</translation>
<translation id="1304973015437969093">ID-ji razširitev/aplikacij in URL-ji posodobitev se namestijo brez obveščanja</translation>
<translation id="1307454923744766368">Izvori ali vzorci imena gostitelja, za katere se omejitve glede
      izvorov, ki niso varni, ne smejo uporabljati</translation>
<translation id="1312799700549720683">Nadzira nastavitve zaslona.</translation>
<translation id="131353325527891113">Pokaži uporabniška imena na zaslonu za prijavo</translation>
<translation id="1327466551276625742">Omogočanje poziva za konfiguracijo omrežja v stanju brez povezave</translation>
<translation id="1330145147221172764">Omogoči zaslonsko tipkovnico</translation>
<translation id="13356285923490863">Ime pravilnika</translation>
<translation id="1347198119056266798">Ta pravilnik je zastarel, namesto tega uporabite <ph name="FORCE_GOOGLE_SAFE_SEARCH_POLICY_NAME" /> in <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" />. Ta pravilnik se prezre, če je nastavljen kateri od teh pravilnikov: <ph name="FORCE_GOOGLE_SAFE_SEARCH_POLICY_NAME" />, <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" /> ali <ph name="FORCE_YOUTUBE_SAFETY_MODE_POLICY_NAME" /> (zastarel).

      Vsili, da se poizvedbe v Google Spletnem iskanju opravijo tako, da je Varno iskanje nastavljeno kot aktivno, uporabnikom pa se prepreči, da bi to nastavitev spremenili. Ta nastavitev prav tako vsili Zmerno omejeni način v YouTubu.

      Če to nastavitev omogočite, sta Varno iskanje v Iskanju Google in Zmerno omejeni način v YouTubu vedno aktivna.

      Če to nastavitev onemogočite ali ne nastavite vrednosti, Varno iskanje v Iskanju Google in Omejeni način v YouTubu nista vsiljena.</translation>
<translation id="1352174694615491349">Ta pravilnik omogoča združevanje povezav HTTP/2, ko se uporabljajo potrdila odjemalca. Če želite združiti povezavi, se morata tako ime gostitelja morebitne nove povezave kot ime gostitelja obstoječe povezave ujemati z enim od vzorcev, ki jih opisuje ta pravilnik. Pravilnik sestavlja seznam gostiteljev, ki uporabljajo obliko filtra URLBlacklist: »example.com« se ujema z »example.com« in vsemi poddomenami (npr. »sub.example.com«), medtem ko se ».example.net« ujema točno z »example.net«.

      Zahteve za združevanje, poslane različnim gostiteljem prek povezav, ki uporabljajo potrdila odjemalca, lahko povzročijo varnostne težave in težave glede zasebnosti, saj bo lokalno pooblastilo preneseno na vse zahteve, tudi če uporabnik tega ni izrecno odobril. Ta pravilnik je začasen in bo odstranjen v eni od prihodnjih različic. Glejte https://crbug.com/855690.

      Če ta pravilnik ni nastavljen, bo uporabljeno privzeto delovanje, po katerem ni dovoljeno nobeno združevanje povezav HTTP/2 pri povezavah, ki uporabljajo potrdila odjemalca.</translation>
<translation id="1354424209129232709">Največ:</translation>
<translation id="1354452738176731363">Če je ta pravilnik nastavljen na »false«, zvok v napravi ni na voljo, ko je uporabnik prijavljen.

      Ta pravilnik vpliva na vse vrste zvočnega predvajanja, ne samo na predvajanje iz vgrajenih zvočnikov. Onemogočene so tudi zvočne funkcije za ljudi s posebnimi potrebam. Če uporabnik potrebuje bralnik zaslona, tega pravilnika ne omogočite.

      Če je ta nastavitev nastavljena na »true« ali ni določena, lahko uporabniki uporabljajo vse podprte izhodne zvočne funkcije v napravi.</translation>
<translation id="1359553908012294236">Če je ta pravilnik omogočen ali ni nastavljen, <ph name="PRODUCT_NAME" /> omogoči prijave gostov. Prijave gostov so profili v brskalniku <ph name="PRODUCT_NAME" />, v katerih so vsa okna v načinu brez beleženja zgodovine.

      Če je ta pravilnik onemogočen, <ph name="PRODUCT_NAME" /> ne dovoli profilov gosta.</translation>
<translation id="1363275621236827384">Omogoči poizvedbe strežniku Quirks Server za profile strojne opreme.</translation>
<translation id="1363612796557848469">Ta pravilnik Pomočniku Google odobri dovoljenje za dostop do vsebine zaslona in pošiljanje podatkov strežniku.
      Če je pravilnik omogočen, je Pomočniku Google dovoljeno dostopati do vsebine zaslona.
      Če je pravilnik onemogočen, Pomočniku Google ni dovoljeno dostopati do vsebine zaslona.
      Če ni nastavljen, se lahko uporabniki odločijo, ali Pomočniku Google odobrijo dostop do vsebine zaslona.</translation>
<translation id="1376119291123231789">Omogočanje naprednega načina polnjenja akumulatorja</translation>
<translation id="1383493480903114193">Ta pravilnik vsili, da se omrežna koda izvaja v procesu brskalnika.

      Ta pravilnik je privzeto onemogočen, če pa je omogočen, so uporabniki izpostavljeni varnostnim težavam, ko se omrežni proces izvaja v peskovniku.

      Namen tega pravilnika je, da se velikim podjetjem omogoči selitev na programsko opremo drugih ponudnikov, ki ni odvisna od uporabe omrežnih API-jev. Priporočamo, da namesto LSP-jev in popravkov API-jev Win32 uporabite strežnike proxy.

      Če ta pravilnik ni nastavljen, se lahko omrežna koda izvaja zunaj procesa brskalnika, kar je odvisno od terenskih preizkušanj preizkusa NetworkService.</translation>
<translation id="1384459581748403878">Sklic: <ph name="REFERENCE_URL" /></translation>
<translation id="1384653327213929024">Uporabnikom dovoli upravljanje nameščenih potrdil.</translation>
<translation id="1393485621820363363">Omogočeni tiskalniki za naprave v podjetjih</translation>
<translation id="1397855852561539316">Privzeti URL iskalnika za predlog</translation>
<translation id="1404043648050567997">Storitev varnega brskanja prikaže opozorilno stran, ko uporabniki pridejo na spletna mesta, ki so označena kot morebiti zlonamerna. Če omogočite to nastavitev, uporabnikom preprečite, da bi z opozorilne strani vseeno šli na zlonamerno spletno mesto.

      Ta pravilnik prepreči samo, da bi uporabniki nadaljevali po opozorilih storitve varnega brskanja (npr. o zlonamerni programski opremi ali lažnem predstavljanju), ne pa tudi pri težavah, povezanih s potrdili SSL, kot so neveljavna ali potekla potrdila.

      Če je ta nastavitev onemogočena ali ni nastavljena, lahko uporabniki po prikazu opozorila nadaljujejo na spletno mesto, označeno z zastavico.

      Več informacij o Varnem brskanju je na voljo na strani https://developers.google.com/safe-browsing.</translation>
<translation id="1413936351612032792">Poročanje podatkov o uporabi aplikacij za Linux</translation>
<translation id="142346659686073702">Omogočanje uporabe Crostinija nepovezanim uporabnikom</translation>
<translation id="1426410128494586442">Da</translation>
<translation id="1427655258943162134">Naslov ali URL strežnika proxy</translation>
<translation id="1431272318313028342">Omogoča funkcijo Varnega brskanja brskalnika <ph name="PRODUCT_NAME" /> in uporabnikom prepreči spreminjanje te nastavitve.

      Če omogočite to nastavitev, je Varno brskanje vedno aktivno.

      Če onemogočite to nastavitev, je Varno brskanje vedno neaktivno.

      Če omogočite ali onemogočite to nastavitev, uporabniki ne morejo spremeniti ali preglasiti nastavitve »Omogoči zaščito pred lažnim predstavljanjem in zlonamerno programsko opremo« v brskalniku <ph name="PRODUCT_NAME" />.

      Če ta pravilnik ni nastavljen, bo to omogočeno, vendar bo lahko uporabnik spremenil nastavitev.

      Na https://developers.google.com/safe-browsing je na voljo več informacij o Varnem brskanju.

      Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="1432194160771348078">
      Določa seznam aplikacij, ki se namestijo v ozadju na zaslonu za prijavo
      brez poseganja uporabnika in jih ni mogoče odstraniti.
      Vsa dovoljenja, ki jih zahtevajo aplikacije, se odobrijo
       implicitno in brez poseganja uporabnika, vključno z dodatnimi
      dovoljenji, ki jih bodo zahtevale prihodnje različice aplikacije.

      Zaradi varnosti in zasebnosti razširitev ni mogoče namestiti s tem pravilnikom. Poleg tega naprave v stabilni različici namestijo samo aplikacije, ki so na seznamu dovoljenih, ki je povezan v skupino v brskalniku <ph name="PRODUCT_NAME" />. Elementi, ki niso skladni s temi pogoji, so prezrti.

      Če je aplikacija, ki je bila prisilno nameščena, odstranjena s tega seznama, jo <ph name="PRODUCT_NAME" /> samodejno odstrani.

      Vsak element na seznamu pravilnika je niz, ki vsebuje ID razširitve in URL za »posodobitev«, ločen s podpičjem (<ph name="SEMICOLON" />). ID razširitve je 32-mestni črkovni niz, ki ga je mogoče v načinu za razvijalce najti na primer na <ph name="CHROME_EXTENSIONS_LINK" />. URL za »posodobitev« mora kazati na dokument XML manifesta za posodobitev, kot je opisano na <ph name="LINK_TO_EXTENSION_DOC1" />. Upoštevajte, da se URL za »posodobitev«, nastavljen v tem pravilniku, uporabi samo pri začetni namestitvi; pri vseh nadaljnjih posodobitvah razširitve je uporabljen URL, naveden v manifestu razširitve.

      <ph name="EXTENSION_POLICY_EXAMPLE" /> namesti na primer aplikacijo <ph name="EXTENSION_POLICY_EXAMPLE_EXTENSION_NAME" /> s standardnega URL-ja za »posodobitev« v Spletni trgovini Chrome. Več informacij o gostovanju razširitev je na voljo tukaj: <ph name="LINK_TO_EXTENSION_DOC2" />.</translation>
<translation id="1435659902881071157">Konfiguracija omrežja na ravni naprave</translation>
<translation id="1438739959477268107">Privzeta nastavitev ustvarjanja ključev</translation>
<translation id="1454846751303307294">Omogoča nastavitev seznama vzorcev URL-jev, s katerimi so določena spletna mesta, ki jim ni dovoljeno izvajanje JavaScripta.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena splošna privzeta vrednost iz pravilnika »DefaultJavaScriptSetting«, kadar je ta nastavljen, ali iz uporabnikove osebne konfiguracije, kadar pravilnik »DefaultImagesSetting« ni nastavljen.</translation>
<translation id="1456822151187621582">Windows (odjemalci s sistemom <ph name="PRODUCT_OS_NAME" />):</translation>
<translation id="1458547592473993238">Ta pravilnik je zastarel. Uporabite pravilnik <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" /> za nadziranje razpoložljivosti vtičnika za Flash in pravilnik <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> za nadziranje, ali je za odpiranje datotek PDF treba uporabiti vdelan pregledovalnik PDF-jev.

      Določi seznam vtičnikov, ki so onemogočeni v brskalniku <ph name="PRODUCT_NAME" />, in uporabnikom prepreči, da bi to nastavitev spremenili.

      Nadomestna znaka * in ? je mogoče uporabiti za nadomeščanje zaporedij poljubnih znakov. Znak * nadomešča poljubno število znakov, znak ? pa izbirni posamezen znak, tj. nadomešča nič znakov ali en znak. Ubežni znak je \; če torej želite nadomestiti dejanske znake *, ? ali \, lahko postavite prednje znak \.

      Če to nastavitev omogočite, določen seznam vtičnikov v brskalniku <ph name="PRODUCT_NAME" /> ni nikoli uporabljen. Vtičniki so v »about:plugins« označeni kot onemogočeni in uporabniki jih ne morejo omogočiti.

      Ta pravilnik lahko preglasita pravilnika EnabledPlugins in DisabledPluginsExceptions.

      Če ta pravilnik ni nastavljen, lahko uporabnik uporabi kateri koli vtičnik, nameščen v sistemu, razen vtičnikov, ki so vdelani neposredno v izvorno kodo, nezdružljivi, zastareli ali nevarni.</translation>
<translation id="1464848559468748897">Nadzira vedenje uporabnikov v večprofilni seji v napravah s sistemom <ph name="PRODUCT_OS_NAME" />.

      Če je ta pravilnik nastavljen na »MultiProfileUserBehaviorUnrestricted«, je lahko uporabnik primarni ali sekundarni uporabnik v večprofilni seji.

      Če je ta pravilnik nastavljen na »MultiProfileUserBehaviorMustBePrimary«, je lahko uporabnik samo primarni uporabnik v večprofilni seji.

      Če je ta pravilnik nastavljen na »MultiProfileUserBehaviorNotAllowed«, uporabnik ne more sodelovati v večprofilni seji.

      Če nastavite to nastavitev, je uporabniki ne morejo spremeniti ali preglasiti.

      Če je nastavitev spremenjena, medtem ko je uporabnik prijavljen v večprofilno sejo, bodo vsi uporabniki v seji preverjeni, ali ustrezajo nastavitvam zanje. Seja bo zaprta, če kateri koli od uporabnikov nima več dovoljenja za sejo.

      Če pravilnik ni nastavljen, se za uporabnike, ki jih upravlja podjetje, uporabi vrednost »MultiProfileUserBehaviorMustBePrimary«, za neupravljane uporabnike pa »MultiProfileUserBehaviorUnrestricted«.</translation>
<translation id="1465619815762735808">Kliknite za predvajanje</translation>
<translation id="1468307069016535757">Nastavitev privzetega stanja visokokontrastnega načina funkcij za ljudi s posebnimi potrebami na prijavnem zaslonu.

          Če je ta pravilnik vklopljen, bo visokokontrastni način omogočen, ko je prikazan prijavni zaslon.

          Če je ta pravilnik izklopljen, bo visokokontrastni način onemogočen, ko je prikazan prijavni zaslon.

         Če ta pravilnik vklopite, ga lahko uporabniki začasno preglasijo tako, da omogočijo ali onemogočijo visokokontrastni način, vendar ta nastavitev ni trajna in se privzeta nastavitev obnovi vsakič, ko je ponovno prikazan prijavni zaslon ali kadar je uporabnik eno minuto nedejaven na prijavnem zaslonu.

          Če ta pravilnik ni vklopljen, je visokokontrastni način onemogočen, ko je prvič prikazan prijavni zaslon. Uporabniki lahko kadar koli omogočijo ali onemogočijo lupo, pri čemer se njegovo stanje na prijavnem zaslonu ohrani med uporabniki.</translation>
<translation id="1468707346106619889">Če je ta pravilnik nastavljen na »true«, je enotno namizje dovoljeno in
      privzeto omogočeno; ta funkcija aplikacijam omogoča, da se raztezajo prek več zaslonov.
      Uporabnik lahko onemogoči enotno namizje za posamezne zaslone, tako da
      v nastavitvah prikaza počisti to funkcijo.

      Če je ta pravilnik nastavljen na »false« ali ni nastavljen, bo enotno namizje
      onemogočeno. V tem primeru uporabnik funkcije ne more omogočiti.</translation>
<translation id="1474273443907024088">Onemogoči funkcijo »False Start« protokola TLS</translation>
<translation id="1477934438414550161">TLS 1.2</translation>
<translation id="1502843533062797703">Omogoči blokiranje vstavljanja programske opreme tretjih oseb</translation>
<translation id="1507382822467487898">
          Konfigurira, kateri naslovi MAC (nadzor dostopa do medija) se uporabljajo, če je z napravo povezan nosilec.

          Če je z nekaterimi modeli naprave povezan nosilec, se za prepoznavo naprave v ethernetu privzeto uporablja določen naslov MAC naprave za nosilec. Ta pravilnik skrbniku omogoča, da spremeni vir naslova MAC, ko je naprava na nosilcu.

          Če je izbrana možnost »DeviceDockMacAddress« ali pravilnik ni nastavljen, se uporabi določen naslov MAC za nosilec.

          Če je izbrana možnost »DeviceNicMacAddress«, se uporabi naslov NIC (kontrolnik omrežnega vmesnika) MAC naprave.

          Če je izbrana možnost »DockNicMacAddress«, se uporabi naslov NIC MAC nosilca.

          Uporabnik te nastavitve ne more spremeniti.</translation>
<translation id="1507957856411744193">Če je ta pravilnik nastavljen na »true«, se bo izdelek <ph name="PRODUCT_NAME" /> povezal z napravami za predvajanje na vseh naslovih IP, ne samo na zasebnih naslovih RFC1918/RFC4193.

          Če je ta pravilnik nastavljen na »false«, se bo izdelek <ph name="PRODUCT_NAME" /> povezal samo z napravami za predvajanje na zasebnih naslovih RFC1918/RFC4193.

          Če ta pravilnik ni nastavljen, se bo izdelek <ph name="PRODUCT_NAME" /> povezal samo z napravami za predvajanje na zasebnih naslovih RFC1918/RFC4193, razen če je omogočena funkcija CastAllowAllIPs.

          Če je pravilnik »EnableMediaRouter« nastavljen na »false«, vrednost tega pravilnika ne bo imela nobenega vpliva.</translation>
<translation id="1509692106376861764">Ta pravilnik se ne uporablja od uveljavitve različice brskalnika <ph name="PRODUCT_NAME" /> 29.</translation>
<translation id="1514888685242892912">Omogoči: <ph name="PRODUCT_NAME" /></translation>
<translation id="1522425503138261032">Dovoli mestom sledenje fizične lokacije uporabnika</translation>
<translation id="1523774894176285446">Nadomestni brskalnik za zagon pri konfiguriranih spletnih mestih.</translation>
<translation id="152657506688053119">Seznam nadomestnih URL-jev za privzetega ponudnika iskanja</translation>
<translation id="1530812829012954197">Vedno upodobi te vzorce URL-jev v gostiteljskem brskalniku</translation>
<translation id="1541170838458414064">Omejitev velikosti tiskanih strani</translation>
<translation id="1553684822621013552">Če je ta pravilnik omogočen, bo ARC omogočen za uporabnika
      (ob upoštevanju dodatnih preverjanj nastavitev pravilnika – ARC še
      vedno ne bo na voljo, če je v trenutni uporabniški seji omogočen kratkotrajni
      način ali prijava z več računi).

      Če je ta nastavitev onemogočena ali ni nastavljena, uporabniki v velikih poslovnih
      okoljih ne bodo mogli uporabljati ARC-ja.</translation>
<translation id="1559980755219453326">Ta pravilnik nadzira, ali se sporočajo podatki o razširitvah in vtičnikih.

      Če ta pravilnik ni nastavljen ali je omogočen, se zbirajo podatki o razširitvah in vtičnikih.
      Če je ta pravilnik onemogočen, se podatki o razširitvah in vtičnikih ne zbirajo.

      Ta pravilnik se uporablja samo, če je omogočena razširitev <ph name="CHROME_REPORTING_EXTENSION_NAME" />, računalnik pa je včlanjen v pravilnik <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="1560205870554624777">Nadzira, ali je omogočena funkcija Kerberos. Kerberos je protokol za preverjanje pristnosti, ki ga je mogoče uporabiti za preverjanje pristnosti spletnih aplikacij in deljenih datotek.

          Če je ta pravilnik omogočen, je funkcija Kerberos omogočena. Račune za Kerberos je mogoče dodati s pravilnikom »Configure Kerberos accounts« (Konfiguriranje računov za Kerberos) ali z nastavitvami računov za Kerberos na strani nastavitev za osebe.

          Če je ta pravilnik onemogočen ali ni nastavljen, so nastavitve računov za Kerberos onemogočene. Računov za Kerberos ni mogoče dodati in preverjanja pristnosti Kerberos ni mogoče uporabljati. Vsi obstoječi računi za Kerberos so izbrisani in enako velja za vsa shranjena gesla.</translation>
<translation id="1561424797596341174">Preglasitve pravilnika za delovne različice gostitelja za oddaljeni dostop, namenjene odpravljanju napak</translation>
<translation id="1561967320164410511">U2F in razširitve za posamezno potrditev</translation>
<translation id="1574554504290354326">Ta nastavitev je zastarela, uporabite SafeBrowsingExtendedReportingEnabled. Če omogočite ali onemogočite SafeBrowsingExtendedReportingEnabled, je to enakovredno, kot če nastavite SafeBrowsingExtendedReportingOptInAllowed na »false«.

      Če ta pravilnik nastavite na »false«, uporabnikom preprečite, da bi pošiljali nekatere informacije o sistemu in vsebino strani v Googlove strežnike. Če je ta nastavitev nastavljena na »true« ali ni nastavljena, je uporabnikom dovoljeno pošiljati nekatere informacije o sistemu in vsebino strani Varnemu brskanju zaradi zaznavanja nevarnih aplikacij in spletnih mest.

      Več informacij o Varnem brskanju je na voljo na https://developers.google.com/safe-browsing.</translation>
<translation id="1583248206450240930">Privzeto uporabi <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="1599424828227887013">Omogočanje osamitve spletnih mest za določene izvore v napravah Android</translation>
<translation id="1608755754295374538">URL-ji, ki jim bo brez poziva dovoljen dostop do naprav za zajem zvoka</translation>
<translation id="1615221548356595305">Dovoli združevanje povezav HTTP/2 za te gostitelje, tudi če se uporabljajo potrdila odjemalca</translation>
<translation id="1615855314789673708">Ponuja konfiguracijo orodja wilco DTC (diagnostična storitev in kontrolnik telemetrije).

      Ta pravilnik omogoča ponujanje konfiguracije orodja wilco DTC, ki jo je mogoče uporabiti, če je wilco DTC na voljo v dani napravi in ga omogoča pravilnik. Velikost konfiguracije ne sme presegati 1 MB (1000000 bajtov) in mora biti kodirana v obliki JSON. Upravlja jo orodje wilco DTC. Kriptografska zgoščena vrednost se uporabi za preverjanje integritete prenosa.

      Konfiguracija se prenese in predpomni. Če se spremeni URL ali zgoščena vrednost, se znova prenese.

      Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.</translation>
<translation id="1617235075406854669">Omogočanje brisanja zgodovine brskalnika in prenosov</translation>
<translation id="163200210584085447">Vzorci na tem seznamu se bodo primerjali z varnostnim
      izvorom zahtevajočega URL-ja. Če bo najdeno ujemanje, bo dostop
      do naprav za zajemanje videa odobren na straneh za prijavo SAML. Če ne bo najdeno nobeno
      ujemanje, bo dostop samodejno zavrnjen. Vzorci z nadomestnimi znaki
      niso dovoljeni.</translation>
<translation id="1634989431648355062">Dovoli vtičnik <ph name="FLASH_PLUGIN_NAME" /> na teh spletnih mestih</translation>
<translation id="1645793986494086629">Shema:</translation>
<translation id="1653229475925941921">Če je ta pravilnik nastavljen, določa vrsto lupe, ki je omogočena. Če ga nastavite na »Brez«, bo lupa izklopljena.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če tega pravilnika ne nastavite, je lupa prvotno onemogočena, vendar jo lahko uporabnik kadar koli omogoči.</translation>
<translation id="1655229863189977773">Nastavi velikost predpomnilnika diska v bajtih</translation>
<translation id="166427968280387991">Strežnik proxy</translation>
<translation id="1668836044817793277">Ali naj se samodejno zagnani aplikaciji za kiosk brez zamika dovoli nadzor nad različico sistema <ph name="PRODUCT_OS_NAME" />.

      Ta pravilnik nadzira, ali naj se samodejno zagnani aplikaciji za kiosk brez zamika dovoli nadzor nad različico sistema <ph name="PRODUCT_OS_NAME" /> z označitvijo različice required_platform_version v njenem manifestu in njeno uporabo kot predpono za samodejno posodobitev ciljne različice.

      Če je pravilnik omogočen, se vrednost ključa manifesta required_platform_version samodejno zagnane aplikacije za kiosk brez zamika uporabi kot predpona za samodejno posodobitev ciljne različice.

      Če pravilnik ni konfiguriran ali ni omogočen, je ključ manifesta required_platform_version prezrt in samodejna posodobitev se nadaljuje kot običajno.

      Opozorilo: ni priporočljivo, da nadzor nad različico sistema <ph name="PRODUCT_OS_NAME" /> dodelite aplikaciji za kiosk, saj tako naprava morda ne bo prejemala posodobitev programske opreme in nujnih varnostnih popravkov. Če dodelite nadzor nad različico sistema <ph name="PRODUCT_OS_NAME" />, so uporabniki morda ogroženi.</translation>
<translation id="1675002386741412210">Na voljo podpora za:</translation>
<translation id="1704516734140344991">Konfigurira razpoložljivost in delovanje funkcije posodobitve vdelane programske opreme modula <ph name="TPM_FIRMWARE_UPDATE_TPM" />.

      Posamezne nastavitve je mogoče določiti v lastnostih datoteke JSON:

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH" />: Če je nastavljeno na <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_POWERWASH_TRUE" />, bodo uporabniki lahko sprožili potek postopka »powerwash« zaradi namestitve posodobitve vdelane programske opreme modula <ph name="TPM_FIRMWARE_UPDATE_TPM" />.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE" />: Če je nastavljeno na <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_ALLOW_USER_INITIATED_PRESERVE_DEVICE_STATE_TRUE" />, bodo uporabniki lahko sprožili postopek posodobitve vdelane programske opreme modula <ph name="TPM_FIRMWARE_UPDATE_TPM" />, ki ohranja stanje za celotno napravo (vključno z včlanitvijo v podjetju), vendar izgubi uporabniške podatke. Ta postopek posodobitve je na voljo z različico 68.

      <ph name="TPM_FIRMWARE_UPDATE_SETTINGS_AUTO_UPDATE_MODE" />: Nadzira, kako so posodobitve vdelane programske opreme modula <ph name="TPM_FIRMWARE_UPDATE_TPM" /> uveljavljene za vdelano programsko opremo ranljivih modulov <ph name="TPM_FIRMWARE_UPDATE_TPM" />. Pri vseh postopkih se ohranil stanje lokalne naprave.
        Če je nastavljeno na 1 ali ni nastavljeno, posodobitve vdelane programske opreme modula TPM niso uveljavljene.
        Če je nastavljeno na 2, bo vdelana programska oprema modula <ph name="TPM_FIRMWARE_UPDATE_TPM" /> posodobljena ob naslednjem vnovičnem zagonu, ko uporabnik potrdi posodobitev.
        Če je nastavljeno na 3, bo vdelana programska oprema modula <ph name="TPM_FIRMWARE_UPDATE_TPM" /> posodobljena ob naslednjem vnovičnem zagonu.
        Če je nastavljeno na 4, bo vdelana programska oprema modula <ph name="TPM_FIRMWARE_UPDATE_TPM" /> posodobljena po včlanitvi, vendar pred prijavo uporabnika.
        Ta možnost je na voljo z različico 74.

      Če pravilnik ni nastavljen, funkcija posodobitve vdelane programske opreme modula <ph name="TPM_FIRMWARE_UPDATE_TPM" /> ne bo na voljo.</translation>
<translation id="1708496595873025510">Nastavitev omejitve prenosa semen različic</translation>
<translation id="1717817358640580294">Če pravilnik ni nastavljen in Chromovo čiščenje odkrije neželeno programsko opremo, bo Googlu morda poslalo metapodatke o pregledu v skladu s pravilnikom, nastavljenim z možnostjo SafeBrowsingExtendedReportingEnabled. Chromovo čiščenje bo uporabnika nato pozvalo, ali želi počistiti neželeno programsko opremo. Uporabnik se lahko odloči za pošiljanje rezultatov čiščenja Googlu in tako pripomore k odkrivanju neželene programske opreme v prihodnosti. Ti rezultati vsebujejo metapodatke o datotekah, samodejno nameščene razširitve in registrske ključe, kot je opisano v beli knjigi o zasebnosti za Chrome.

      Če je pravilnik onemogočen in Chromovo čiščenje odkrije neželeno programsko opremo, Googlu ne bo poslalo metapodatkov o pregledu, pri čemer bo preglašen morebiten pravilnik, nastavljen z možnostjo SafeBrowsingExtendedReportingEnabled. Chromovo čiščenje bo uporabnika pozvalo, ali želi počistiti neželeno programsko opremo.  Rezultati čiščenja ne bodo poslani Googlu in tudi uporabnik ne bo imel možnosti tega storiti.

      Če je pravilnik omogočen in Chromovo čiščenje odkrije neželeno programsko opremo, bo Googlu morda sporočilo metapodatke o pregledu v skladu s pravilnikom, nastavljenim z možnostjo SafeBrowsingExtendedReportingEnabled. Chromovo čiščenje bo uporabnika pozvalo, ali želi počistiti neželeno programsko opremo.  Rezultati čiščenja bodo poslani Googlu in uporabnik tega ne bo mogel preprečiti.

      Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="172374442286684480">Vsem spletnim mestom je omogočeno nastavljanje lokalnih podatkov</translation>
<translation id="1736269219679256369">Dovoli nadaljevanje s strani z opozorilom SSL</translation>
<translation id="1745780278307622857">Ugotavljanje, ali sme brskalnik <ph name="PRODUCT_NAME" /> dovoliti prenos brez preverjanja z Varnim brskanjem, če je datoteka iz zaupanja vrednega vira.

      Če je pravilnik nastavljen na »False«, prenesene datoteke ne bodo poslane v analizo Varnemu brskanju, če so iz zaupanja vrednega vira.

      Če pravilnik ni nastavljen (ali je nastavljen na »True«), so prenesene datoteke poslane v analizo Varnemu brskanju, tudi če so iz zaupanja vrednega vira.

      Upoštevajte, da te omejitve veljajo za prenose, sprožene prek vsebine spletnih strani in z možnostjo kontekstnega menija »povezava za prenos …«. Te omejitve ne veljajo za možnost shrani/prenesi na trenutno prikazani strani in ne veljajo za možnost shranjevanja kot datoteko PDF pri možnostih tiskanja.

      Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="1749815929501097806">Določa pogoje storitve, ki jih mora uporabnik sprejeti, preden začne sejo lokalnega računa v napravi.

      Če je pravilnik nastavljen, <ph name="PRODUCT_OS_NAME" /> prenese pogoje storitve in jih predstavi uporabniku, ko ta začne sejo lokalnega računa v napravi. Uporabnik lahko začne sejo, samo če sprejme pogoje storitve.

      Če pravilnik ni nastavljen, niso prikazani nobeni pogoji storitve.

      Pravilnik naj bo nastavljen na URL, s katerega lahko <ph name="PRODUCT_OS_NAME" /> prenese pogoje storitve. Ti morajo biti v obliki navadnega besedila vrste MIME in brez označevanja.</translation>
<translation id="1750315445671978749">Blokiraj vse prenose</translation>
<translation id="1762072363876276024">
      Ta pravilnik se nanaša na zaslon za prijavo. Oglejte si tudi pravilnik <ph name="SITE_PER_PROCESS_POLICY_NAME" />, ki se nanaša na uporabniško sejo. Priporočljivo je, da za oba pravilnika nastavite enako vrednost. Če se vrednosti ne ujemata, lahko pride do zakasnitve pri odpiranju uporabniške seje, medtem ko se uveljavlja vrednost, ki jo določa uporabniški pravilnik.
      To nastavitev, DeviceLoginScreenSitePerProcess, je mogoče uporabljati, da se uporabnikom ne dovoli onemogočanja privzetega delovanja osamitve vseh spletnih mest. Upoštevajte, da je lahko pravilnik DeviceLoginScreenIsolateOrigins uporaben tudi za osamitev dodatnih, podrobnejših izvorov.
      Če je pravilnik omogočen, uporabniki ne bodo mogli onemogočiti privzetega delovanja, pri katerem se vsako spletno mesto izvaja v svojem procesu.
      Če pravilnik ni konfiguriran ali je onemogočen, bo uporabnik lahko spremenil to nastavitev (lahko bo na primer uporabil vnos »Disable site isolation« (onemogoči osamitev spletnih mest) v chrome://flags).
      </translation>
<translation id="1767673020408652620">Omogočanje priporočil aplikacij v ničelnem stanju iskalnega polja</translation>
<translation id="17719159826324007">
      Če je ta pravilnik nastavljen na ArcSession, napravo prisili, da se znova zažene ob odjavi uporabnika, če se je zagnal Android.
      Če je ta pravilnik nastavljen na »Vedno«, napravo prisili, da se znova zažene ob vsaki odjavi uporabnika.
      Če pravilnik ni nastavljen, nima učinka in ob odjavi uporabnika ni vsiljen vnovični zagon. Isto velja, če je nastavljen na »Nikoli«.
      Ta pravilnik vpliva samo na nepovezane uporabnike.
      </translation>
<translation id="1781356041596378058">Ta pravilnik prav tako nadzira dostop do možnosti za razvijalce za Android. Če ta pravilnik omogočite, uporabniki ne morejo dostopati do možnosti za razvijalce. Če ta pravilnik onemogočite ali ga ne nastavite, uporabniki lahko dostopajo do možnosti za razvijalce, tako da se v aplikaciji Nastavitve za Android sedemkrat dotaknejo številke gradnje.</translation>
<translation id="1793346220873697538">Onemogočanje, da je privzeto tiskanje s kodo PIN</translation>
<translation id="1797233582739332495">Uporabniku prikaži ponavljajoč se poziv, ki obvešča, da je potreben vnovičen zagon</translation>
<translation id="1798559516913615713">Življenjska doba predpomnjenja za GPO</translation>
<translation id="1803646570632580723">Seznam pripetih aplikacij v zaganjalniku</translation>
<translation id="1808715480127969042">Blokiraj piškotke na teh mestih</translation>
<translation id="1810261428246410396">Dovoli uporabo takojšnje povezave z internetom prek mobilnega telefona</translation>
<translation id="1817685358399181673">Ta pravilnik določa sliko vtičnika <ph name="PLUGIN_VM_NAME" /> za uporabnika. Ta pravilnik nastavite z določanjem URL-ja, s katerega lahko naprava prenese sliko in razpršilno vrednost SHA-256, ki se uporablja za preverjanje celovitosti prenosa.

      Pravilnik mora biti določen kot niz, ki izraža URL in razpršilno vrednost v obliki JSON.</translation>
<translation id="1827523283178827583">Uporabi fiksne strežnike proxy</translation>
<translation id="1831495419375964631">Ta pravilnik je URL, ki kaže na datoteko XML v isti obliki, kakršne je pravilnik <ph name="IEEM_SITELIST_POLICY" /> za Internet Explorer. Pravila nalaga iz datoteke XML, ne da bi ta pravila delil z Internet Explorerjem.

      Če ta pravilnik ni nastavljen ali ni nastavljen na veljaven URL, ga <ph name="PRODUCT_NAME" /> ne uporablja kot vir pravil za preklop med brskalniki.

      Če je ta pravilnik nastavljen na veljaven URL, <ph name="PRODUCT_NAME" /> prenese seznam spletnih mest s tega URL-ja in uporabi pravila, kot bi bila konfigurirana s pravilnikom <ph name="SITELIST_POLICY_NAME" />.

      Več informacij o pravilniku <ph name="IEEM_SITELIST_POLICY" /> za Internet Explorer je na voljo tukaj: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="1839060937202387559">Poročanje statističnih podatkov o strojni opremi in identifikatorjev za naprave za shranjevanje.

      Če je ta pravilnik onemogočen, statistični podatki ne bodo poslani.
      Če je ta pravilnik omogočen ali ni nastavljen, bodo statistični podatki poslani.</translation>
<translation id="1843117931376765605">Osveži oceno za uporabniški pravilnik</translation>
<translation id="1844620919405873871">Konfigurira pravilnike, povezane s hitrim odklepanjem.</translation>
<translation id="1845405905602899692">Nastavitve kioska</translation>
<translation id="1845429996559814839">Omejevanje načina tiskanja s kodo PIN</translation>
<translation id="1847960418907100918">Določa parametre, uporabljene pri takojšnjem iskanju z metodo POST. Sestavljena je iz parov ime/vrednost, ločenih z vejico. Če je vrednost parameter predloge, kot je v zgornjih primerih {searchTerms}, bo zamenjana s pravimi podatki iskalnih izrazov.

          Ta pravilnik je izbiren. Če ni nastavljen, bo zahteva za takojšnje iskanje poslana z metodo GET.

          Ta pravilnik se upošteva samo, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="1852294065645015766">Dovoli samodejno predvajanje predstavnosti</translation>
<translation id="1857152770025485173">Ta pravilnik uporabniku preprečuje nalaganje spletnih strani URL-jev s seznama blokiranih. Seznam blokiranih posreduje seznam vzorcev URL-jev, ki določajo, kateri URL-ji bodo uvrščeni na seznam blokiranih.

      Vzorec URL-ja mora biti oblikovan glede na to: https://www.chromium.org/administrators/url-blacklist-filter-format.

      Izjeme je mogoče opredeliti s pravilnikom o seznamu dovoljenih URL-jev. Ti pravilniki so omejeni na 1000 vnosov; nadaljnji vnosi bodo prezrti.

      Upoštevajte, da ni priporočljivo blokirati notranjih URL-jev »chrome://*«, saj lahko to privede do nepričakovanih napak.

      Od različice M73 je mogoče blokirati URL-je »javascript://*« . Vendar to vpliva samo na JavaScript, vnesen v naslovni vrstici (ali na primer na priljubljene programčke). Upoštevajte, da za URL-je JavaScripta, umeščene na strani, ta pravilnik ne velja, če gre za dinamično naložene podatke. Če na primer blokirate »primer.com/abc«, bo stran »primer.com« še vedno lahko naložila »primer.com/abc« z zahtevo XMLHTTPRequest.

      Če ta pravilnik ni nastavljen, ne bo noben URL uvrščen na seznam blokiranih v brskalniku.</translation>
<translation id="1859859319036806634">Opozorilo: preklop na različico TLS-ja bo odstranjen iz brskalnika <ph name="PRODUCT_NAME" /> po različici 52 (približno septembra 2016) in ta pravilnik bo takrat prenehal delovati.

      Če rokovanje TLS ne uspe, <ph name="PRODUCT_NAME" /> pred tem poskusi vzpostaviti povezavo z nižjo različico TLS-ja, da mu ni treba upoštevati napak v strežnikih HTTPS. Ta nastavitev konfigurira različico, pri kateri se postopek preklopa ustavi. Če strežnik pravilno izvede pogajanja glede različice (tj. brez prekinitve povezave), se ta nastavitev ne uporabi. Ne glede na to mora biti vzpostavljena povezava skladna s pravilnikom SSLVersionMin.

      Če ta pravilnik ni konfiguriran ali če je nastavljen na »tls1.2«, <ph name="PRODUCT_NAME" /> ne izvede več tega preklopa. S tem ni onemogočena podpora za starejše različice TLS-ja, temveč je zgolj določeno, ali <ph name="PRODUCT_NAME" /> ne bo upošteval strežnikov z napakami, ki ne morejo pravilno izvesti pogajanj glede različice.

      Če je treba ohraniti združljivost s strežnikom z napakami, je pravilnik lahko nastavljen na »tls1«. To je začasen ukrep in napake v strežniku je treba hitro odpraviti.</translation>
<translation id="1864382791685519617">Omogoča omrežno predvidevanje v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom preprečuje spreminjanje te nastavitve.

      Ta pravilnik nadzira vnaprejšnji prenos podatkov DNS, vnaprejšnje povezovanje TCP in SSL ter vnaprejšnje upodabljanje spletnih strani.

      Če nastavite ta pravilnik, uporabniki v brskalniku <ph name="PRODUCT_NAME" /> ne morejo spremeniti ali preglasiti te nastavitve.

      Če ta pravilnik ni nastavljen, bo to omogočeno, vendar bo lahko uporabnik to spremenil.</translation>
<translation id="1865417998205858223">Glavna dovoljenja</translation>
<translation id="186719019195685253">Dejanje, ki se izvede, ko je pri napajanju iz električnega omrežja dosežena zakasnitev zaradi nedejavnosti</translation>
<translation id="187819629719252111">Omogoča dostop do lokalnih datotek v računalniku, tako da programu <ph name="PRODUCT_NAME" /> dovoli prikaz pogovornih oken za izbiro datotek.

      Če to nastavitev omogočite, lahko uporabniki odpirajo pogovorna okna za izbiro datotek.

      Če to nastavitev onemogočite, se vsakič, ko uporabnik izvede dejanje, ki bi odprlo pogovorno okno za izbiro datoteke (npr. uvoz zaznamkov, prenos datotek iz računalnika, shranjevanje seznamov ipd.), prikaže sporočilo in predpostavi, da je uporabnik v pogovornem oknu za izbiro datoteke kliknil »Prekliči«.

      Če ta možnost ni nastavljena, lahko uporabniki kot običajno odpirajo pogovorna okna za izbiro datotek.</translation>
<translation id="1885782360784839335">Omogočanje prikazovanja promocijske vsebine po celem zavihku</translation>
<translation id="1888871729456797026">Včlanitveni žeton pravilnika o oblaku v namiznem računalniku</translation>
<translation id="1897365952389968758">Dovoli izvajanje JavaScripta vsem mestom</translation>
<translation id="1906888171268104594">Nadzira, ali se podatki meritev uporabe in diagnostični podatki, vključno s poročili o zrušitvah, pošljejo Googlu.

      Če je pravilnik omogočen, <ph name="PRODUCT_OS_NAME" /> pošlje podatke meritev uporabe in diagnostične podatke.

      Če je onemogočen, je pošiljanje podatkov meritev in diagnostičnih podatkov onemogočeno.

      Če ni nastavljen, je pošiljanje podatkov meritev in diagnostičnih podatkov onemogočeno v neupravljanih napravah in omogočeno v upravljanih.</translation>
<translation id="1907431809333268751">Konfiguriranje seznama URL-jev za prijavo za poslovna okolja (samo sheme HTTP in HTTPS). Na teh URL-jih bo zajet prstni odtis gesla in uporabljen za odkrivanje vnovične uporabe enakega gesla.
      Če želite, da bo <ph name="PRODUCT_NAME" />pravilno zajel prstne odtise gesel, poskrbite, da so strani za prijavo skladne s smernicami na naslovu https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Če je ta nastavitev omogočena, bo storitev za zaščito gesel na teh URL-jih zajela prstni odtis gesla in ga uporabila za odkrivanje vnovične uporabe enakega gesla.
      Če je ta nastavitev onemogočena ali ni nastavljena, bo storitev za zaščito gesel prstni odtis gesla zajela samo na naslovu https://accounts.google.com.
      Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="1914840757300882918">Če je ta pravilnik nastavljen, gostitelj za preverjanje pristnosti prek RemoteAccessHostTokenValidationUrl uporabi potrdilo odjemalca, ki ga izda CN. Če želite uporabiti poljubno razpoložljivo potrdilo odjemalca, pravilnik nastavite na »*«.

          Ta funkcija je trenutno onemogočena na strani strežnika.</translation>
<translation id="1919802376548418720">Uporabi pravilnik KDC za delegiranje poverilnic.</translation>
<translation id="1920046221095339924">Omogočanje upravljane seje v napravi</translation>
<translation id="1929709556673267855">Posreduje konfiguracije za tiskalnike v podjetjih, vezane na naprave.

      Ta pravilnik vam omogoča, da posredujete konfiguracije tiskalnikov napravam z operacijskim sistemom <ph name="PRODUCT_OS_NAME" />. Oblika je enaka obliki imenika NativePrinters, z dodatnim obveznim poljem »id« ali »guid« na tiskalnik zaradi dodajanja na seznam dovoljenih ali nedovoljenih.

      Velikost datoteke ne sme presegati 5 MB in mora biti kodirana v obliki JSON. Ocenjuje se, da je datoteka, ki vsebuje približno 21.000 tiskalnikov, kodirana kot datoteka velikosti 5 MB. Za preverjanje celovitosti se uporablja kriptografska zgoščevalna vrednost.

      Datoteka se prenese in shrani v predpomnilnik. Ob vsaki spremembi URL-ja ali zgoščevalne vrednosti se znova prenese.

      Če je ta pravilnik nastavljen, <ph name="PRODUCT_OS_NAME" /> prenese datoteko s konfiguracijami tiskalnikov in omogoči, da so tiskalniki na voljo skladno s pravilniki <ph name="DEVICE_PRINTERS_ACCESS_MODE" />, <ph name="DEVICE_PRINTERS_WHITELIST" /> in <ph name="DEVICE_PRINTERS_BLACKLIST" />.

      Ta pravilnik ne vpliva na to, ali lahko uporabniki konfigurirajo tiskalnike v posameznih napravah. Namenjen je kot dopolnilo konfiguracijam tiskalnikov, ki jih opravijo posamezni uporabniki.

      Ta pravilnik je dodatek pravilniku <ph name="BULK_PRINTERS_POLICY" />.

      Če ta pravilnik ni nastavljen, ne bo tiskalnikov za naprave in drugi pravilniki <ph name="DEVICE_PRINTERS_POLICY_PATTERN" /> bodo prezrti.
      </translation>
<translation id="193259052151668190">Seznam dovoljenih naprav USB, katerih povezavo je mogoče prekiniti</translation>
<translation id="1933378685401357864">Slika za ozadje</translation>
<translation id="1956493342242507974">Nastavitev upravljanja porabe na prijavnem zaslonu v sistemu <ph name="PRODUCT_OS_NAME" />.

      S tem pravilnikom lahko nastavite, kako deluje <ph name="PRODUCT_OS_NAME" />, ko uporabnik nekaj časa ni dejaven in je prikazan prijavni zaslon. Pravilnik nadzira več nastavitev. Za podrobnosti posameznih nastavitev in njihove obsege vrednosti si oglejte ustrezne pravilnike, ki v seji nadzirajo upravljanje porabe. Edini odstopanji od teh pravilnikov sta:
      * dejanja, ki se izvedejo v stanju nedejavnosti ali ob zapiranju pokrova, ne smejo končati seje;
      * privzeto dejanje v stanju nedejavnosti, ko se računalnik napaja iz električnega omrežja, je zaustavitev.

      Če nastavitev ni določena, se uporabi privzeta vrednost.

      Če ta pravilnik ni nastavljen, se za vse nastavitve uporabijo privzete vrednosti.</translation>
<translation id="1958138414749279167">Omogoči funkcijo za samodejno izpolnjevanje v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom omogoča samodejno izpolnjevanje podatkov o naslovu v spletnih obrazcih s predhodno shranjenimi podatki.

      Če je ta nastavitev onemogočena, samodejno izpolnjevanje ne bo nikoli predlagalo ali vneslo podatkov o naslovu in prav tako ne bo shranilo dodatnih podatkov o naslovu, ki jih uporabnik morda vnese med brskanjem v spletu.

      Če je ta nastavitev omogočena ali nima nastavljene vrednosti, bo uporabnik lahko nadziral samodejno izpolnjevanje za naslove v uporabniškem vmesniku.</translation>
<translation id="1962273523772270623">Omogočanje zbiranja dnevnikov dogodkov tehnologije WebRTC iz Googlovih storitev</translation>
<translation id="1964634611280150550">Način brez beleženja zgodovine je onemogočen</translation>
<translation id="1964802606569741174">Ta pravilnik ne vpliva na aplikacijo YouTube za Android. Če naj bo varni način v YouTubu uveljavljen, mora biti namestitev aplikacije YouTube za Android onemogočena.</translation>
<translation id="1969212217917526199">Preglasi pravilnike za delovne različice gostitelja za oddaljeni dostop, namenjene odpravljanju napak.

          Vrednost je razčlenjena kot slovar JSON preslikav imen pravilnika v vrednosti pravilnika.</translation>
<translation id="1969808853498848952">Vedno izvaja vtičnike, ki zahtevajo dovoljenje (zastarelo)</translation>
<translation id="1988371335297483117">Samoposodobitveni paketi v sistemu <ph name="PRODUCT_OS_NAME" /> se lahko namesto prek protokola HTTPS prenesejo prek protokola HTTP. To omogoča neposredno predpomnjenje HTTP za prenose HTTP.

      Če je ta pravilnik nastavljen na »true«, poskuša <ph name="PRODUCT_OS_NAME" /> samoposodobitvene pakete prenesti prek HTTP. Če je ta pravilnik nastavljen na »false« ali ni nastavljen, se za prenos samoposodobitvenih paketov uporabi HTTPS.</translation>
<translation id="199764499252435679">Dovoli posodobitve komponent v izdelku <ph name="PRODUCT_NAME" /></translation>
<translation id="1997994951395619441">Če to nastavitev omogočite, bo <ph name="PRODUCT_NAME" /> prikazoval vrstico z zaznamki.

      Če to nastavitev onemogočite, vrstica z zaznamki ne bo prikazana.

      Če to nastavitev omogočite ali onemogočite, uporabniki v brskalniku <ph name="PRODUCT_NAME" /> tega ne bodo mogli spremeniti ali preglasiti.

      Če te nastavitve ne določite, se lahko uporabnik odloči, ali bo uporabljal to funkcijo.</translation>
<translation id="2006530844219044261">Upravljanje porabe</translation>
<translation id="2014757022750736514">Nadzira delovanje zaslona za prijavo, na katerem se uporabniki prijavijo v račun. Nastavitve vključujejo, kdo se lahko prijavi, katere vrste računov so dovoljene, kateri načini preverjanja pristnosti se uporabljajo ter vključujejo tudi splošno dostopnost, način vnosa in nastavitve jezika.</translation>
<translation id="201557587962247231">Pogostost nalaganja poročil o stanju naprave</translation>
<translation id="2017301949684549118">URL-ji za spletne aplikacije za namestitev brez obveščanja.</translation>
<translation id="2017459564744167827">Na <ph name="REFERENCE_URL" /> je na voljo več informacij o shemi in oblikovanju.</translation>
<translation id="2018836497795982119">Določa obdobje v milisekundah, po katerem se storitvi za upravljanje naprave pošlje poizvedba za uporabniške podatke pravilnika.

      Z nastavitvijo tega pravilnika se preglasi privzeta vrednost 3 ur. Veljavne vrednosti za ta pravilnik so med 1.800.000 (30 minut) in 86.400.000 (1 dan). Vrednosti, ki niso v tem obsegu, bodo spremenjene na ustrezno mejo obsega. Če okolje podpira obvestila pravilnika, je zakasnitev osvežitve nastavljena na 24 ur, ker je pričakovano, da obvestila pravilnika ob vsakokratni zamenjavi pravilnika samodejno vsilijo osvežitev.

      Če tega pravilnika ne nastavitev, bo brskalnik <ph name="PRODUCT_NAME" /> uporabljal privzeto vrednost 3 ur.

      Če okolje podpira obvestila pravilnika, je zakasnitev osvežitve nastavljena na 24 ur (prezrejo se vse privzete nastavitve in vrednost tega pravilnika), ker je pričakovano, da obvestila pravilnika ob vsakokratni zamenjavi pravilnika samodejno vsilijo osvežitev, zaradi česar so pogostejše osvežitve nepotrebne.</translation>
<translation id="2024476116966025075">Konfiguriranje imena domene, potrebnega za odjemalce za oddaljeni dostop</translation>
<translation id="2030905906517501646">Privzeta ključna beseda iskalnika</translation>
<translation id="203096360153626918">Ta pravilnika ne vpliva na aplikacije za Android. Tudi če je ta pravilnik nastavljen na <ph name="FALSE" />, bodo aplikacije lahko preklopile v celozaslonski način.</translation>
<translation id="2043770014371753404">Onemogočeni tiskalniki v podjetjih</translation>
<translation id="2050629715135525072">Nadzira možnost uporabnika, povezanega z gostiteljem za oddaljeni dostop, da prenaša datoteke med odjemalcem in gostiteljem. To ne velja za povezave za oddaljeno pomoč, ki ne podpirajo prenosa podatkov.

          Če je ta nastavitev onemogočena, prenos datotek ne bo dovoljen. Če je ta nastavitev omogočena ali ni nastavljena, bo prenos podatkov dovoljen.</translation>
<translation id="2057317273526988987">Dovoli dostop do seznama URL-jev</translation>
<translation id="2061810934846663491">Nastavitev zahtevanih imen domene za dostop do oddaljenih gostiteljev</translation>
<translation id="206623763829450685">Določa, katere načine preverjanja pristnosti HTTP podpira <ph name="PRODUCT_NAME" />.

          Možne vrednosti so »basic«, »digest«, »ntlm« in »negotiate«. Več vrednosti ločite z vejicami.

          Če ta pravilnik ni nastavljen, bodo uporabljeni vsi štirje načini.</translation>
<translation id="2067011586099792101">Blokira dostop do spletnih mest zunaj paketov vsebine</translation>
<translation id="2073552873076775140">Dovoli prijavo v izdelek <ph name="PRODUCT_NAME" /></translation>
<translation id="2077129598763517140">Uporabi strojno pospeševanje, če je na voljo</translation>
<translation id="2077273864382355561">Časovni zamik izklopa zaslona ob napajanju iz akumulatorja</translation>
<translation id="2082205219176343977">Konfiguriranje najmanjše dovoljene različice Chroma za napravo.</translation>
<translation id="209586405398070749">Stabilna različica</translation>
<translation id="2098658257603918882">Omogoči poročanje o uporabi in podatkih, povezanih z zrušitvami</translation>
<translation id="2104418465060359056">Sporočanje podatkov o razširitvah in vtičnikih</translation>
<translation id="2106627642643925514">Preglasi privzeti način tiskanja s kodo PIN. Če način ni na voljo, je ta pravilnik prezrt.</translation>
<translation id="2107601598727098402">
        Ta pravilnik zastara v različici M72. Uporabite pravilnik CloudManagementEnrollmentToken.
        </translation>
<translation id="2111016292707172233">Omogoči razpoložljivost funkcije »Iskanje z dotikom« v pogledu vsebine brskalnika <ph name="PRODUCT_NAME" />.

      Če omogočite to nastavitev, je funkcija »Iskanje z dotikom« na voljo uporabniku, ki lahko to funkcijo vkopi ali izklopi.

      Če onemogočite to nastavitev, bo funkcija »Iskanje z dotikom« v celoti onemogočena.

      Če ta pravilnik ni nastavljen, je enako, kot če je funkcija omogočena. Glejte zgornji opis.</translation>
<translation id="2113068765175018713">Omejitev časa dejavnosti naprave samodejnim vnovičnim zagonom</translation>
<translation id="2116790137063002724">Ta pravilnik nadzira, ali se sporočajo podatki, s katerimi je mogoče prepoznati uporabnike, kot so podatki za prijavo v operacijski sistem, podatki za prijavo v profil za <ph name="PRODUCT_NAME" />, ime profila za <ph name="PRODUCT_NAME" />, pot profila za <ph name="PRODUCT_NAME" /> in pot do izvedljive datoteke za <ph name="PRODUCT_NAME" />.

      Če ta pravilnik ni nastavljen ali je omogočen, se zbirajo podatki, s katerimi je mogoče prepoznati uporabnike.
      Če je ta pravilnik onemogočen, se podatki, s katerimi je mogoče prepoznati uporabnike, ne zbirajo.

      Ta pravilnik se uporablja samo, če je omogočena razširitev <ph name="CHROME_REPORTING_EXTENSION_NAME" />, računalnik pa je včlanjen v pravilnik <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="2127599828444728326">Dovoli obvestila na teh mestih</translation>
<translation id="2131902621292742709">Časovni zamik zatemnitve zaslona ob napajanju iz akumulatorja</translation>
<translation id="2134437727173969994">Dovoli zaklepanje zaslona</translation>
<translation id="2137064848866899664">Če je ta pravilnik nastavljen, je vsak zaslon zasukan na
      določeno postavitev pri vsakem vnovičnem zagonu in pri prvi povezavi
      po spremembi vrednosti pravilnika. Uporabnik lahko po prijavi
      na strani z nastavitvami spremeni sukanje, vendar bo pri naslednjem
      vnovičnem zagonu vrednost pravilnika preglasila njegovo nastavitev.

      Ta pravilnika velja za primarne in sekundarne zaslone.

      Če pravilnik ni nastavljen, je privzeta vrednost 0 stopinj in uporabnik
      jo lahko spremeni. V tem primeru se privzeta vrednost ob vnovičnem
      zagonu ne uveljavi znova.</translation>
<translation id="2138449619211358657">Ta pravilnik sistemu <ph name="PRODUCT_OS_NAME" /> omogoča obhod katerega koli strežnika proxy za preverjanje pristnosti v prestreznih portalih.

      Pravilnik se uveljavi samo, če je nastavljen strežnik proxy (na primer s pravilnikom, z razširitvami ali če ga je nastavil uporabnik v »chrome://settings«).

      Če omogočite to nastavitev, bodo morebitne strani prestreznega portala za preverjanje pristnosti (tj. vse spletne strani od strani za prijavo v prestrezni portal do trenutka, ko brskalnik <ph name="PRODUCT_NAME" /> zazna uspešno povezavo z internetom) prikazane v ločenem oknu, ki prezre vse nastavitve in omejitve pravilnika za trenutnega uporabnika.

      Če to nastavitev onemogočite ali je ne nastavite, bodo morebitne strani prestreznega portala za preverjanje pristnosti prikazane na (običajnem) novem zavihku brskalnika z nastavitvami strežnika proxy trenutnega uporabnika.</translation>
<translation id="21394354835637379">Omogoča, da določite URL-je, s katerih je dovoljeno nameščati razširitve, aplikacije in teme.

          Z brskalnikom <ph name="PRODUCT_NAME" /> 21 je težje namestiti razširitve, aplikacije in uporabniške skripte, ki niso iz Spletne trgovine Chrome. Prej so uporabniki lahko kliknili povezavo na datoteko *.crx in <ph name="PRODUCT_NAME" /> je po nekaj opozorilih ponudil namestitev datoteke. Od brskalnika <ph name="PRODUCT_NAME" /> 21 naprej pa je treba te datoteke prenesti in povleči na stran z nastavitvami za <ph name="PRODUCT_NAME" />. S to nastavitvijo je mogoče za določene URL-je omogočiti starejši in preprostejši način namestitve.

          Vsak element na tem seznamu je vzorec ujemanja v slogu razširitve (glejte https://developer.chrome.com/extensions/match_patterns). Uporabniki lahko preprosto namestijo elemente s poljubnega URL-ja, ki se ujema z elementom na tem seznamu. Mesto datoteke *.crx in strani, kjer se prenos začne (tj. napotitelj), morajo dovoljevati vzorci s tega seznama.

          Seznam <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" /> ima prednost pred tem pravilnikom. To pomeni, da razširitve s seznama blokiranih ni mogoče namestiti, čeprav je za namestitev uporabljeno spletno mesto na tem seznamu.</translation>
<translation id="214901426630414675">Omejitev obojestranskega tiskanja</translation>
<translation id="2149330464730004005">Omogočanje barvnega tiskanja</translation>
<translation id="2156132677421487971">Konfiguriranje pravilnikov za napravo <ph name="PRODUCT_NAME" /> – to je funkcija, ki uporabnikom omogoča predvajanje vsebine zavihkov, spletnih mest ali namizja iz brskalnika na oddaljene zaslone ali zvočne sisteme.</translation>
<translation id="2166472654199325139">Ne filtriraj spletnih mest za izločitev vsebine za odrasle</translation>
<translation id="2168397434410358693">Časovni zamik nedejavnosti ob napajanju iz električnega omrežja</translation>
<translation id="217013996107840632">Parametri ukazne vrstice za preklop z nadomestnega brskalnika.</translation>
<translation id="2170233653554726857">Omogočanje optimizacije za WPAD</translation>
<translation id="2176565653304920879">Če je ta pravilnik nastavljen, je samodejno zaznavanje časovnega pasu odvisno od vrednosti nastavitve:

      Če je nastavljen na TimezoneAutomaticDetectionUsersDecide, lahko uporabniki z običajnimi kontrolniki v chrome://settings nadzirajo samodejno zaznavanje časovnega pasu.

      Če je nastavljen na TimezoneAutomaticDetectionDisabled, so kontrolniki za samodejno zaznavanje časovnega pasu v chrome://settings onemogočeni. Samodejno zaznavanje časovnega pasu je vedno izklopljeno.

      Če je nastavljen na TimezoneAutomaticDetectionIPOnly, so kontrolniki za časovni pas v chrome://settings onemogočeni. Samodejno zaznavanje časovnega pasu je vedno vklopljeno. Pri zaznavanju časovnega pasu se za določanje lokacije uporablja samo IP.

      Če je nastavljen na TimezoneAutomaticDetectionSendWiFiAccessPoints, so kontrolniki za časovni pas v chrome://settings onemogočeni. Samodejno zaznavanje časovnega pasu bo vedno vklopljeno. Seznam vidnih dostopnih točk Wi-Fi bo vedno poslan v strežnik API-ja za geolokacijo zaradi natančnega zaznavanja časovnega pasu.

      Če je nastavljen na TimezoneAutomaticDetectionSendAllLocationInfo, so kontrolniki za časovni pas v chrome://settings onemogočeni. Samodejno zaznavanje časovnega pasu bo vedno vklopljeno. Podatki o lokaciji (na primer dostopne točke Wi-Fi, dosegljive bazne postaje, GPS) bodo poslani v strežnik zaradi natančnega zaznavanja časovnega pasu.

      Če ta pravilnik ni nastavljen, deluje, kot da je nastavljena možnost TimezoneAutomaticDetectionUsersDecide.

      Če je nastavljen pravilnik SystemTimezone, preglasi ta pravilnik. V tem primeru je samodejno zaznavanje časovnega pasu v celoti onemogočeno.</translation>
<translation id="2178899310296064282">Uveljavitev vsaj Zmerno omejenega načina v YouTubu</translation>
<translation id="2182291258410176649">Uporabnik se odloči, ali bo omogočil varnostno kopiranje in obnovitev</translation>
<translation id="2183294522275408937">Ta nastavitev nadzira, kako pogosto zaklenjeni zaslon zahteva vnos gesla, če želi uporabnik naprej uporabljati hitro odklepanje. Ob vsakem odpiranju zaklenjenega zaslona se preveri čas, ki je pretekel od zadnjega vnosa gesla – če presega to vrednost, ob odpiranju zaklenjenega zaslona hitro odklepanje ne bo na voljo. Če se uporabnik zadrži pri zaklenjenem zaslonu dlje od tega časovnega obdobja, bo od uporabnika zahtevano geslo, ko naslednjič vnese napačno kodo ali znova odpre zaklenjeni zaslon, kar koli se zgodi prej.

          Če je ta nastavitev konfigurirana, bodo morali uporabniki, ki uporabljajo hitro odklepanje, na zaklenjenem zaslonu vnesti geslo glede na to nastavitev.

          Če ta nastavitev ni konfigurirana, bodo morali uporabniki, ki uporabljajo hitro odklepanje, na zaklenjenem zaslonu vnesti geslo vsak dan.</translation>
<translation id="2194470398825717446">Ta pravilnik je zastarel v različici M61, uporabite EcryptfsMigrationStrategy.

      Določa, kako naj deluje naprava, ki je bila dobavljena z ecryptfs in mora preiti na šifriranje ext4.

      Če ta pravilnik nastavite na »DisallowArc«, bodo aplikacije za Android onemogočene za vse uporabnike naprave (vključno s tistimi, ki že imajo šifriranje ext4) in nobenemu uporabniku ne bo ponujena selitev s šifriranja ecryptfs na ext4.

      Če ta pravilnik nastavite na »AllowMigration«, bo uporabnikom z domačimi imeniki ecryptfs po potrebi ponujena selitev na šifriranje ext4 (trenutno, ko je za napravo na voljo Android N).

      Ta pravilnik se ne uporablja za aplikacije za kiosk – njihova selitev je opravljena samodejno. Če ta pravilnik ni nastavljen, bo naprava delovala, kot da bi bila izbrana možnost »DisallowArc«..</translation>
<translation id="2195032660890227692">Ta pravilnik je bil odstranjen v izdelku <ph name="PRODUCT_NAME" /> 68 in ga je zamenjal pravilnik <ph name="ARC_BR_POLICY_NAME" />.</translation>
<translation id="219720814106081560">Če je ta pravilnik omogočen ali ni nastavljen (privzeto), bo uporabnik pozvan,
      da dovoli zajem videa, razen za URL-je, nastavljene na seznamu
      VideoCaptureAllowedUrls, za katere bo zajem dovoljen brez poziva uporabniku.

      Če je ta pravilnik onemogočen, uporabnik ne bo nikoli pozvan, pri čemer bo zajem
      videa na voljo samo URL-jem, konfiguriranim na seznamu VideoCaptureAllowedUrls.

      Ta pravilnik vpliva na vse vrste videovhodov, in ne samo na vgrajeno kamero.</translation>
<translation id="2201555246697292490">Konfiguracija seznama dovoljenih za izvorno pošiljanje sporočil</translation>
<translation id="2204753382813641270">Nadzor samodejnega skrivanja police</translation>
<translation id="2208976000652006649">Parametri za iskalni URL, ki uporablja POST</translation>
<translation id="2214880135980649323">Če je ta pravilnik omogočen, je razširitvam, nameščenim s pravilnikom podjetja, dovoljeno uporabljati API za okolja za strojno opremo za podjetja.
      Če je ta pravilnik onemogočen ali ni nastavljen, nobeni razširitvi ni dovoljeno uporabljati API-ja za okolja za strojno opremo za podjetja.
      Ta pravilnik se uporablja tudi za razširitve komponent, kot je razširitev Hangout Services.</translation>
<translation id="2223598546285729819">Privzeta nastavitev obveščanja</translation>
<translation id="2231817271680715693">Uvoz zgodovine brskanja privzetega brskalnika ob prvem zagonu</translation>
<translation id="2236488539271255289">Nobenemu mestu ne dovoli nastavljanja lokalnih podatkov</translation>
<translation id="2240879329269430151">Omogoča nastavitev, ali je spletnim mestom dovoljeno prikazovati pojavna okna. Prikazovanje pojavnih oken je mogoče dovoliti ali zavrniti za vsa spletna mesta.

         Če ta pravilnik ni nastavljen, bo uporabljen pravilnik »BlockPopups« in uporabnik ga bo lahko spremenil.</translation>
<translation id="2255326053989409609">Če to nastavitev omogočite, spletnim stranem preprečite dostop do grafičnega procesorja. Spletne strani ne morejo dostopati do API-ja WebGL, vtičniki pa ne morejo uporabiti API-ja Pepper 3D.

      Če to nastavitev onemogočite ali je ne določite, spletnim stranem načeloma dovolite uporabo API-ja WebGL, vtičnikom pa API Pepper 3D. Privzete nastavitve brskalnika lahko še vedno določajo, da je treba za uporabo teh API-jev uporabiti argumente ukazne vrstice.

      Če je pravilnik HardwareAccelerationModeEnabled onemogočen, se pravilnik Disable3DAPIs prezre in je enako, kot če je pravilnik Disable3DAPIs omogočen.</translation>
<translation id="2258126710006312594">Uporabnikom oddaljenega dostopa dovoli prenos datotek iz gostitelja in v njega</translation>
<translation id="2265214338421787313">Skrbnik lahko s tem pravilnikom določi, da lahko stran med razkladanjem prikazuje pojavna okna.

      Če je ta pravilnik omogočen, je stranem med razkladanjem dovoljeno prikazovanje pojavnih oken.

      Če je pravilnik onemogočen ali ni nastavljen, stranem med razkladanjem ni dovoljeno prikazovanje pojavnih oken, kar je v skladu s specifikacijo (https://html.spec.whatwg.org/#apis-for-creating-and-navigating-browsing-contexts-by-name).

      Ta pravilnik bo odstranjen v različici Chrome 82.

      Glejte https://www.chromestatus.com/feature/5989473649164288 .</translation>
<translation id="2269319728625047531">Omogočanje prikaza soglasja za sinhronizacijo med prijavo</translation>
<translation id="2274864612594831715">Ta pravilnik nastavi omogočanje navidezne tipkovnice kot vhodne naprave v sistemu Chrome OS. Uporabniki tega pravilnika ne morejo preglasiti.

      Če je pravilnik nastavljen na »true«, je zaslonska navidezna tipkovnica vedno omogočena.

      Če je nastavljen na »false«, je zaslonska navidezna tipkovnica vedno onemogočena.

      Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti. Uporabniki bodo kljub temu še vedno lahko omogočili/onemogočili zaslonsko tipkovnico za ljudi s posebnimi potrebami, ki ima prednost pred navidezno tipkovnico, ki jo ureja ta pravilnik. Če želite nadzirati zaslonsko tipkovnico za ljudi s posebnimi potrebami, si oglejte pravilnik |VirtualKeyboardEnabled|.

      Če ta pravilnik ni nastavljen, je zaslonska tipkovnica sprva onemogočena, vendar jo lahko uporabnik kadar koli omogoči. Na odločanje o prikazu tipkovnice lahko vplivajo tudi hevristična pravila.</translation>
<translation id="2292084646366244343"><ph name="PRODUCT_NAME" /> lahko uporablja Googlovo spletno storitev za preverjanje črkovanja. Če je ta nastavitev omogočena, bo ta storitev vedno uporabljena. Če je ta nastavitev onemogočena, storitev ne bo nikoli uporabljena.

      Preverjanje črkovanja je še vedno mogoče z uporabo prenesenega slovarja; ta pravilnik nadzira samo uporabo spletne storitve.

      Če ta nastavitev ni nastavljena, lahko uporabniki izberejo, ali bo storitev preverjanja črkovanja uporabljena ali ne.</translation>
<translation id="2294382669900758280">Predvajanje videoposnetkov v aplikacijah za Android se ne upošteva, tudi če je ta pravilnik nastavljen na <ph name="TRUE" />.</translation>
<translation id="2299220924812062390">Določi seznam omogočenih vtičnikov</translation>
<translation id="2303795211377219696">Omogočanje samodejnega izpolnjevanja za kreditne kartice</translation>
<translation id="2309390639296060546">Privzeta nastavitev geolokacije</translation>
<translation id="2327252517317514801">Opredelitev domen, ki smejo dostopati do storitve G Suite</translation>
<translation id="2356878440219553005">Določa pravilnik za upravljanje porabe energije za več načinov polnjenja akumulatorja.

          Dinamično nadzirajte polnjenje akumulatorja, da zmanjšate njegovo izrabo zaradi obremenjenosti in podaljšate njegovo življenjsko dobo.

          Če je izbran prilagojen način polnjenja akumulatorja, morate določiti DeviceBatteryChargeCustomStartCharging in DeviceBatteryChargeCustomStopCharging.

          Če je ta pravilnik nastavljen, bo način polnjenja akumulatorja uporabljen, če ga naprava podpira.

          Če ta pravilnik ni nastavljen, pravilnik pa je podprt v napravi, bo uporabljen standardni način polnjenja akumulatorja in uporabnik tega ne more spremeniti.

          Opomba: če je določeno to: <ph name="DEVICE_ADVANCED_BATTERY_CHARGE_MODE_ENABLED_NAME" />, preglasi pravilnik.</translation>
<translation id="237494535617297575">Omogoča nastavitev seznama vzorcev URL-jev, s katerim so določena spletna mesta, ki lahko prikazujejo obvestila.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena splošna privzeta vrednost iz pravilnika »DefaultNotificationsSetting«, kadar je ta nastavljen, ali iz uporabnikove osebne konfiguracije, kadar pravilnik »DefaultImagesSetting« ni nastavljen.</translation>
<translation id="2386362615870139244">Omogočanje zaklepanja preklopa zaslona iz mirovanja</translation>
<translation id="2411817661175306360">Opozorilo zaščite z geslom je izklopljeno</translation>
<translation id="2411919772666155530">Blokiraj obvestila na teh mestih</translation>
<translation id="2418507228189425036">Onemogoči shranjevanje zgodovine brskanja v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom preprečuje spreminjanje te nastavitve.

      Če je ta nastavitev omogočena, se zgodovina brskanja ne shranjuje. Ta nastavitev prav tako onemogoča sinhronizacijo zavihkov.

      Če je ta nastavitev onemogočena ali ni nastavljena, se zgodovina brskanja shranjuje.</translation>
<translation id="2426782419955104525">Omogoči dinamični način za <ph name="PRODUCT_NAME" /> in uporabnikom prepreči spreminjanje te nastavitve.

      Če to nastavitev omogočite, je dinamični način za <ph name="PRODUCT_NAME" /> omogočen.

      Če to nastavitev onemogočite, je dinamični način za <ph name="PRODUCT_NAME" /> onemogočen.

      Če to nastavitev omogočite ali onemogočite, je uporabniki ne morejo spremeniti ali preglasiti.

      Če te nastavitve ne nastavite, se lahko uporabnik odloči, ali želi uporabljati to funkcijo.

      Ta nastavitev je bila odstranjena iz programa <ph name="PRODUCT_NAME" /> 29 in novejših različic.</translation>
<translation id="2433412232489478893">Ta pravilnik nadzira, ali je funkcija omrežnih naprav za skupno rabo datotek za izdelek <ph name="PRODUCT_NAME" /> dovoljena za uporabnika.

      Če ta pravilnik ni konfiguriran ali je omogočen, bodo uporabniki lahko uporabljali omrežne naprave za skupno rabo datotek.

      Če je ta pravilnik onemogočen, uporabniki ne bodo mogli uporabljati omrežnih naprav za skupno rabo datotek.</translation>
<translation id="2438609638493026652">Omogoča poročanje Googlu o ključnih dogodkih pri namestitvi aplikacije za Android. Dogodki so zajeti samo za aplikacije, katerih namestitev je bila sprožena s pravilnikom.

      Če je pravilnik omogočen, bodo dogodki zabeleženi.
      Če je pravilnik onemogočen ali ni nastavljen, dogodki ne bodo zabeleženi.</translation>
<translation id="244317009688098048">Omogočanje bližnjičnih tipk, da se obide samodejna prijava.

      Če ta pravilnik ni nastavljen ali je nastavljen na »True« in je lokalni račun v napravi konfiguriran tako, da pri samodejni prijavi ni zakasnitve, <ph name="PRODUCT_OS_NAME" /> upošteva bližnjične tipke Ctrl + Alt + S, da obide samodejno prijavo in prikaz zaslona za prijavo.

      Če je ta pravilnik nastavljen na »False«, samodejne prijave brez zakasnitve (če je konfigurirana) ni mogoče obiti.</translation>
<translation id="2454228136871844693">Optimizacija za stabilnost.</translation>
<translation id="2463034609187171371">Omogočanje šifrirnih zbirk DHE v protokolu TLS</translation>
<translation id="2463365186486772703">Območne nastavitve programa</translation>
<translation id="2466131534462628618">Prestrezni portal za preverjanje pristnosti prezre strežnik proxy</translation>
<translation id="2471748297300970300">Če je onemogočen, preprečuje prikazovanje varnostnih opozoril, ko je Chrome zagnan z nekaterimi morebitno nevarnimi zastavicami »command-line«.

          Če je omogočen ali ni nastavljen, so varnostna opozorila prikazana, ko se za zagon Chroma uporabijo nekatere zastavice »command-line«.

          V sistemu Windows je ta pravilnik na voljo samo v primerkih, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="2482676533225429905">Izvorno pošiljanje sporočil</translation>
<translation id="2483146640187052324">Predvidevaj omrežna dejanja v kateri koli omrežni povezavi</translation>
<translation id="2484208301968418871">Ta pravilnik nadzira uporabo filtra URL-jev SafeSites.
      Ta filter uporablja API Google Safe Search za ugotavljanje, ali so URL-i pornografski ali ne.

      Če ta pravilnik ni konfiguriran ali nastavljen na »Ne filtriraj spletnih mest za vsebino za odrasle«, spletna mesta ne bodo filtrirana.

      Če je ta pravilnik nastavljen na »Filtriraj vrhnja spletna mesta za vsebino za odrasle«, bodo spletna mesta, klasificirana kot pornografska, filtrirana.</translation>
<translation id="2486371469462493753">Onemogoča uveljavljanje zahtev pravilnika o preglednosti potrdila za navedene URL-je.

      Ta pravilnik omogoča, da potrdila za imena gostiteljev v navedenih URL-jih niso razkrita na podlagi pravilnika o preglednosti potrdila. To omogoča nadaljnjo uporabo potrdil, ki bi bila sicer obravnavana, kot da niso zaupanja vredna, ker niso bila ustrezno javno razkrita, vendar otežuje odkrivanje neustrezno izdanih potrdil za te gostitelje.

      Vzorec URL-ja je oblikovan v skladu s tem: https://www.chromium.org/administrators/url-blacklist-filter-format. Glede na to, da so potrdila za dano ime gostitelja veljavna neodvisno od sheme, vrat ali poti, se upošteva samo del URL-ja z imenom gostitelja. Gostitelji z nadomestnimi znaki niso podprti.

      Če ta pravilnik ni nastavljen, bo vsako potrdilo, ki mora biti razkrito na podlagi pravilnika o preglednosti potrdila, obravnavano, kot da ni zaupanja vredno, če ne bo razkrito skladno s pravilnikom o preglednosti potrdila.</translation>
<translation id="2488010520405124654">Omogočanje poziva za konfiguracijo omrežja v stanju brez povezave.

      Če ta pravilnik ni nastavljen ali je nastavljen na »True« in je lokalni račun v
napravi konfiguriran tako, da pri samodejni prijavi ni zakasnitve, naprava pa nima dostopa do interneta, <ph name="PRODUCT_OS_NAME" /> prikaže poziv za konfiguracijo omrežja.

      Če je ta pravilnik nastavljen na »False«, se namesto poziva za konfiguracijo omrežja prikaže sporočilo o napaki.</translation>
<translation id="2498238926436517902">Vedno samodejno skrij polico</translation>
<translation id="2514328368635166290">Določa URL ikone priljubljene strani privzetega ponudnika iskanja.

          Ta pravilnik je izbiren. Če ni nastavljen, ikona za ponudnika iskanja ne bo prikazana.

          Ta pravilnik velja le, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="2516600974234263142">Omogoča tiskanje v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom prepreči spreminjanje te nastavitve.

      Če je ta nastavitev omogočena ali ni nastavljena, lahko uporabniki tiskajo.

      Če je ta nastavitev onemogočena, uporabniki v brskalniku <ph name="PRODUCT_NAME" /> ne morejo tiskati. Tiskanje je onemogočeno v meniju ključa, razširitvah, aplikacijah JavaScript itn. Tiskanje je še vedno mogoče prek vtičnikov, ki pri tiskanju zaobidejo <ph name="PRODUCT_NAME" />. Nekatere aplikacije Flash imajo na primer možnost tiskanja v priročnem meniju, česar ta pravilnik ne obsega.</translation>
<translation id="2518231489509538392">Omogočanje predvajanje zvoka</translation>
<translation id="2521581787935130926">Prikaz bližnjice za aplikacije v vrstici z zaznamki</translation>
<translation id="2529659024053332711">Omogoča, da določite način delovanja ob zagonu.

          Če izberete »Odpri nov zavihek s povezavami«, se bo ob vsakem zagonu brskalnika <ph name="PRODUCT_NAME" /> odprl nov zavihek s povezavami.

          Če izberete »Obnovi zadnjo sejo« se bodo znova odprli URL-ji, ki so bili odprti ob zadnjem zaprtju brskalnika <ph name="PRODUCT_NAME" />, seja brskanja pa bo obnovljena, kakršno ste zapustili.
          Če izberete to možnost, onemogočite nekatere nastavitve, ki so odvisne od sej ali ki izvedejo dejanja ob zapiranju (na primer brisanje podatkov brskanja ob zaprtju ali sejni piškotki).

          Če izberete »Odpri seznam URL-jev«, bo odprt seznam »URL-jev za odpiranje ob zagonu«, ko uporabnik zažene brskalnik <ph name="PRODUCT_NAME" />.

          Če omogočite to nastavitev, je uporabniki v brskalniku <ph name="PRODUCT_NAME" /> ne morejo spremeniti ali preglasiti.

          Če onemogočite to nastavitev, je enako, kot če je ne konfigurirate. Uporabnik jo v brskalniku <ph name="PRODUCT_NAME" /> še vedno lahko spremeni.

          Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="2529880111512635313">Konfiguriranje seznama vsiljenih namestitev aplikacij in razširitev</translation>
<translation id="253135976343875019">Časovni zamik opozorila o nedejavnosti ob napajanju iz električnega omrežja</translation>
<translation id="2536525645274582300">Uporabnik se odloči, ali bodo omogočene Googlove lokacijske storitve</translation>
<translation id="254653220329944566">Omogoča poročanje v oblaku brskalnika <ph name="PRODUCT_NAME" /></translation>
<translation id="2548572254685798999">Sporočanje podatkov o Varnem brskanju</translation>
<translation id="2550593661567988768">Samo enostransko tiskanje</translation>
<translation id="2552966063069741410">Časovni pas</translation>
<translation id="2562339630163277285">Določa URL iskalnika, ki se uporablja za prikaz rezultatov dinamičnega iskanja. URL mora vsebovati niz »<ph name="SEARCH_TERM_MARKER" />«, ki ga bo ob času poizvedbe nadomestilo besedilo, ki ga je uporabnik vnesel do takrat.

          Ta pravilnik je izbiren. Če ni nastavljen, ne bo prikazan noben rezultat dinamičnega iskanja.

          Googlov URL za rezultate dinamičnega iskanja je mogoče določiti kot: <ph name="GOOGLE_INSTANT_SEARCH_URL" />.

          Ta pravilnik velja le, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="2569647487017692047">Če je ta pravilnik onemogočen, bo sistem <ph name="PRODUCT_OS_NAME" /> onemogočil Bluetooth in ga uporabnik ne bo mogel znova omogočiti.

      Če je ta pravilnik omogočen ali ni nastavljen, bo uporabnik lahko Bluetooth po želji omogočil ali onemogočil.

      Če je ta pravilnik nastavljen, ga uporabnik ne more spremeniti ali preglasiti.

      Ko omogočite Bluetooth, se mora uporabnik odjaviti in znova prijaviti, da bodo spremembe izvedene (če Bluetooth onemogočite, tega uporabniku ni treba storiti).</translation>
<translation id="2571066091915960923">Omogoči ali onemogoči strežnik proxy za stiskanje podatkov in uporabnikom prepreči spreminjanje te nastavitve.
      Če omogočite ali onemogočite to nastavitev, je uporabniki ne morejo spremeniti ali preglasiti.

      Če ta pravilnik ni nastavljen, bo lahko uporabnik sam izbiral, ali želi uporabiti funkcijo strežnika proxy za stiskanje podatkov.</translation>
<translation id="257788512393330403">Vnos gesla je obvezen vsakih 6 ur</translation>
<translation id="2586162458524426376">
      Ta pravilnik se nanaša na zaslon za prijavo. Oglejte si tudi pravilnik <ph name="ISOLATE_ORIGINS_POLICY_NAME" />, ki se nanaša na uporabniško sejo.
      Če je pravilnik omogočen, se bo vsak naveden izvor s seznama, ločenega z vejicami, izvajal v svojem procesu. S tem bodo osamljeni tudi izvori, ki jih navedejo poddomene; če na primer navedete https://example.com/, bo kot del spletnega mesta https://example.com/ osamljeno tudi spletno mesto https://foo.example.com/.
      Če pravilnik ni konfiguriran ali je onemogočen, se bodo za zaslon za prijavo uporabljale privzete nastavitve okolja glede osamitve spletnih mest.
      </translation>
<translation id="2587719089023392205">Nastavi <ph name="PRODUCT_NAME" /> za privzeti brskalnik</translation>
<translation id="2592091433672667839">Trajanje nedejavnosti, preden se v maloprodajnem načinu na zaslonu za prijavo pokaže ohranjevalnik zaslona</translation>
<translation id="2592162121850992309">Če je ta pravilnik omogočen ali ni nastavljen, bo strojno pospeševanje omogočeno, razen če je določena funkcija GPE-ja na seznamu blokiranih.

      Če je ta pravilnik onemogočen, bo strojno pospeševanje onemogočeno.</translation>
<translation id="2596260130957832043">Nadzira, ali je omogočeno preverjanje pristnosti NTLMv2.

          Vse novejše različice strežnikov Samba in Windows podpirajo NTLMv2. To onemogočite samo za združljivost s prejšnjimi različicami, saj je v tem primeru zmanjšana varnost preverjanja pristnosti.

          Če ta pravilnik ni nastavljen, se uporabi privzeta vrednost in je preverjanje pristnosti NTLMv2 omogočeno.</translation>
<translation id="26023406105317310">Konfiguriranje računov za Kerberos</translation>
<translation id="2604182581880595781">Konfiguriranje pravilnikov, povezanih z omrežnimi napravami za skupno rabo datotek.</translation>
<translation id="2623014935069176671">Čakanje na začetno dejavnost uporabnika</translation>
<translation id="262740370354162807">Omogoča pošiljanje dokumentov v storitev <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="2627554163382448569">Posreduje konfiguracije za tiskalnike v podjetjih.

      Ta pravilnik vam omogoča, da posredujete konfiguracije tiskalnikov napravam z operacijskim sistemom <ph name="PRODUCT_OS_NAME" />. Oblika je enaka obliki imenika NativePrinters, z dodatnim obveznim poljem »id« ali »guid« na tiskalnik zaradi dodajanja na seznam dovoljenih ali nedovoljenih.

      Velikost datoteke ne sme presegati 5 MB in mora biti kodirana v obliki JSON. Ocenjuje se, da je datoteka, ki vsebuje približno 21.000 tiskalnikov, kodirana kot datoteka velikosti 5 MB. Za preverjanje celovitosti se uporablja kriptografska zgoščevalna vrednost.

      Datoteka se prenese in shrani v predpomnilnik. Ob vsaki spremembi URL-ja ali zgoščevalne vrednosti se znova prenese.

      Če je ta pravilnik nastavljen, <ph name="PRODUCT_OS_NAME" /> prenese datoteko s konfiguracijami tiskalnikov in omogoči, da so tiskalniki na voljo skladno s pravilniki <ph name="BULK_PRINTERS_ACCESS_MODE" />, <ph name="BULK_PRINTERS_WHITELIST" /> in <ph name="BULK_PRINTERS_BLACKLIST" />.

      Če nastavite ta pravilnik, ga uporabniki ne bodo mogli spremeniti ali preglasiti.

      Ta pravilnik ne vpliva na to, ali lahko uporabniki konfigurirajo tiskalnike v posameznih napravah. Namenjen je kot dopolnilo konfiguracijam tiskalnikov, ki jih opravijo posamezni uporabniki.
      </translation>
<translation id="2633084400146331575">Vklop izgovorjave</translation>
<translation id="2646290749315461919">Omogoča nastavitev, ali lahko spletna mesta sledijo uporabnikovi fizični lokaciji. Sledenje uporabnikovi fizični lokaciji je lahko privzeto dovoljeno, privzeto zavrnjeno ali pa je lahko uporabnik vprašan vsakič, ko spletno mesto zahteva fizično lokacijo.

          Če ta pravilnik ni nastavljen, bo uporabljen pravilnik »AskGeolocation« in uporabnik ga bo lahko spremenil.</translation>
<translation id="2647069081229792812">Omogoči ali onemogoči urejanje zaznamkov</translation>
<translation id="2649896281375932517">Odločijo naj se uporabniki</translation>
<translation id="2650049181907741121">Dejanje, ki naj se izvede, ko uporabnik zapre pokrov</translation>
<translation id="2655233147335439767">Določa URL iskalnika, ki se uporablja pri privzetem iskanju. URL mora vsebovati niz »<ph name="SEARCH_TERM_MARKER" />«, ki ga bodo ob času poizvedbe nadomestili izrazi, ki jih išče uporabnik.

          Googlov URL za iskanje je mogoče določiti kot: <ph name="GOOGLE_SEARCH_URL" />.

          Ta možnost mora biti nastavljena, ko je omogočen pravilnik »DefaultSearchProviderEnabled«, in bo veljala samo v tem primeru.</translation>
<translation id="2659019163577049044">Če je ta nastavitev omogočena, bo uporabnikom dovoljeno, da v napravah nastavijo sinhroniziranje sporočil SMS med telefoni in Chromebooki. Upoštevajte: če je ta pravilnik dovoljen, morajo uporabniki to funkcijo izrecno omogočiti, in sicer tako, da opravijo postopek nastavitve. Ko ga opravijo, bodo uporabniki lahko pošiljali in prejemali sporočila SMS v Chromebookih.

      Če je ta nastavitev onemogočena, uporabnikom ne bo dovoljeno nastaviti sinhroniziranja sporočil SMS.

      Če ta pravilnik ni nastavljen, funkcije privzeto ni dovoljeno uporabljati upravljanim uporabnikom, dovoljeno pa jo je uporabljati uporabnikom, ki niso upravljani.</translation>
<translation id="2660846099862559570">Nikoli ne uporabi proxyja</translation>
<translation id="2672012807430078509">Nadzira omogočanje protokola NTLM kot protokola za preverjanje pristnosti vpetih datotečnih sredstev SMB v skupni rabi</translation>
<translation id="267596348720209223">Določa kodiranja znakov, ki jih podpira ponudnik iskanja. Kodiranja so imena kodnih strani, na primer UTF-8, GB2312 in ISO-8859-1. Poskusi uporabe potekajo po navedenem vrstnem redu.

          Ta pravilnik je izbiren. Če ni nastavljen, bo uporabljena privzeta nastavitev, ki je UTF-8.

          Ta pravilnik velja le, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="268577405881275241">Omogoči funkcijo stiskanja podatkov v strežniku proxy</translation>
<translation id="2693108589792503178">Konfigurirajte URL za spremembo gesla.</translation>
<translation id="2694143893026486692">Zasidrana lupa je omogočena</translation>
<translation id="2706708761587205154">Omogočanje tiskanja samo s kodo PIN</translation>
<translation id="2710534340210290498">Če je ta pravilnik onemogočen, uporabniki ne bodo mogli zakleniti zaslona (mogoča bo samo odjava iz uporabniške seje). Če je ta nastavitev omogočena ali ni nastavljena, bodo lahko zaslon zaklenili uporabniki, ki so preverili pristnost z geslom.</translation>
<translation id="2731627323327011390">Onemogočanje uporabe potrdil sistema <ph name="PRODUCT_OS_NAME" /> aplikacijam ARC</translation>
<translation id="2742843273354638707">Skrivanje aplikacije Spletna trgovina Chrome in povezave v nogi na novem zavihku s povezavami in v zaganjalniku aplikacij v sistemu <ph name="PRODUCT_OS_NAME" />.

      Če je ta pravilnik nastavljen na »True«, so ikone skrite.

      Če je ta pravilnik nastavljen na »False« ali ni konfiguriran, so ikone vidne.</translation>
<translation id="2744751866269053547">Registracija rutin za obravnavo protokola</translation>
<translation id="2746016768603629042">Ta pravilnik je zastarel, namesto tega uporabite pravilnik »DefaultJavaScriptSetting«.

      Uporabiti ga je mogoče za onemogočen JavaScript v brskalniku <ph name="PRODUCT_NAME" />.

      Če je ta nastavitev onemogočena, spletne strani ne morejo uporabljati JavaScripta in uporabnik te vrednosti ne more spremeniti.

      Če je ta nastavitev omogočena ali ni nastavljena, lahko spletne strani uporabljajo JavaScript, toda uporabnik lahko to nastavitev spremeni.</translation>
<translation id="2753637905605932878">Omejitev obsega lokalnih vrat UDP, ki jih uporablja tehnologija WebRTC</translation>
<translation id="2757054304033424106">Vrste razširitev/aplikacij, katerih namestitev je dovoljena</translation>
<translation id="2758084448533744848">Določa uveljavljen časovni pas, ki se uporablja za napravo. Če je ta pravilnik nastavljen, uporabniki v napravi ne morejo preglasiti določenega časovnega pasu. Če je vnesena neveljavna vrednost, je pravilnik kljub temu aktiviran s časovnim pasom »GMT«. Če je naveden prazen niz, je pravilnik prezrt.

      Če se ta pravilnik ne uporablja, se uporablja trenutno aktivni časovni pas, uporabniki pa ga lahko spremenijo.

      Nove naprave imajo na začetku nastavljen časovni pas »ameriški/tihomorski«.

      Oblika vrednosti je v skladu z imeni časovnih pasov v zbirki podatkov o časovnih pasovih IANA (glejte »https://en.wikipedia.org/wiki/Tz_database«). Veliko časovnih pasov je mogoče navesti kot »celina/vele_mesto« ali »ocean/vele_mesto«.

      Če nastavite ta pravilnik, je v celoti onemogočeno samodejno določanje časovnega pasu glede na lokacijo naprave. Preglasi tudi pravilnik SystemTimezoneAutomaticDetection.</translation>
<translation id="2759224876420453487">Nadzor vedenja uporabnikov v večprofilni seji</translation>
<translation id="2761483219396643566">Časovni zamik opozorila o nedejavnosti ob napajanju iz akumulatorja</translation>
<translation id="2762164719979766599">Določa seznam lokalnih računov za napravo, ki bodo prikazani na zaslonu za prijavo.

      Vsak vnos na seznamu določa identifikator, ki se uporablja interno za razlikovanje med lokalnimi računi za napravo.</translation>
<translation id="2769952903507981510">Nastavitev zahtevanega imena domene za dostop do oddaljenih gostiteljev</translation>
<translation id="2783078941107212091">Omogočanje priporočil aplikacij v ničelnem stanju iskalnega polja v zaganjalniku.

          Če je ta pravilnik omogočen, so priporočila aplikacij morda prikazana v iskanju ničelnega stanja.

          Če ta pravilnik ni omogočen, priporočila aplikacij niso prikazana v iskanju ničelnega stanja.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če ta pravilnik ni nastavljen, je za upravljane naprave privzeta nastavitev »False«.</translation>
<translation id="2787173078141616821">Poročanje podatkov o stanju Androida</translation>
<translation id="2799297758492717491">Dovoli samodejno predvajanje predstavnosti na seznamu dovoljenih vzorcev URL</translation>
<translation id="2801155097555584385">Nastavitev prilagojene točke začetka polnjenja akumulatorja v odstotkih</translation>
<translation id="2801230735743888564">Uporabnikom dovoli igranje skrite igre z dinozavrom, ko je naprava brez internetne povezave.

      Če je ta pravilnik onemogočen, uporabniki ne bodo mogli igrati skrite igre z dinozavrom, ko je naprava brez internetne povezave. Če je nastavitev omogočena, bodo uporabniki lahko igrali igro. Če ta pravilnik ni nastavljen, uporabniki igre ne bodo mogli igrati v včlanjenem OS Chrome, lahko pa jo bodo igrali v drugih okoliščinah.</translation>
<translation id="2802085784857530815">Omogoča nadziranje, ali uporabniki lahko dostopajo do tiskalnikov, ki niso od podjetja.

      Če je pravilnik omogočen ali sploh ni nastavljen, lahko uporabniki dodajajo, konfigurirajo in tiskajo s svojimi izvornimi tiskalniki.

      Če je pravilnik onemogočen, uporabniki ne morejo dodajati ali konfigurirati svojih izvornih tiskalnikov. Prav tako ne morejo tiskati z že konfiguriranimi izvornimi tiskalniki.
      </translation>
<translation id="2805707493867224476">Dovoli vsem mestom, da pokažejo pojavna okna</translation>
<translation id="2808013382476173118">Omogoča uporabo strežnikov STUN, ko oddaljeni odjemalci poskušajo vzpostaviti zvezo s tem računalnikom.

          Če je ta nastavitev omogočena, lahko oddaljeni odjemalci odkrijejo te računalnike in se povežejo z njimi, tudi če jih ločuje požarni zid.

          Če je ta nastavitev onemogočena in izhodne povezave UDP filtrira požarni zid, bo ta računalnik dovolil samo povezave iz odjemalskih računalnikov v lokalnem omrežju.

          Če ta pravilnik ni nastavljen, bo nastavitev omogočena.</translation>
<translation id="2813281962735757923">Ta pravilnik nadzira obdobja, med katerimi napravi s sistemom <ph name="PRODUCT_OS_NAME" /> ni samodejno dovoljeno preverjati, ali so na voljo posodobitve.
      Če je ta pravilnik nastavljen na seznam časovnih intervalov, ki ni prazen:
      Naprave med določenimi časovnimi intervali ne bodo mogle samodejno preveriti, ali so na voljo posodobitve. Na naprave, ki jih je treba povrniti v prejšnje stanje ali ki uporabljajo nižjo različico operacijskega sistema <ph name="PRODUCT_OS_NAME" /> od najnižje zahtevane, zaradi morebitnih varnostnih težav ta pravilnik ne bo vplival. Poleg tega ta pravilnik ne bo blokiral zahtev za preverjanje, ali so na voljo posodobitve, ki jih izvedejo uporabniki ali skrbniki.
      Če ta pravilnik ni nastavljen ali ne vsebuje časovnih intervalov:
      Ta pravilnik ne bo blokiral samodejnih preverjanj, ali so na voljo posodobitve, vendar jih bodo morda blokirali drugi pravilniki. Ta funkcija je omogočena samo v napravah Chrome, ki so konfigurirane kot kioski s samodejnim zagonom. Drugih naprav ta pravilnik ne bo omejeval.</translation>
<translation id="2823870601012066791">Lokacija registra sistema Windows za odjemalce s sistemom <ph name="PRODUCT_OS_NAME" />:</translation>
<translation id="2824715612115726353">Omogoči način brez beleženja zgodovine</translation>
<translation id="2836621397261130126">Določa, ali se upošteva odobritev pravilnika KDC za odločanje, ali naj se delegirajo vstopnice za <ph name="KERBEROS" />.

          Če je ta pravilnik omogočen, preverjanje pristnosti HTTP upošteva nastavitve odobritev s pravilnikom KDC, torej Chrome poverilnice delegira samo, če KDC na vstopnici storitve nastavi <ph name="OK_AS_DELEGATE" />. Več informacij je na voljo na https://tools.ietf.org/html/rfc5896.html. Storitev se mora ujemati tudi s pravilnikom »AuthNegotiateDelegateWhitelist«.

          Če ta pravilnik ni nastavljen ali je onemogočen, se pravilnik KDC v podprtih okoljih prezre in se upošteva samo pravilnik »AuthNegotiateDelegateWhitelist«.

          V sistemu Windows se vedno upošteva pravilnik KDC.</translation>
<translation id="283695852388224413">Če je ta pravilnik nastavljen, se uveljavi konfigurirana največja dovoljena dolžina kode PIN. Vrednost 0 ali manj pomeni brez največje dovoljene dolžine; v tem primeru lahko uporabnik nastavi kodo PIN poljubne dolžine. Če je ta nastavitev manjša od <ph name="PIN_UNLOCK_MINIMUM_LENGTH_POLICY_NAME" />, vendar večja od 0, je največja dovoljena dolžina enaka najmanjši dovoljeni dolžini.

          Če ta pravilnik ni nastavljen, se ne uveljavi največja dovoljena dolžina.</translation>
<translation id="2838830882081735096">Prepoved selitve podatkov in ARC-ja</translation>
<translation id="2839294585867804686">Nastavitve omrežnih naprav za skupno rabo datotek</translation>
<translation id="2840269525054388612">Določa tiskalnike, ki jih uporabnik lahko uporablja.

      Ta pravilnik se uporablja samo, če je za pravilnik <ph name="DEVICE_PRINTERS_ACCESS_MODE" /> izbrana možnost <ph name="PRINTERS_WHITELIST" />.

      Če se uporablja ta pravilnik, so uporabniku na voljo samo tiskalniki z ID-ji, ki se ujemajo z vrednostmi v tem pravilniku. ID-ji morajo ustrezati polju »id« ali »guid« v datoteki, določeni v pravilniku <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="2842152347010310843">Nadzira seznam dovoljenih vzorcev URL-jev, za katere je samodejno predvajanje vedno omogočeno.

      Če je samodejno predvajanje omogočeno, se lahko v izdelku <ph name="PRODUCT_NAME" /> videoposnetki predvajajo samodejno (brez soglasja uporabnika) z zvočno vsebino.

      Tehnični podatki veljavnega vzorca URL-ja so:

      – [*.]domain.tld (ujema se z domain.tld in vsemi poddomenami)

      – host (ujema se s točnim imenom gostitelja)

      – scheme://host:port (podprte sheme: http, https)

      – scheme://[*.]domain.tld:port (podprte sheme: http, https)

      – file://path (pot mora biti absolutna pot, ki se začne z »/«)

      – a.b.c.d (ujema se s točnim naslovom IP po protokolu IPv4)

      – [a:b:c:d:e:f:g:h] (ujema se s točnim naslovom IP po protokolu IPv6)

      Če je pravilnik AutoplayAllowed nastavljen na »True«, ta pravilnik ne bo učinkoval.

      Če je pravilnik AutoplayAllowed nastavljen na »False«, bo za vzorce URL-jev, nastavljene v tem pravilniku, predvajanje še vedno dovoljeno.

      Upoštevajte: če se izdelek <ph name="PRODUCT_NAME" /> izvaja in se ta pravilnik spremeni, bo uveljavljen samo za novo odprte zavihke. Nekateri zavihki bodo zato morda še vedno delovali po starem.</translation>
<translation id="284288632677954003">URL datoteke XML z URL-ji, ki naj nikoli ne sprožijo preklopa brskalnika.</translation>
<translation id="285480231336205327">Omogoči visokokontrastni način</translation>
<translation id="2854919890879212089">Povzroči, da <ph name="PRODUCT_NAME" /> kot privzeto možnost v predogledu tiskanja uporabi sistemsko privzet tiskalnik namesto nazadnje uporabljenega tiskalnika.

      Če onemogočite to nastavitev ali ne nastavite vrednosti, predogled tiskanja kot privzeti cilj uporabi nazadnje uporabljeni tiskalnik.

      Če omogočite to nastavitev, predogled tiskanja kot privzeti cilj uporabi privzeti tiskalnik operacijskega sistema.</translation>
<translation id="285627849510728211">Nastavitev dnevne konfiguracije naprednega načina polnjenja akumulatorja</translation>
<translation id="2856674246949497058">Povrnite na ciljno različico in ostanite na njej, če je različica operacijskega sistema novejša kot ciljna. Med postopkom izvedite Powerwash.</translation>
<translation id="2872961005593481000">Zaustavitev</translation>
<translation id="2873651257716068683">Preglasi privzeto velikost tiskanih strani. Če velikost strani ni na voljo, je ta pravilnik prezrt.</translation>
<translation id="2874209944580848064">Opomba glede naprav s sistemom <ph name="PRODUCT_OS_NAME" />, ki podpirajo aplikacije za Android:</translation>
<translation id="2877225735001246144">Onemogoči iskanje CNAME pri pogajanju o preverjanju pristnosti Kerberos</translation>
<translation id="2890645751406497668">Samodejno odobravanje dovoljenj tem spletnim mestom za povezovanje z napravami USB z danimi ID-ji ponudnikov storitev in izdelkov.</translation>
<translation id="2892414556511568464">Omeji obojestransko tiskanje. Če pravilnik ni nastavljen ali je nabor prazen, ni omejitve.</translation>
<translation id="2893546967669465276">Pošiljanje sistemskih dnevnikov v strežnik za upravljanje</translation>
<translation id="2899002520262095963">Aplikacije za Android lahko uporabljajo omrežne konfiguracije in potrdila overitelja potrdil, nastavljena s tem pravilnikom, vendar nimajo dostopa do nekaterih možnosti konfiguracij.</translation>
<translation id="290002216614278247">Omogoča zaklepanje uporabnikove seje glede na čas odjemalca ali omejitev uporabe v dnevu.

          |time_window_limit| določa dnevno obdobje, v katerem je uporabnikova seja zaklenjena. Podpiramo samo eno pravilo za vsak dan v tednu, zato se polje |entries| morda razlikuje v velikosti od 0 do 7. |starts_at| in |ends_at| sta začetek in konec omejitve obdobja; če je |ends_at| manjši od |starts_at|, se |time_limit_window| konča naslednji dan. |last_updated_millis| je časovni žig časa UTC za zadnji čas, ko je bil ta vnos posodobljen. Poslan je kot niz, ker časovnega žiga ni mogoče spraviti v celo število.

          |time_usage_limit| določa omejitev dnevne uporabe. Ko jo uporabnik doseže, se uporabnikova seja zaklene. Za vsak dan v tednu je na voljo lastnost, ki jo nastavite le, če je za ta dan aktivna omejitev. |usage_quota_mins| določa, koliko časa v dnevu je mogoče uporabljati upravljano napravo, |reset_at| pa določa čas, ko se omejitev uporabe znova začne meriti od nič. Privzeta vrednost za |reset_at| je polnoč ({'hour': 0, 'minute': 0}). |last_updated_millis| je časovni žig časa UTC za zadnji čas, ko je bil ta vnos posodobljen. Poslan je kot niz, ker časovnega žiga ni mogoče spraviti v celo število..

          |overrides| je na voljo za začasno razveljavitev enega ali več prejšnjih pravil.
          * Če nista aktivna ne time_window_limit ne time_usage_limit, je za zaklepanje naprave mogoče uporabiti |LOCK|.
          * |LOCK| začasno zaklene uporabnikovo sejo, dokler se ne začne naslednji time_window_limit ali time_usage_limit.
          * |UNLOCK| odklene uporabnikovo sejo, ki jo zaklene time_window_limit ali time_usage_limit.
          |created_time_millis| je časovni žig časa UTC za ustvarjanje preglasitve. Poslan je kot niz, ker časovnega žiga ni mogoče spraviti v celo število. Uporabi se za določitev, ali se ta preglasitev še vedno uporabi. Če se je trenutno aktivna funkcija za omejitev časa (časovna omejitev uporabe ali omejitev časovnega obdobja) začela po ustvarjanju preglasitve, se ne izvaja. Če je bila preglasitev ustvarjena pred zadnjo spremembo aktivne omejitve time_window_limit ali aktivnega obdobja time_usage_window, se ne uporablja.

          Morda je poslanih več preglasitev. Uporabi se najnovejši veljavni vnos.</translation>
<translation id="2901725272378498025">Omogočanje varnostnih opozoril za zastavice »command-line«</translation>
<translation id="2905984450136807296">Življenjska doba predpomnjenja podatkov za preverjanje pristnosti</translation>
<translation id="2906874737073861391">Seznam razširitev AppPack</translation>
<translation id="2907992746861405243">Nadzira, kateri tiskalniki iz pravilnika <ph name="BULK_PRINTERS_POLICY" /> so na voljo uporabnikom.

      Določa, kateri pravilnik o dostopu se uporablja za konfiguracijo tiskalnikov v velikem obsegu. Če je izbrana možnost <ph name="PRINTERS_ALLOW_ALL" />, so prikazani vsi tiskalniki. Če je izbrana možnost <ph name="PRINTERS_BLACKLIST" />, se omeji dostop do določenih tiskalnikov s pravilnikom <ph name="BULK_PRINTERS_BLACKLIST" />. Če je izbrana možnost <ph name="PRINTERS_WHITELIST" />, pravilnik <ph name="BULK_PRINTERS_WHITELIST" /> določa samo tiste tiskalnike, ki jih je mogoče izbrati.

      Če ta pravilnik ni nastavljen, se predvideva uporaba pravilnika <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="2908277604670530363">Največje dovoljeno število hkratnih povezav s strežnikom proxy</translation>
<translation id="2952347049958405264">Omejitve:</translation>
<translation id="2956777931324644324">Ta pravilnik se ne uporablja od uveljavitve različice brskalnika <ph name="PRODUCT_NAME" /> 36.

      Določa, ali mora biti razširitev za potrdila, domensko vezana na TLS, omogočena.

      Ta nastavitev se uporablja, da se razširitev za potrdila, domensko vezana na TLS, omogoči za preskušanje. Ta poskusna nastavitev bo v prihodnosti odstranjena.</translation>
<translation id="2957506574938329824">Ne dovoli nobenemu spletnemu mestu zahtevanja dostopa do naprav Bluetooth prek API-ja za Web Bluetooth</translation>
<translation id="2957513448235202597">Vrsta računa za preverjanje pristnosti z razširitvijo <ph name="HTTP_NEGOTIATE" /></translation>
<translation id="2959469725686993410">Vedno pošlji dostopne točke Wi-Fi v strežnik pri določanju časovnega pasu</translation>
<translation id="2959898425599642200">Pravila, kdaj se obide proxy</translation>
<translation id="2960128438010718932">Produkcijski razpored za uveljavljanje nove posodobitve</translation>
<translation id="2960691910306063964">Omogočanje ali onemogočanje preverjanja pristnosti brez kode PIN za gostitelje za oddaljeni dostop</translation>
<translation id="2976002782221275500">Določa trajanje uporabnikove nedejavnosti, po preteku katere se zaslon zatemni, če se napaja iz akumulatorja.

          Če je pravilnik nastavljen na vrednost nad nič, določa, koliko časa mora biti uporabnik nedejaven, preden <ph name="PRODUCT_OS_NAME" /> zatemni zaslon.

          Če je pravilnik nastavljen na vrednost nič, <ph name="PRODUCT_OS_NAME" /> ne zatemni zaslona, ko uporabnik postane nedejaven.

          Če pravilnik ni nastavljen, se uporabi privzeto trajanje.

          Vrednost pravilnika naj bo navedena v milisekundah. Vrednosti morajo biti manjše ali enake kot časovni zamik izklopa zaslona (če je nastavljen) in časovnik zamik nedejavnosti.</translation>
<translation id="2977997796833930843">Upoštevajte, da je ta pravilnik zastarel in bo v prihodnosti odstranjen.

          Ta pravilnik določa rezervno vrednost za podrobnejša pravilnika <ph name="IDLE_ACTION_AC_POLICY_NAME" /> in <ph name="IDLE_ACTION_BATTERY_POLICY_NAME" />. Če je ta pravilnik nastavljen, se njegova vrednost uporabi, kadar ni nastavljen ustrezen podrobnejši pravilnik.

          Če ta pravilnik ni nastavljen, to ne vpliva na delovanje podrobnejših pravilnikov.</translation>
<translation id="2987155890997901449">Omogočanje ARC-ja</translation>
<translation id="2987227569419001736">Nadzor uporabe API-ja za Web Bluetooth</translation>
<translation id="2990018289267778247">Če je pravilnik nastavljen na »true«, so možnosti funkcij za ljudi s posebnimi potrebami vedno prikazane v meniju sistemske vrstice.

          Če je pravilnik nastavljen na »false«, možnosti funkcij za ljudi s posebnimi potrebami niso prikazane v meniju sistemske vrstice.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če ta pravilnik ni nastavljen, možnosti funkcij za ljudi s posebnimi potrebami niso prikazane v meniju sistemske vrstice, vendar lahko uporabniki nastavijo, da so možnosti funkcij za ljudi s posebnimi potrebami prikazane prek strani z nastavitvami.

          Če so omogočene funkcije za ljudi s posebnimi potrebami (na druge načine, na primer s kombinacijo tipk), so možnosti funkcij za ljudi s posebnimi potrebami vedno prikazane v meniju sistemske vrstice.</translation>
<translation id="3011301228198307065">Konfigurira privzeti URL domače strani za brskalnik <ph name="PRODUCT_NAME" /> in uporabnikom prepreči, da bi ga spreminjali.

          Domača stran je stran, ki se odpre ob kliku gumba »Domača stran«. Strani, ki se odprejo ob zagonu, določajo pravilniki RestoreOnStartup.

          Vrsta začetne strani je lahko določena z URL-jem, ki ga navedete tukaj, ali nastavljena na nov zavihek s povezavami. Če izberete nov zavihek s povezavami, ta pravilnik nima vpliva.

          Če omogočite to nastavitev, uporabniki ne bodo mogli spremeniti URL-ja domače strani za brskalnik <ph name="PRODUCT_NAME" />, lahko pa kot domačo stran še vedno izberejo nov zavihek s povezavami.

          Če tega pravilnika ne nastavite, bo lahko uporabnik sam izbral domačo stran, če ni nastavljen tudi pravilnik HomepageIsNewTabPage.

          URL mora imeti standardno shemo, kot je »http://primer.com« ali »https://primer.com«.

          Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="3016255526521614822">Uvrščanje aplikacij za zapiske, ki so omogočene na zaklenjenem zaslonu sistema <ph name="PRODUCT_OS_NAME" />, na seznam dovoljenih</translation>
<translation id="3021562480854470924">Število mejnikov, za katere je dovoljena povrnitev</translation>
<translation id="3023572080620427845">URL datoteke XML, ki vsebuje URL-je, ki naj se naložijo v nadomestnem brskalniku.</translation>
<translation id="3030000825273123558">Omogoči pošiljanje podatkov</translation>
<translation id="3033660238345063904">Tu lahko določite URL strežnika proxy.

          Ta pravilnik velja le, če ste v »Izberite, kako določiti nastavitve strežnika proxy« izbrali ročne nastavitve strežnika proxy in če pravilnik <ph name="PROXY_SETTINGS_POLICY_NAME" /> ni bil določen.

          Če ste za nastavitve pravilnikov za strežnik proxy izbrali drug način, tega pravilnika ne nastavljajte.

          Več o drugih možnostih in podrobnejše primere najdete na:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="3034580675120919256">Omogoča nastavitev, ali lahko spletna mesta izvajajo JavaScript. Izvajanje JavaScripta je lahko dovoljeno ali zavrnjeno za vsa spletna mesta.

          Če ta pravilnik ni nastavljen, bo omogočen pravilnik »AllowJavaScript«, uporabnik pa ga bo lahko spremenil.</translation>
<translation id="3038323923255997294">Nadaljuj izvajanje programov v ozadju, ko je <ph name="PRODUCT_NAME" /> zaprt</translation>
<translation id="3046192273793919231">Pošiljanje omrežnih paketov v strežnik za upravljanje zaradi spremljanja stanja povezave</translation>
<translation id="3047732214002457234">Nadzor, kako Chromovo čiščenje sporoča podatke Googlu</translation>
<translation id="304775240152542058">Ta pravilnik nadzira parametre ukazne vrstice za zagon nadomestnega brskalnika.

      Če ta pravilnik ni nastavljen, se kot parameter ukazne vrstice posreduje samo URL.

      Če je ta pravilnik nastavljen na seznam nizov, je vsak niz posredovan nadomestnemu brskalniku kot ločen parameter ukazne vrstice. V sistemu Windows so parametri združeni s presledki. V sistemih macOS in Linux lahko parameter vsebuje presledke in se še vedno obravnava kot en parameter.

      Če kateri element vsebuje ${url}, ga nadomesti URL strani, ki naj bo odprta.

      Če noben element ne vsebuje ${url}, je URL pripet na koncu ukazne vrstice.

      Spremenljivke okolja so razširjene. V sistemu Windows %ABC% nadomesti vrednost spremenljivke okolja ABC. V sistemih macOS in Linux ${ABC} nadomesti vrednost spremenljivke okolja ABC.</translation>
<translation id="3048744057455266684">Če je pravilnik nastavljen in predlagani iskalni URL iz naslovne vrstice vsebuje ta parameter v poizvedbi ali identifikatorju delov, predlog prikaže iskalne izraze in ponudnika iskanja namesto neobdelanega iskalnega URL-ja.

          Pravilnik je izbiren. Če ga ne nastavite, iskalni izrazi ne bodo nadomeščeni.

          Pravilnik se upošteva samo, če je pravilnik »DefaultSearchProviderEnabled« omogočen.</translation>
<translation id="3053265701996417839">Microsoft Windows 7</translation>
<translation id="306887062252197004">Ta pravilnik uporabnikom funkcije WebDriver omogoča preglasitev
      pravilnikov, ki lahko ovirajo njeno delovanje.

      Ta pravilnik trenutno onemogoča pravilnika SitePerProcess in IsolateOrigins.

      Če je pravilnik omogočen, bo funkcija WebDriver lahko preglasila nezdružljive
      pravilnike.
      Če je pravilnik onemogočen ali ni konfiguriran, funkciji WebDriver ne bo dovoljeno
      preglasiti nezdružljivih pravilnikov.</translation>
<translation id="3069958900488014740">Omogoča izklop optimizacije WPAD (samodejno odkrivanje strežnikov proxy v spletu) v brskalniku <ph name="PRODUCT_NAME" />.

      Če je ta pravilnik onemogočen, je optimizacija WPAD onemogočena, zaradi česa mora <ph name="PRODUCT_NAME" /> čakati dlje na strežnike WPAD, ki temeljijo na DNS-ju. Če pravilnik ni nastavljen ali je omogočen, je optimizacija WPAD omogočena.

      Neodvisno od tega, ali je pravilnik nastavljen oziroma kako je nastavljen, uporabniki ne morejo spremeniti nastavitve optimizacije WPAD.</translation>
<translation id="3072045631333522102">Ohranjevalnik zaslona na zaslonu za prijavo v maloprodajnem načinu</translation>
<translation id="3072847235228302527">Nastavitev pogojev storitve za lokalni račun v napravi.</translation>
<translation id="3077183141551274418">Omogoči ali onemogoči življenjske cikle zavihkov</translation>
<translation id="3079417254871857650">Določa dejanje, ki se mora izvesti, če je bil uporabnikov domači imenik ustvarjen s šifriranjem ecryptfs.

      Če ta pravilnik nastavite na »DisallowArc«, bodo aplikacije za Android onemogočene za uporabnika in izvedena ne bo nobena selitev s šifriranja ecryptfs na ext4. Izvajanje aplikacij za Android ne bo preprečeno, če je domači imenik že šifriran s šifriranjem ext4.

      Če ta pravilnik nastavite na »Migrate«, bodo domači imeniki, šifrirani s šifriranjem ecryptfs, samodejno preseljeni na šifriranje ext4 brez zahtevanja soglasja uporabnika.

      Če ta pravilnik nastavite na »Wipe«, bodo domači imeniki, šifrirani s šifriranjem ecryptfs, izbrisani ob prijavi in ustvarjeni bodo novi domači imeniki, šifrirani s šifriranjem ext4. Opozorilo: s tem odstranite uporabnikove lokalne podatke.

      Če ta pravilnik nastavite na »MinimalMigrate«, bodo domači imeniki, šifrirani s šifriranjem ecryptfs, izbrisani ob prijavi in ustvarjeni bodo novi domači imeniki, šifrirani s šifriranjem ext4. Pri tem se bo poskušalo ohraniti žetone za prijavo, da se uporabniku ni treba prijaviti znova. Opozorilo: s tem odstranite uporabnikove lokalne podatke.

      Če ta pravilnik nastavite na možnost, ki ni več podprta (»AskUser« ali »AskForEcryptfsArcUsers«), se bo obravnavalo, kot da ste izbrali možnost »Migrate«.

      Ta pravilnik se ne uporablja za uporabnike kioska. Če ta pravilnik ni nastavljen, bo naprava delovala, kot da bi bila izbrana možnost »DisallowArc«.</translation>
<translation id="3086995894968271156">Konfiguriranje sprejemnika za Google Cast v sistemu <ph name="PRODUCT_NAME" />.</translation>
<translation id="3088796212846734853">Omogoča nastavitev seznama vzorcev za URL-je, s katerim so določena spletna mesta, ki smejo prikazati slike.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena globalna privzeta vrednost iz pravilnika »DefaultImagesSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.

          Ta pravilnik je bil prej zmotno omogočen v Androidu, vendar ta funkcija ni bila nikoli v celoti podprta v Androidu.</translation>
<translation id="3091832372132789233">Polnjenje akumulatorjev naprav, ki so prvenstveno priključene na zunanji vir napajanja.</translation>
<translation id="3096595567015595053">Seznam omogočenih vtičnikov</translation>
<translation id="3101501961102569744">Izberite, kako določiti nastavitve strežnika proxy</translation>
<translation id="3101709781009526431">Datum in ura</translation>
<translation id="3114411414586006215">Ta pravilnik nadzira seznam spletnih mest, ki ne bodo nikoli povzročila preklopa brskalnika.

      Upoštevajte, da je mogoče elemente tudi dodati na ta seznam s pravilnikom <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Če ta pravilnik ni nastavljen, nobeno spletno mesto ni dodano na seznam.

      Če je ta pravilnik nastavljen, je vsak element obravnavan kot pravilo, podobno kot pri pravilniku <ph name="URL_LIST_POLICY_NAME" />. Vendar je tukaj logika obratna: pravila, ki se ujemajo, ne odprejo nadomestnega brskalnika.

      Drugače kot pri pravilniku <ph name="URL_LIST_POLICY_NAME" /> se pravila uporabljajo v obeh smereh. Če je torej nameščen in omogočen dodatek za Internet Explorer, ta prav tako nadzira, ali naj izdelek <ph name="IE_PRODUCT_NAME" /> odpre te URL-je v izdelku <ph name="PRODUCT_NAME" />.</translation>
<translation id="3117676313396757089">Opozorilo: DHE bo v celoti odstranjen iz programa <ph name="PRODUCT_NAME" /> po različici 57 (okoli marca 2017) in ta pravilnik bo takrat prenehal delovati.

      Če pravilnik ni nastavljen ali je onemogočen, šifrirne zbirke DHE v protokolu TLS ne bodo omogočene, sicer pa je lahko omogočen zaradi omogočanja šifrirnih zbirk DHE in ohranjanja združljivosti z zastarelim strežnikom. To je začasen ukrep in strežnik je treba na novo konfigurirati.

      Priporočamo, da začnete v strežnikih uporabljati šifrirne zbirke ECDHE. Če te niso na voljo, poskrbite, da bo omogočena šifrirna zbirka, ki uporablja izmenjavo ključev RSA.</translation>
<translation id="3117706142826400449">Če je pravilnik onemogočen, Chromovemu čiščenju prepreči pregledovanje, ali je v sistemu neželena programska oprema, in čiščenje. Ročna sprožitev Chromovega čiščenja v nastavitvah chrome://settings/cleanup je onemogočena.

      Če je pravilnik omogočen ali ni nastavljen, Chromovo čiščenje redno pregleduje, ali je v sistemu neželena programska oprema, in če jo najde, uporabnik prejme poziv, ali jo želi odstraniti. Ročna sprožitev Chromovega čiščenja v nastavitvah chrome://settings je omogočena.

      Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="3152425128389603870">Naj bo enotno namizje na voljo in privzeto vklopljeno</translation>
<translation id="3159375329008977062">Uporabniku je omogočen izvoz/uvoz vsebnikov za Crostini prek uporabniškega vmesnika</translation>
<translation id="3165808775394012744">Ti pravilniki so vključeni tukaj, da jih je mogoče lažje odstraniti.</translation>
<translation id="316778957754360075">Ta nastavitev se ne uporablja od uveljavitve različice brskalnika <ph name="PRODUCT_NAME" /> 29. Za nastavitev zbirk razširitev/aplikacij, ki gostujejo v organizaciji, se priporoča, da se spletno mesto, na katerem gostujejo paketi CRX, vključi na seznam ExtensionInstallSources in da se na spletno mesto dodajo povezave za neposreden prenos paketov. Zaganjalnik za to stran se lahko ustvari s pravilnikom ExtensionInstallForcelist.</translation>
<translation id="3168968618972302728">Pravilniki, povezani s preverjanjem pristnosti Kerberos.</translation>
<translation id="3171369832001535378">Predloga za ime gostitelja omrežja naprave</translation>
<translation id="3172512016079904926">Omogoči nameščanje gostiteljev izvornega pošiljanja sporočil na uporabniški ravni.

          Če je ta nastavitev omogočena, <ph name="PRODUCT_NAME" /> dovoli uporabo gostiteljev izvornega pošiljanja sporočil, nameščenih na uporabniški ravni.

          Če ta nastavitev ni omogočena, bo <ph name="PRODUCT_NAME" /> uporabljal samo gostitelje izvornega pošiljanja sporočil, nameščene na sistemski ravni.

          Če ta nastavitev ni nastavljena, bo <ph name="PRODUCT_NAME" /> dovolil uporabo gostiteljev izvornega pošiljanja na uporabniški ravni.</translation>
<translation id="3177802893484440532">Zahtevanje spletnih preverjanj OCSP/CRL za lokalna sidra zaupanja</translation>
<translation id="3185009703220253572">od različice <ph name="SINCE_VERSION" /></translation>
<translation id="3187220842205194486">Aplikacije za Android ne morejo dobiti dostopa do ključev podjetja. Ta pravilnik nanje ne vpliva.</translation>
<translation id="3205825995289802549">Povečaj prvo okno brskalnika pri prvem izvajanju</translation>
<translation id="3211426942294667684">Nastavitve prijave v brskalnik</translation>
<translation id="3214164532079860003">Če je ta pravilnik omogočen, se domača stran uvozi iz trenutnega privzetega brskalnika.

      Če je onemogočen, se domača stran ne uvozi.

      Če ni nastavljen, bo uporabnik morda vprašan, ali naj jo uvozi, ali pa bo uvoz izveden samodejno.</translation>
<translation id="3219421230122020860">Način brez beleženja zgodovine je na voljo</translation>
<translation id="3220624000494482595">Če je aplikacija za kiosk aplikacija za Android, ne bo imela nadzora nad različico sistema <ph name="PRODUCT_OS_NAME" />, tudi če je ta pravilnik nastavljen na <ph name="TRUE" />.</translation>
<translation id="3236046242843493070">Vzorci URL-jev, ki omogočajo namestitev razširitev, aplikacij in uporabniških skriptov iz</translation>
<translation id="3240609035816615922">Pravilnik o dostopu do konfiguracij tiskalnikov.</translation>
<translation id="3240655340884151271">V nosilcu vgrajen naslov NIC MAC</translation>
<translation id="3243309373265599239">Določa trajanje uporabnikove nedejavnosti, po preteku katere se zaslon zatemni, če se napaja iz električnega omrežja.

          Če je pravilnik nastavljen na vrednost nad nič, določa, koliko časa mora biti uporabnik nedejaven, preden <ph name="PRODUCT_OS_NAME" /> zatemni zaslon.

          Če je pravilnik nastavljen na vrednost nič, <ph name="PRODUCT_OS_NAME" /> ne zatemni zaslona, ko uporabnik postane nedejaven.

          Če pravilnik ni nastavljen, se uporabi privzeto trajanje.

          Vrednost pravilnika naj bo navedena v milisekundah. Vrednosti morajo biti manjše ali enake kot časovni zamik izklopa zaslona (če je nastavljen) in časovnik zamik nedejavnosti.</translation>
<translation id="3251500716404598358">Konfiguriranje pravilnikov za preklop med brskalniki.

      Konfigurirana spletna mesta se samodejno odprejo v brskalniku, ki ni <ph name="PRODUCT_NAME" />.</translation>
<translation id="3264793472749429012">Privzeto kodiranje iskalnika</translation>
<translation id="3273221114520206906">Privzeta nastavitev JavaScripta</translation>
<translation id="3284094172359247914">Nadzor uporabe API-ja za WebUSB</translation>
<translation id="3288595667065905535">Kanal za izdaje</translation>
<translation id="3292147213643666827">Omogoča, da <ph name="PRODUCT_NAME" /> deluje kot proxy med storitvijo <ph name="CLOUD_PRINT_NAME" /> in starejšimi tiskalniki, priključenimi na računalnik.

      Če je ta nastavitev omogočena ali ni nastavljena, lahko uporabniki s preverjanjem pristnosti prek računa za Google omogočijo proxy za tiskanje v oblaku.

      Če je ta nastavitev onemogočena, uporabniki ne morejo omogočiti proxyja, računalnik pa tiskalnikov ne bo smel dati v skupno rabo s storitvijo <ph name="CLOUD_PRINT_NAME" />.</translation>
<translation id="3312206664202507568">Omogoča stran na chrome://password-change, ki uporabnikom prijave SAML omogoča spremembo gesel za prijavo SAML med sejo, s čimer se zagotovi, da sta geslo za prijavo SAML in geslo za zaklenjen zaslon naprave sinhronizirana.

      Ta pravilnik prav tako omogoča obvestila, ki uporabnike prijave SAML opozorijo, če bodo njihova gesla za prijavo SAML kmalu potekla, tako da lahko to težavo takoj odpravijo s spremembo gesla med sejo.
      Toda ta obvestila bodo prikazana samo, če podatke o poteku gesla v napravo pošlje ponudnik identitete za prijavo SAML med potekom prijave SAML.

      Če je ta pravilnik nastavljen, ga uporabniki ne morejo spremeniti ali preglasiti.</translation>
<translation id="3322771899429619102">Omogoča nastavitev seznama vzorcev URL-jev, s katerim so določena mesta, ki smejo uporabljati ustvarjanje ključev. Če je vzorec URL-ja v »KeygenBlockedForUrls«, to preglasi te izjeme.

         Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena splošna privzeta vrednost iz pravilnika »DefaultKeygenSetting«, kadar je ta nastavljen, ali iz uporabnikove osebne konfiguracije, kadar pravilnik »DefaultKeygenSetting« ni nastavljen.</translation>
<translation id="332771718998993005">Določanje sporočenega imena cilja za napravo <ph name="PRODUCT_NAME" />.

          Če je pravilnik nastavljen na niz, ki ni prazen, je ta niz uporabljen kot ime cilja za napravo <ph name="PRODUCT_NAME" />, sicer pa je ime cilja ime naprave. Če ta pravilnik ni nastavljen, je ime cilja ime naprave in lastnik naprave (ali uporabnik v domeni, ki upravlja napravo) ga sme spremeniti. Ime je omejeno na 24 znakov dolžine.</translation>
<translation id="3335468714959531450">Omogoča nastavitev seznama vzorcev URL-jev, ki določa, katerim spletnim mestom je dovoljeno nastavljanje piškotkov.

          Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi globalna privzeta vrednost iz pravilnika »DefaultCookiesSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.

          Glejte tudi pravilnika »CookiesBlockedForUrls« in »CookiesSessionOnlyForUrls«. V teh treh pravilnikih ne sme biti vzorcev URL v sporu – ni določeno, kateri pravilnik ima prednost.</translation>
<translation id="3373364525435227558">Nastavi enega ali več priporočenih jezikov za upravljano sejo in uporabnikom omogoči, da preprosto izberejo enega izmed njih.

      Uporabnik lahko izbere jezik in postavitev tipkovnice pred začetkom upravljane seje. Vsi jeziki, ki jih podpira operacijski sistem <ph name="PRODUCT_OS_NAME" />, so privzeto navedeni v abecednem vrstnem redu. S tem pravilnikom lahko pomaknete niz priporočenih jezikov na vrh seznama.

      Če ta pravilnik ni nastavljen, bo vnaprej izbran trenutni jezik uporabniškega vmesnika.

      Če ta pravilnik je nastavljen, bodo priporočeni jeziki pomaknjeni na vrh seznama in bodo vidno ločeni od drugih jezikov. Priporočeni jeziki bodo navedeni v vrstnem redu, po katerem se pojavljajo v pravilniku. Vnaprej izbran bo prvi priporočeni jezik.

      Če je več priporočenih jezikov, se domneva, da bodo uporabniki želeli izbirati med temi jeziki. Izbira jezika in postavitve tipkovnice bo vidno ponujena ob začetku upravljane seje. V nasprotnem primeru se domneva, da bo večina uporabnikov želela uporabljati vnaprej izbrani jezik. Izbira jezika in postavitve tipkovnice bo manj vidno ponujena ob začetku upravljane seje.

      Če je ta pravilnik nastavljen in je omogočena samodejna prijava (glejte pravilnika |DeviceLocalAccountAutoLoginId| in |DeviceLocalAccountAutoLoginDelay|), bo samodejno začeta upravljana seja uporabljala prvi priporočeni jezik in najbolj priljubljeno postavitev tipkovnice, ki se ujema s tem jezikom.

      Vnaprej izbrana postavitev tipkovnice bo vedno najbolj priljubljena postavitev, ki se ujema z vnaprej izbranim jezikom.

      Ta pravilnik je mogoče nastaviti samo kot priporočenega. S tem pravilnikom lahko pomaknete niz priporočenih jezikov na vrh, vendar je uporabnikom vedno dovoljeno izbrati kateri koli jezik, ki ga operacijski sistem <ph name="PRODUCT_OS_NAME" /> podpira za njihovo sejo.
      </translation>
<translation id="3381968327636295719">Privzeto uporabi brskalnik gostitelja</translation>
<translation id="3384115339826100753">Omogočanje pravilnika za upravljanje porabe energije s funkcijo preklopa na akumulatorsko napajanje ob konicah.

          Preklop na akumulatorsko napajanje ob konicah predstavlja pravilnik za varčevanje z energijo, ki zmanjša uporabo izmeničnega toka v obdobjih dneva, ko je poraba energije v električnem omrežju največja. Za vsak dan v tednu je mogoče nastaviti začetni in končni čas delovanja v načinu s preklopom na akumulatorsko napajanje ob konicah. V teh obdobjih bo sistem deloval na energijo iz akumulatorja, tudi če je priklopljen na izmenični tok, dokler raven energije v akumulatorju presega določen prag. Po koncu določenega časa bo sistem deloval na izmenični tok, če je priklopljen nanj, akumulatorja pa ne bo obremenjeval. Sistem bo znova deloval normalno, in sicer tako, da bo uporabljal izmenični tok ter polnil akumulator, po začetku določenega začetnega časa za polnjenje.

          Če je ta pravilnik omogočen in sta nastavljena pravilnika DevicePowerPeakShiftBatteryThreshold in DevicePowerPeakShiftDayConfig, je funkcija preklopa na akumulatorsko napajanje ob konicah v napravi vedno omogočena, če jo naprava podpira.

          Če je pravilnik onemogočen, je funkcija preklopa na akumulatorsko napajanje ob konicah vedno onemogočena.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če ta pravilnik ni nastavljen, je funkcija preklopa na akumulatorsko napajanje ob konicah sprva onemogočena in je uporabnik ne more omogočiti.</translation>
<translation id="3414260318408232239">Če ta pravilnik ni konfiguriran, <ph name="PRODUCT_NAME" /> uporablja privzeto najnižjo različico, ki je TLS 1.0.

      Sicer bo nastavljen na eno od teh vrednosti: »tls1«, »tls1.1« ali »tls1.2«. Če je nastavljen, <ph name="PRODUCT_NAME" /> ne bo uporabljal različic protokolov SSL/TLS, nižjih od navedene različice. Neprepoznane vrednosti bodo prezrte.</translation>
<translation id="34160070798637152">Nadzira konfiguracijo omrežja za napravo.</translation>
<translation id="3417418267404583991">Če je ta pravilnik omogočen ali ni nastavljen, <ph name="PRODUCT_OS_NAME" /> omogoči prijave gostov. Prijave gostov so anonimne seje uporabnikov in ne zahtevajo gesla.

      Če je pravilnik onemogočen, <ph name="PRODUCT_OS_NAME" /> ne omogoča sej gosta.</translation>
<translation id="3418871497193485241">Uveljavi najmanjši mogoč Omejeni način v YouTubu in uporabnikom prepreči,
      da bi izbrali manj omejen način.

      Če je ta nastavitev nastavljena na »Strogo«, je Strogo omejeni način v YouTubu vedno aktiven.

      Če je ta nastavitev nastavljena na »Zmerno«, lahko uporabnik v YouTubu izbere samo Zmerno omejeni način
      in Strogo omejeni način, Omejenega načina pa ne more onemogočiti.

      Če je ta nastavitev nastavljena na »Izklopljeno« ali ni nastavljena nobena vrednost, <ph name="PRODUCT_NAME" /> v YouTubu ne uveljavi Omejenega načina. Zunanji pravilniki, na primer pravilniki za YouTube, lahko še vedno uveljavijo Omejeni način.</translation>
<translation id="3428247105888806363">Omogoči omrežno predvidevanje</translation>
<translation id="3432863169147125747">Nadzira nastavitve tiskanja.</translation>
<translation id="3434932177006334880">Ta nastavitev se je pred Chromom različice 42 imenovala »EnableWebBasedSignin«, podpora zanjo pa bo v celoti odstranjena v Chromu različice 43.

      Ta nastavitev je koristna za poslovne stranke, ki uporabljajo sisteme enotne prijave, ki še niso združljivi z novim potekom prijave v vrstici.
      Če to nastavitev omogočite, se uporablja stari potek prijave v spletu.
      Če to nastavitev onemogočite ali je ne nastavite, bo privzeto uporabljen novi potek prijave v vrstici. Uporabniki lahko še vedno omogočijo stari potek prijave v spletu s to zastavico v ukazni vrstici: »--enable-web-based-signin«.

      Poskusna nastavitev bo odstranjena, ko bo potek prijave v vrstici združljiv z vsemi poteki sistemov enotne prijave.</translation>
<translation id="3437924696598384725">Omogočanje uporabnikom, da upravljajo povezave VPN</translation>
<translation id="3459509316159669723">Tiskanje</translation>
<translation id="3460784402832014830">Določa URL, ki ga iskalnik uporablja za nov zavihek s povezavami.

          Ta pravilnik je izbiren. Če ni nastavljen, ne bo novega zavihka s povezavami.

          Ta pravilnik se upošteva samo, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="3461279434465463233">Poročanje o stanju napajanja</translation>
<translation id="346731943813722404">Določa, ali naj se zakasnitve upravljanja porabe in omejitev dolžine seje začnejo izvajati šele po prvi zaznani dejavnosti uporabnika v seji.

          Če je pravilnik nastavljen na »True«, se zakasnitve upravljanja porabe in omejitev dolžine seje ne začnejo izvajati, dokler v seji ni zaznana prva dejavnost uporabnika.

          Če je pravilnik nastavljen na »False« oziroma ni nastavljen, se zakasnitve upravljanja porabe in omejitev dolžine seje začnejo izvajati takoj ob začetku seje.</translation>
<translation id="3478024346823118645">Ob odjavi izbriši uporabniške podatke</translation>
<translation id="3480961938508521469">Polnjenje akumulatorja do napolnjenosti z običajno hitrostjo.</translation>
<translation id="348495353354674884">Omogoči navidezno tipkovnico</translation>
<translation id="3487623755010328395">
        Če je ta pravilnik nastavljen, se bo <ph name="PRODUCT_NAME" /> poskusil registrirati in uporabiti povezani pravilnik oblaka za vse profile.

        Vrednost tega pravilnika je žeton za včlanitev, ki ga je mogoče pridobiti v konzoli Google Admin console.</translation>
<translation id="3489247539215560634">Če je ta nastavitev omogočena, si lahko <ph name="PRODUCT_NAME" /> zapomni gesla in jih samodejno ponudi uporabnikom, ko se naslednjič prijavijo v spletno mesto.

          Če je ta nastavitev onemogočena, uporabniki ne morejo shranjevati novih gesel, vendar
          lahko še vedno uporabljajo že shranjena gesla.

          Če je ta pravilnik omogočen ali onemogočen, ga uporabniki v brskalniku <ph name="PRODUCT_NAME" /> ne morejo spremeniti ali preglasiti. Če ta pravilnik ni nastavljen, je shranjevanje gesel dovoljeno (vendar ga lahko uporabnik izklopi).</translation>
<translation id="3496296378755072552">Upravitelj gesel</translation>
<translation id="3500732098526756068">Omogoča nadziranje sprožanja opozorila zaščite gesel. Zaščita gesel opozori uporabnike, kadar na morebitno nevarnih spletnih mestih znova uporabijo zaščiteno geslo.

      S pravilnikoma »PasswordProtectionLoginURLs« in »PasswordProtectionChangePasswordURL« lahko konfigurirate, katera gesla naj bodo zaščitena.

      Če je ta pravilnik nastavljen na »PasswordProtectionWarningOff«, ne bo prikazano nobeno opozorilo zaščite gesel.
      Če je ta pravilnik nastavljen na »PasswordProtectionWarningOnPasswordReuse«, bo opozorilo zaščite gesel prikazano, kadar uporabnik znova uporabi zaščiteno geslo na spletnem mestu, ki ni uvrščeno na seznam dovoljenih.
      Če je ta pravilnik nastavljen na »PasswordProtectionWarningOnPhishingReuse«, bo opozorilo zaščite gesel prikazano, kadar uporabnik znova uporabi zaščiteno geslo na spletnem mestu z lažnim predstavljanjem.
      Če ta pravilnik ni nastavljen, bo storitev zaščite gesel ščitila samo gesla za Google, uporabnik pa bo to nastavitev lahko spremenil.</translation>
<translation id="3502555714327823858">Dovoli vse načine obojestranskega tiskanja</translation>
<translation id="350443680860256679">Konfiguriranje ARC-a</translation>
<translation id="3504791027627803580">Določa URL iskalnika, ki se uporabi za slikovno iskanje. Iskalne poizvedbe se pošljejo z metodo GET. Če je nastavljen pravilnik DefaultSearchProviderImageURLPostParams, se zahteve za slikovno iskanje pošljejo z metodo POST.

          Ta pravilnik je izbiren. Če ni nastavljen, se ne uporabi nobeno slikovno iskanje.

          Ta pravilnik se upošteva samo, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="350797926066071931">Omogoči Google Prevajalnik</translation>
<translation id="3513655665999652754">Strežnik Quirks Server ponuja konfiguracijske datoteke za posamezne komponente strojne opreme, kot so
      prikazovalni profili ICC za prilagajanje umerjanja monitorja.

      Če je ta pravilnik nastavljen na »False«, naprava ne bo poskušala
      vzpostaviti stika s strežnikom Quirks Server in prenesti konfiguracijskih datotek.

      Če je ta pravilnik nastavljen na »True« ali ni konfiguriran, bo <ph name="PRODUCT_OS_NAME" /> samodejno vzpostavil stik s strežnikom Quirks Server in prenesel konfiguracijske datoteke, če so na voljo, ter jih shranil v napravi.  Te datoteke je mogoče na primer uporabiti za izboljšanje kakovosti prikaza priključenih monitorjev.</translation>
<translation id="3524204464536655762">Ne dovoli nobenemu spletnemu mestu zahtevanja dostopa do naprav USB prek API-ja za WebUSB</translation>
<translation id="3526752951628474302">Samo enobarvno tiskanje</translation>
<translation id="3528000905991875314">Omogoči nadomestne strani za napake</translation>
<translation id="3545457887306538845">Omogoča nadzor nad tem, kje se lahko uporabijo orodja za razvijalce.

      Če je ta pravilnik nastavljen na »DeveloperToolsDisallowedForForceInstalledExtensions« (vrednost 0, ki je privzeta vrednost), je dostop do orodij za razvijalce in konzole JavaScript na splošno mogoč, vendar ne v kontekstu razširitev, nameščenih s pravilnikom podjetja.
      Če je ta pravilnik nastavljen na »DeveloperToolsAllowed« (vrednost 1), sta dostop do orodij za razvijalce in konzole JavaScript ter njihova uporaba mogoča v vseh kontekstih, vključno s kontekstom razširitev, nameščenih s pravilnikom podjetja.
      Če je ta pravilnik nastavljen na »DeveloperToolsDisallowed« (vrednost 2), dostop do orodij za razvijalce ni mogoč in elementov na spletnih mestih ne bo več mogoče pregledovati. Vse bližnjične tipke in vnosi v meniju ali kontekstnem meniju za odpiranje orodij za razvijalce in konzole JavaScript bodo onemogočeni.</translation>
<translation id="3547954654003013442">Nastavitve proxyja</translation>
<translation id="3550875587920006460">Omogoča nastavitev razporeda po meri za preverjanje, ali so na voljo posodobitve. To velja za vse uporabnike in vse vmesnike v napravi. Ko je pravilnik nastavljen, bo naprava preverjala, ali so na voljo posodobitve, glede na razpored. Ta pravilnik je treba odstraniti, če želite preklicati nadaljnja načrtovana preverjanja, ali je na voljo posodobitev.</translation>
<translation id="355118380775352753">Spletna mesta za odpiranje v nadomestnem brskalniku</translation>
<translation id="3554984410014457319">Omogočanje Pomočniku Google, da posluša, ali je izgovorjena besedna zveza za glasovno aktiviranje</translation>
<translation id="3557208865710006939">Vsili omogočanje jezikov za preverjanje črkovanja. Neprepoznani jeziki na seznamu so prezrti.

      Če omogočite ta pravilnik, je preverjanje črkovanja omogočeno za navedene jezike poleg jezikov, za katere je uporabnik omogočil preverjanje črkovanja.

      Če ne nastavite tega pravilnika ali ga onemogočite, ni sprememb uporabnikovih nastavitev preverjanja črkovanja.

      Če je pravilnik <ph name="SPELLCHECK_ENABLED_POLICY_NAME" /> onemogočen, ta pravilnik nima učinka.

      Če je jezik vključen v ta pravilnik in pravilnik <ph name="SPELLCHECK_LANGUAGE_BLACKLIST_POLICY_NAME" />, ima ta pravilnik prednost in jezik za preverjanje črkovanja je omogočen.

      Za zdaj so podprti jeziki: 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="356579196325389849">Uporabniki lahko konfigurirajo kanal za izdaje sistema OS Chrome</translation>
<translation id="3575011234198230041">Preverjanje pristnosti HTTP</translation>
<translation id="3577251398714997599">Nastavitve oglasov za spletna mesta z vsiljivimi oglasi</translation>
<translation id="357917253161699596">Uporabnikom dovoli upravljanje uporabniških potrdil</translation>
<translation id="3583230441447348508">Določa seznam vnaprej konfiguriranih omrežnih datotečnih sredstev v skupni rabi.

      Vsak seznam elementov pravilnika je predmet z dvema členoma: »share_url« in »mode«. »share_url« mora biti URL datotečnega sredstva v skupni rabi, »mode« pa mora imeti vrednost »drop_down« ali »pre_mount«. Način »drop_down« označuje, da bo »share_url« dodan v spustni meni odkrivanja datotečnih sredstev v skupni rabi. Način »pre_mount« označuje, da bo vpet »share_url«.</translation>
<translation id="3591527072193107424">Omogočanje funkcije podpore za zastarele brskalnike.</translation>
<translation id="3591584750136265240">Konfiguriranje preverjanja pristnosti pri prijavi</translation>
<translation id="3627678165642179114">Omogoči ali onemogoči spletno storitev preverjanja črkovanja</translation>
<translation id="3628480121685794414">Omogoči enostransko tiskanje</translation>
<translation id="3631099945620529777">Če je pravilnik onemogočen, je gumb za končanje procesa v upravitelju opravil onemogočen.

      Če je pravilnik omogočen ali ni konfiguriran, lahko uporabnik konča procese v upravitelju opravil.</translation>
<translation id="3643284063603988867">Omogočanje funkcije »Zapomni si geslo«</translation>
<translation id="3646859102161347133">Nastavitev vrste lupe</translation>
<translation id="3653237928288822292">Privzeta ikona iskalnika</translation>
<translation id="3660510274595679517">
        Če je ta pravilnik nastavljen na »True«, je včlanitev v upravljanje v oblaku obvezna in blokira postopek zagona Chroma, če je neuspešna.

        Če pravilnik ni nastavljen ali je nastavljen na »False«, je včlanitev v upravljanje v oblaku izbirna in ne blokira postopka zagona Chroma, če je neuspešna.

        Ta pravilnik uporablja včlanitev v pravilnik oblaka v obsegu naprave v namiznem računalniku in ga je mogoče nastaviti prek registra ali pravilnika skupine v sistemu Windows, prek datoteke plist v sistemu macOS in datoteke pravilnika v obliki zapisa JSON v Linuxu.</translation>
<translation id="3660562134618097814">Prenesi piškotke SAML IdP pri prijavi</translation>
<translation id="3701121231485832347">Nadzira nastavitve za naprave s sistemom <ph name="PRODUCT_OS_NAME" />, ki jih upravlja <ph name="MS_AD_NAME" />.</translation>
<translation id="3702518095257671450">Potrditev na daljavo</translation>
<translation id="3702647575225525306"><ph name="POLICY_NAME" /> (Enovrstično polje je zastarelo in bo v prihodnje odstranjeno. Začnite uporabljati večvrstično besedilno polje spodaj.)</translation>
<translation id="3709266154059827597">Nastavi seznam razširitev, katerih namestitev je prepovedana</translation>
<translation id="3711895659073496551">Prekinitev</translation>
<translation id="3715569262675717862">Preverjanje pristnosti glede na potrdila odjemalca</translation>
<translation id="3736879847913515635">Omogočanje dodajanja oseb v upravitelju uporabnikov</translation>
<translation id="3738723882663496016">Ta pravilnik določa licenčni ključ <ph name="PLUGIN_VM_NAME" /> za to napravo.</translation>
<translation id="3748900290998155147">Določa, ali so omogočena zaklepanja prebujanja. Zaklepanja prebujanja lahko zahtevajo razširitve prek API-ja razširitve za upravljanje energije in aplikacije ARC.

          Če je ta pravilnik omogočen ali ni nastavljen, bodo za upravljanje energije uporabljena zaklepanja prebujanja.

          Če je ta pravilnik onemogočen, bodo zahteve za zaklepanje prebujanja prezrte.</translation>
<translation id="3750220015372671395">Blokiraj ustvarjanje ključev na teh spletnih mestih</translation>
<translation id="375266612405883748">Omeji obseg vrat UDP, ki jih uporablja gostitelj oddaljenega dostopa v tem računalniku.

          Če ta pravilnik ni nastavljen ali je nastavljen na prazno vrednost, bo lahko gostitelj oddaljenega dostopa uporabljal poljubna vrata, ki so na voljo, razen če je pravilnik <ph name="REMOTE_ACCESS_HOST_FIREWALL_TRAVERSAL_POLICY_NAME" /> onemogočen. V tem primeru bo gostitelj oddaljenega dostopa uporabljal vrata UDP v obsegu 12400–12409.</translation>
<translation id="3756011779061588474">Blokiranje načina za razvijalce</translation>
<translation id="3758089716224084329">Omogoča nastavitev strežnika proxy, ki ga uporablja <ph name="PRODUCT_NAME" />, in preprečuje uporabnikom spreminjanje nastavitev strežnika proxy.

      Če izberete, da strežnika proxy ne boste uporabljali in se boste vedno povezovali neposredno, so vse druge možnosti prezrte.

      Če izberete samodejno zaznavanje strežnika proxy, so vse druge možnosti prezrte.

      Podrobnejše primere najdete na:
      <ph name="PROXY_HELP_URL" />

      Če to nastavitev omogočite, <ph name="PRODUCT_NAME" /> in aplikacije ARC prezrejo vse s proxyjem povezane možnosti, določene iz ukazne vrstice.

      Če teh pravilnikov ne nastavite, lahko uporabniki sami izberejo nastavitve proxyja.</translation>
<translation id="3758249152301468420">Onemogoči Orodja za razvijalce</translation>
<translation id="3764248359515129699">Onemogoči uveljavljanje zahtev za preglednost potrdil za seznam starejših overiteljev potrdil.

      S tem pravilnikom lahko onemogočite zahteve za razkritje za preglednost potrdil za verige potrdil, ki vsebujejo potrdila z eno od navedenih zgoščevalnih vrednosti subjectPublicKeyInfo. To omogoča, da potrdila, ki sicer ne bi bila zaupanja vredna, ker niso bila pravilno javno razkrita, še naprej uporabljate za gostitelje v poslovnih okoljih.

      Če želite, da je uveljavljanje preglednosti potrdil onemogočeno, ko je nastavljen ta pravilnik, mora biti zgoščevalna vrednost vrste subjectPublicKeyInfo, ki se pojavlja v potrdilu overitelja potrdil, ki je prepoznan kot starejši overitelj potrdil. Starejši overitelj potrdil je tak, ki mu privzeto javno zaupa eden ali več operacijskih sistemov, ki jih podpira izdelek <ph name="PRODUCT_NAME" />, ne zaupa pa mu Android Open Source Project ali <ph name="PRODUCT_OS_NAME" />.

      Zgoščevalna vrednost subjectPublicKeyInfo je določena s sestavljanjem imena zgoščevalnega algoritma, znaka »/« in kodiranja Base64 zgoščevalnega algoritma, uporabljenega za subjectPublicKeyInfo navedenega potrdila, ki je kodiran s pravili DER. To kodiranje Base64 ima enako obliko zapisa kot prstni odtis za SPKI, kot je opredeljeno v razdelku 2.4 dokumenta RFC 7469. Neprepoznani zgoščevalni algoritmi se prezrejo. Trenutno je edini podprt zgoščevalni algoritem »sha256«.

      Če ta pravilnik ni nastavljen, bo vsako potrdilo, ki ga je treba razkriti prek preglednosti potrdil, obravnavano kot tako, ki ni zaupanja vredno, če ni razkrito skladno s pravilnikom o preglednosti potrdil.</translation>
<translation id="3765260570442823273">Trajanje opozorila o odjavi zaradi nedejavnosti</translation>
<translation id="377044054160169374">Uveljavitev posredovanja pri zlorabi</translation>
<translation id="3780152581321609624">Vključi nestandardna vrata v SPN za Kerberos</translation>
<translation id="3780319008680229708">Če je ta pravilnik omogočen, bo ikona za Google Cast v orodni vrstici vedno prikazana v orodni vrstici ali v meniju z dodatnimi elementi in je uporabniki ne bodo mogli odstraniti.

          Če je ta pravilnik onemogočen ali ni nastavljen, bodo lahko uporabniki ikono pripeli ali odstranili prek priročnega menija.

          Če je pravilnik »EnableMediaRouter« onemogočen, vrednost tega pravilnika ne bo imela vpliva in ikona v orodni vrstici ne bo prikazana.</translation>
<translation id="3788662722837364290">Nastavitve upravljanja energije, ko uporabnik postane nedejaven</translation>
<translation id="3790085888761753785">Če je ta nastavitev omogočena, bo uporabnikom dovoljeno, da se prijavijo v račun s funkcijo Smart Lock. S to nastavitvijo je dopuščeno več od običajnega delovanja funkcije Smart Lock, ki uporabnikom omogoča zgolj odklepanje zaslona.

      Če je ta nastavitev onemogočena, uporabnikom ne bo dovoljeno uporabljati prijave s funkcijo Smart Lock.

      Če ta pravilnik ni nastavljen, funkcija privzeto ni dovoljena za uporabnike, ki jih upravlja podjetje, in je dovoljena za uporabnike, ki niso upravljani.</translation>
<translation id="379602782757302612">Omogoča izbiro razširitev, ki jih uporabniki NE morejo namestiti. Razširitve, ki so že nameščene, bodo onemogočene, če so na seznamu prepovedanih, in uporabnik jih ne more omogočiti. Ko je razširitev, ki je onemogočena, ker je na seznamu prepovedanih, odstranjena s seznama, je samodejno znova omogočena.

         Vrednost »*« na seznamu blokiranih pomeni, da so vse razširitve na seznamu blokirane, razen če so izrecno navedene na seznamu dovoljenih.

          Če ta pravilnik ni nastavljen, lahko uporabnik v izdelku <ph name="PRODUCT_NAME" /> namesti katero koli razširitev.</translation>
<translation id="3800626789999016379">Konfigurira imenik, ki ga bo <ph name="PRODUCT_NAME" /> uporabljal za prenašanje datotek.

      Če ta pravilnik nastavite, bo <ph name="PRODUCT_NAME" /> uporabljal navedeni imenik ne glede na to, ali ga je uporabnik določil ali omogočil zastavico za vsakokraten poziv za mesto prenosa.

      Seznam spremenljivk, ki jih je mogoče uporabiti, si lahko ogledate na https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Če tega pravilnika ne nastavite, bo uporabljen privzeti imenik za prenose in uporabnik ga bo lahko spremenil.</translation>
<translation id="3805659594028420438">Omogoči razširitev za potrdila, domensko vezana na TLS (zastarelo)</translation>
<translation id="3808945828600697669">Določi seznam onemogočenih vtičnikov</translation>
<translation id="3811562426301733860">Omogočanje oglasov na vseh spletnih mestih</translation>
<translation id="3816312845600780067">Omogočanje bližnjičnih tipk, da se zaobide samodejna prijava</translation>
<translation id="3820526221169548563">Omogoča funkcije za ljudi s posebnimi potrebami zaslonske tipkovnice.

          Če je ta pravilnik nastavljen na »true«, je zaslonska tipkovnica stalno omogočena.

          Če je ta pravilnik nastavljen na »false«, je zaslonska tipkovnica stalno onemogočena.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če ta pravilnik ni nastavljen, je zaslonska tipkovnica na začetku onemogočena, vendar jo lahko uporabnik kadar koli omogoči.</translation>
<translation id="382476126209906314">Nastavitev predpone »TalkGadget« za gostitelje oddaljenega dostopa</translation>
<translation id="3824972131618513497">Nadzira nastavitve upravljanja napajanja in vnovičnega zagona.</translation>
<translation id="3826475866868158882">Googlove lokacijske storitve so omogočene</translation>
<translation id="3831054243924627613">Ta pravilnik nadzira začetno stanje Androidove storitve varnostnega kopiranja in obnovitve.

      Če ta pravilnik ni konfiguriran ali je nastavljen na <ph name="BR_DISABLED" />, je Androidova storitev varnostnega kopiranja in obnovitve sprva onemogočena.

      Če je ta pravilnik nastavljen na <ph name="BR_ENABLED" />, je Androidova storitev varnostnega kopiranja in obnovitve sprva omogočena.

      Če je ta pravilnik nastavljen na <ph name="BR_UNDER_USER_CONTROL" />, je uporabnik pozvan, naj izbere, ali želi uporabljati Androidovo storitev varnostnega kopiranja in obnovitve. Če uporabnik omogoči varnostno kopiranje in obnovitev, so podatki aplikacij za Android naloženi v strežnike za varnostno kopiranje za Android in znova obnovljeni iz njih ob vnovični namestitvi združljivih aplikacij.

      Upoštevajte, da ta pravilnik nadzira stanje Androidove storitve varnostnega kopiranja in obnovitve samo pri začetni nastavitvi. Uporabnik lahko pozneje odpre nastavitve za Android in vklopi/izklopi Androidovo storitev varnostnega kopiranja in obnovitve.</translation>
<translation id="3831376478177535007">Če je ta nastavitev omogočena, <ph name="PRODUCT_NAME" /> omogoča zaupanje potrdilom, izdanim s postopki starejše infrastrukture PKI družbe Symantec Corporation, če se drugače uspešno potrdijo in so v verigi s prepoznanim potrdilom overitelja potrdil.

      Upoštevajte, da je ta pravilnik odvisen od tega, ali operacijski sistem še vedno prepozna potrdila starejše infrastrukture družbe Symantec. Če posodobitev operacijskega sistema spremeni, kako operacijski sistem ravna s takimi potrdili, ta pravilnik ne učinkuje več. Namen tega pravilnika je delovati kot začasna rešitev, ki daje podjetjem na voljo več časa, da prenehajo uporabljati starejša potrdila družbe Symantec. Ta pravilnik bo odstranjen okoli 1. januarja 2019 oziroma na ta datum.

      Če ta pravilnik ni nastavljen ali je onemogočen, <ph name="PRODUCT_NAME" /> upošteva javno najavljen razpored za zastaranje.

      Če želite več podrobnosti o tem zastaranju, glejte https://g.co/chrome/symantecpkicerts.</translation>
<translation id="383466854578875212">Omogoča, da določite, kateri gostitelji izvornega pošiljanja sporočil niso vključeni na seznam blokiranih.

          Vrednost * na seznamu blokiranih pomeni, da so vsi gostitelji izvornega pošiljanja sporočil blokirani in da bodo naloženi samo gostitelji izvornega pošiljanja sporočil, ki so na seznamu dovoljenih.

          Na seznamu dovoljenih so privzeto vsi gostitelji izvornega pošiljanja sporočil, vendar če se s pravilnikom vse gostitelje izvornega pošiljanja sporočil uvrsti na seznam blokiranih, se s seznamom dovoljenih lahko ta pravilnik preglasi.</translation>
<translation id="3835692988507803626">Vsiljeno onemogočanje jezikov za preverjanje črkovanja.</translation>
<translation id="3837424079837455272">Ta pravilnik nadzira, ali je v sistem <ph name="PRODUCT_OS_NAME" /> mogoče dodati nove uporabnike. Uporabnikom ne preprečuje prijave v dodatne račune za Google znotraj Androida. Če želite to preprečiti, konfigurirajte pravilnik za Android <ph name="ACCOUNT_TYPES_WITH_MANAGEMENT_DISABLED_CLOUDDPC_POLICY_NAME" /> kot del pravilnika <ph name="ARC_POLICY_POLICY_NAME" />.</translation>
<translation id="384743459174066962">Omogoča nastavitev seznama vzorcev URL-jev, s katerim so določena spletna mesta, ki jim ni dovoljeno odpirati pojavnih oken.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena splošna privzeta vrednost iz pravilnika »DefaultPopupsSetting«, kadar je ta nastavljen, ali iz uporabnikove osebne konfiguracije, kadar pravilnik »DefaultImagesSetting« ni nastavljen.</translation>
<translation id="3851039766298741586">Poročanje podatkov o aktivni seji kioska, na primer
      ID-ja in različice aplikacije.

      Če je pravilnik onemogočen, se podatki o seji kioska ne
      poročajo. Če je omogočen ali ni nastavljen, se podatki o seji kioska
      poročajo.</translation>
<translation id="3858658082795336534">Privzeto obojestransko tiskanje</translation>
<translation id="3859780406608282662">Dodajanje parametra prejemanju semen različic v izdelku <ph name="PRODUCT_OS_NAME" />.

     Če je pravilnik določen, se URL-ju za prenos semen različic doda parameter poizvedbe »restrict«. Vrednost parametra je vrednost, določena v tem pravilniku.

      Če pravilnik ni določen, se URL semen različic ne spremeni.</translation>
<translation id="3863409707075047163">Omogočena je najnižja različica SSL</translation>
<translation id="3864020628639910082">Določa URL iskalnika, ki se uporablja za predloge za iskanje. URL mora vsebovati niz »<ph name="SEARCH_TERM_MARKER" />«, ki ga bo ob času poizvedbe nadomestilo besedilo, ki ga je uporabnik vnesel do takrat.

          Ta pravilnik je izbiren. Če ni nastavljen, ne bo uporabljen noben URL predloga.

          Googlov URL predloga je mogoče določiti kot: <ph name="GOOGLE_SUGGEST_SEARCH_URL" />.

          Ta pravilnik velja le, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="3864129983143201415">Konfiguriranje dovoljenih jezikov v uporabniški seji</translation>
<translation id="3866249974567520381">Opis</translation>
<translation id="3868347814555911633">Ta pravilnik je aktiven samo v maloprodajnem načinu.

      Navaja razširitve, samodejno nameščene za uporabnika predstavitvenega načina, za naprave v maloprodajnem načinu. Te razširitve so shranjene v napravi in jih je mogoče namestiti brez povezave.

      Vsak vnos na seznamu vsebuje slovar, ki mora vključevati ID razširitve v polju »extension-id« in URL za posodobitev v polju »update-url«.</translation>
<translation id="3874773863217952418">Omogoči »Iskanje z dotikom«</translation>
<translation id="3877517141460819966">Integriran način dvojnega preverjanja pristnosti</translation>
<translation id="3879208481373875102">Konfiguriranje seznama vsiljeno nameščenih spletnih aplikacij</translation>
<translation id="388237772682176890">Ta pravilnik je zastarel v različici M53 in je odstranjen v različici M54 zaradi umika podpore za protokol SPDY/3.1.

      Onemogoči uporabo protokola SPDY v brskalniku <ph name="PRODUCT_NAME" />.

      Če je ta pravilnik omogočen, protokol SPDY v brskalniku <ph name="PRODUCT_NAME" /> ne bo na voljo.

      Če je pravilnik onemogočen, bo uporaba protokola SPDY na voljo.

      Če pravilnik ni nastavljen, bo protokol SPDY na voljo.</translation>
<translation id="3891357445869647828">Omogoči JavaScript</translation>
<translation id="3895557476567727016">Konfigurira privzeti imenik, ki ga <ph name="PRODUCT_NAME" /> uporabi za prenos datotek.

      Če nastavite ta pravilnik, bo spremenil privzeti imenik, v katerega <ph name="PRODUCT_NAME" /> prenese datoteke. Ta pravilnik ni obvezen, tako da lahko uporabnik spremeni imenik.

      Če tega pravilnika ne nastavite, <ph name="PRODUCT_NAME" /> uporabi običajni privzeti imenik (odvisno od posameznega okolja).

      Na https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables si lahko ogledate seznam spremenljivk, ki jih je mogoče uporabiti.</translation>
<translation id="3904459740090265495">Ta pravilnik nadzira delovanje prijave v brskalniku. Omogoča vam, da določite, ali se sme uporabnik prijaviti v brskalnik <ph name="PRODUCT_NAME" /> z računom in uporabljati storitve, povezane z računom, na primer sinhronizacijo za Chrome.

      Če je pravilnik nastavljen na »Onemogočanje prijave v brskalnik«, se uporabnik ne more prijaviti v brskalnik in uporabljati storitev, ki temeljijo na računu. V tem primeru funkcij na ravni brskalnika, kot je sinhronizacija za Chrome, ni mogoče uporabljati in niso na voljo. Če je bil uporabnik prijavljen in je pravilnik nastavljen na »Onemogočeno«, bo ob naslednjem zagonu Chroma odjavljen, lokalni podatki profila, kot so zaznamki, gesla ipd., pa se bodo ohranili. Uporabnik se bo še vedno lahko prijavljal v Googlove spletne storitve, na primer Gmail, in jih uporabljal.

      Če je pravilnik nastavljen na »Omogočanje prijave v brskalnik«, se uporabnik sme prijaviti v brskalnik in je samodejno prijavljen vanj, če je prijavljen v Googlove spletne storitve, na primer Gmail. Če je uporabnik prijavljen v brskalnik, pomeni, da brskalnik ohrani podatke o njegovem računu, vendar to ne pomeni, da je sinhronizacija za Chrome privzeto vklopljena; če želi uporabnik to funkcijo uporabljati, jo mora omogočiti ločeno. Če omogočite ta pravilnik, bo uporabniku preprečen izklop nastavitve, ki omogoča prijavo v brskalnik. Če želite nadzirati razpoložljivost sinhronizacije za Chrome, uporabite pravilnik »SyncDisabled«.

      Če je pravilnik nastavljen na »Vsiljenje prijave v brskalnik«, je uporabniku prikazano pogovorno okno za izbiro računa, v katerem mora izbrati račun in se prijaviti vanj, če želi uporabljati brskalnik. S tem se zagotovi, da se pri upravljanih računih uporabljajo in izvajajo pravilniki, povezani z računom. S tem je za račun privzeto vklopljena sinhronizacija za Chrome, razen v primeru, če sinhronizacijo prek pravilnika »SyncDisabled« onemogoči skrbnik domene. Privzeta vrednost za BrowserGuestModeEnabled bo nastavljena na onemogočeno. Obstoječi neprijavljeni profili bodo po omogočanju tega pravilnika zaklenjeni in nedostopni. Več informacij je na voljo v tem članku centra za pomoč: https://support.google.com/chrome/a/answer/7572556.

      Če ta pravilnik ni nastavljen, se lahko uporabnik odloči, ali želi omogočiti možnost prijave v brskalnik in jo uporabljati po želji.</translation>
<translation id="3911737181201537215">Ta pravilnik ne vpliva na zapisovanje dnevnik sistema Android.</translation>
<translation id="391531815696899618">Če je ta možnost nastavljena na »True«, onemogoči sinhroniziranje Googla Drive v aplikaciji Datoteke za <ph name="PRODUCT_OS_NAME" />. V tem primeru se v Google Drive ne naložijo nobeni podatki.

Če ta možnost ni nastavljena ali je nastavljena na »False«, bodo uporabniki lahko prenesli datoteke v Google Drive.</translation>
<translation id="3915395663995367577">URL za datoteko .pac v proxyju</translation>
<translation id="3920892052017026701">Nastavitev prilagojene točke začetka polnjenja akumulatorja v odstotkih.

          Akumulator se začne polniti, ko izčrpa vrednost prilagojene točke začetka polnjenja akumulatorja.

          DeviceBatteryChargeCustomStartCharging mora biti manj kot DeviceBatteryChargeCustomStopCharging.

          Ta pravilnik se uporablja samo, če je DeviceBatteryChargeMode nastavljeno na »custom« (prilagojeno).

          Če ta pravilnik ni konfiguriran ali nastavljen, se uporabi običajen način polnjenja akumulatorja.</translation>
<translation id="3925377537407648234">Nastavite ločljivost zaslona in faktor povečave</translation>
<translation id="3939893074578116847">Pošiljanje omrežnih paketov v strežnik za upravljanje zaradi spremljanja stanja povezave, tako da lahko
      strežnik zazna, ali ima naprava povezavo.

      Če je pravilnik omogočen, se pošiljajo omrežni paketi za spremljanje (t.i. <ph name="HEARTBEATS_TERM" />).
      Če je onemogočen ali ni nastavljen, se paketi ne pošiljajo.</translation>
<translation id="3950239119790560549">Posodobitev omejitev časa</translation>
<translation id="3956686688560604829">Uporaba pravilnika za sezname spletnih mest za Internet Explorer za podporo starejših brskalnikov.</translation>
<translation id="3958586912393694012">Dovoli uporabo funkcije Smart Lock</translation>
<translation id="3963602271515417124">Če je ta pravilnik omogočen, bo za to napravo dovoljeno potrjevanje na daljavo in samodejno bo ustvarjeno potrdilo, ki bo preneseno v strežnik za upravljanje naprav.

          Če je ta pravilnik onemogočen ali ni nastavljen, ne bo ustvarjeno potrdilo in pozivi API-ju za razširitve enterprise.platformKeys ne bodo uspeli.</translation>
<translation id="3964262920683972987">Konfiguriranje slike za ozadje na ravni naprave, ki je prikazana na prijavnem zaslonu, če se v napravo ni prijavil še noben uporabnik. Pravilnik se nastavi tako, da navedete URL, s katerega lahko naprava s sistemom OS Chrome prenese sliko za ozadje, in kriptografsko zgoščeno vrednost, ki se uporablja za preverjanje celovitosti prenosa. Slika mora biti v obliki JPEG in njena velikost ne sme presegati 16 MB. URL mora biti dostopen brez preverjanja pristnosti. Slika za ozadje se prenese in predpomni. Če se spremeni URL ali zgoščena vrednost, se znova prenese.

      Če je nastavljen pravilnik o sliki za ozadje naprave, bo naprava s sistemom OS Chrome prenesla in uporabila sliko za ozadje na prijavnem zaslonu, če se v napravo ni prijavil še noben uporabnik. Ko se uporabnik prijavi, začne veljati uporabnikov pravilnik o sliki za ozadje.

      Če pravilnik o sliki za ozadje naprave ni nastavljen, pravilnik o sliki za ozadje uporabnika izbere, kaj bo prikazano, če je nastavljen uporabnikov pravilnik o sliki za ozadje.</translation>
<translation id="3965339130942650562">Časovna omejitev za odjavo nedejavnega uporabnika</translation>
<translation id="3973371701361892765">Nikoli samodejno ne skrij police</translation>
<translation id="3984028218719007910">Določa, ali <ph name="PRODUCT_OS_NAME" /> po odjavi ohrani lokalne podatke o računu. Če je pravilnik omogočen, <ph name="PRODUCT_OS_NAME" /> ne shrani trajnih računov in vsi podatki seje uporabnika se po odjavi izbrišejo. Če je pravilnik onemogočen ali ni nastavljen, lahko naprava hrani (šifrirane) lokalne podatke uporabnikov.</translation>
<translation id="398475542699441679">Ta pravilnik nadzira, ali je omogočena podpora za zastarele brskalnike.

      Če ta pravilnik ni nastavljen ali je nastavljen na »false«, Chrome ne bo poskusil odpreti določenih URL-jev v nadomestnem brskalniku.

      Če je ta pravilnik nastavljen na »true«, bo Chrome poskusil odpreti nekatere URL-je v nadomestnem brskalniku (na primer Internet Explorerju). Ta funkcija je konfigurirana s pravilniki v skupini <ph name="LEGACY_BROWSER_SUPPORT_POLICY_GROUP" />.

      Ta funkcija nadomešča razširitev <ph name="LEGACY_BROWSER_SUPPORT_EXTENSION_NAME" />. Konfiguracija iz razširitve se bo prenesla na to funkcijo, vendar zelo priporočamo, da namesto nje uporabljate Chromove pravilnike. S tem si zagotovite boljšo združljivost v prihodnje.</translation>
<translation id="3997519162482760140">URL-ji, ki jim bo odobren dostop do naprav za zajem videa na straneh za prijavo SAML</translation>
<translation id="4001275826058808087">Skrbniki za IT, ki upravljajo naprave v podjetju, lahko s to zastavico določijo, ali je uporabnikom dovoljeno unovčiti ponudbe prek registracije sistema Chrome OS.

      Če je vrednost pravilnika nastavljena na »true« ali pravilnik ni nastavljen, lahko uporabniki unovčijo ponudbe prek registracije sistema Chrome OS.

      Če je vrednost pravilnika nastavljena na »false«, uporabniki ne morejo unovčiti ponudb.</translation>
<translation id="4008233182078913897">Določa seznam aplikacij in razširitev, ki so nameščene brez obveščanja
          in posegov uporabnika ter jih uporabnik ne more odmestiti ali
          onemogočiti. Vsa dovoljenja, ki jih zahtevajo aplikacije/razširitve,
          so implicitno odobrena brez posegov uporabnika,
          vključno z morebitnimi dodatnimi dovoljenji, ki jih bodo zahtevale
          prihodnje različice aplikacije/razširitve. Prav tako so odobrena dovoljenja
          za razširitvena API-ja enterprise.deviceAttributes in enterprise.platformKeys.
          (Ta API-ja nista na voljo aplikacijam/razširitvam,
          ki niso vsiljeno nameščene.)

          Ta pravilnik ima prednost pred pravilnikom <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" /> v primeru njunega spora. Če je aplikacija ali razširitev, ki je bila vsiljeno nameščena, odstranjena s tega seznama, jo brskalnik <ph name="PRODUCT_NAME" /> samodejno odmesti.

          Za primerke sistema Windows, ki niso pridruženi v domeno <ph name="MS_AD_NAME" />, je vsiljeno nameščanje omejeno na aplikacije in razširitve, navedene v Spletni trgovini Chrome.

          Upoštevajte, da lahko uporabniki spremenijo izvorno kodo katere koli razširitve z orodji za razvijalce (s čimer razširitev morda izgubi funkcionalnost). Če imate glede tega pomisleke, nastavite pravilnik <ph name="DEVELOPER_TOOLS_POLICY_NAME" />.

          Vsak element na seznamu pravilnika je niz, ki vsebuje ID razširitve in (neobvezno) URL za »posodobitev«, ločen s podpičjem (<ph name="SEMICOLON" />). ID razširitve je 32-mestni črkovni niz, ki ga je mogoče v načinu za razvijalce najti na primer na <ph name="CHROME_EXTENSIONS_LINK" />. Če je URL za »posodobitev« naveden, mora kazati na dokument XML manifesta za posodobitev, kot je opisano na <ph name="LINK_TO_EXTENSION_DOC1" />. Privzeto se uporabi URL za posodobitev v Spletni trgovini Chrome (ki je trenutno »https://clients2.google.com/service/update2/crx«). Upoštevajte, da se URL za »posodobitev«, nastavljen v tem pravilniku, uporabi samo pri začetni namestitvi; pri vseh nadaljnjih posodobitvah razširitve je uporabljen URL, naveden v manifestu razširitve. Upoštevajte tudi, da je bila izrecna navedba URL-ja za »posodobitev« obvezna v različicah brskalnika <ph name="PRODUCT_NAME" /> do vključno različice 67.

          <ph name="EXTENSION_POLICY_EXAMPLE" /> namesti na primer razširitev z ID-jem <ph name="EXTENSION_ID_SAMPLE" /> s standardnega URL-ja za »posodobitev« v Spletni trgovini Chrome. Več informacij o gostovanju razširitev je na voljo tukaj: <ph name="LINK_TO_EXTENSION_DOC2" />.

          Če ta pravilnik ni nastavljen, nobena aplikacija ali razširitev ni nameščena samodejno in uporabnik lahko odmesti katero koli aplikacijo ali razširitev v brskalniku <ph name="PRODUCT_NAME" />.

          Upoštevajte, da se ta pravilnik ne uporablja za način brez beleženja zgodovine.</translation>
<translation id="4008507541867797979">Če je ta pravilnik omogočen ali ni konfiguriran, bo operacijski sistem <ph name="PRODUCT_OS_NAME" /> na zaslonu za prijavo prikazal obstoječe uporabnike in omogočal izbiro enega.

      Če ta pravilnik ni omogočen, operacijski sistem <ph name="PRODUCT_OS_NAME" /> na zaslonu za prijavo ne bo prikazal obstoječih uporabnikov. Prikazan bo zaslon za običajno prijavo (s pozivom za vnos uporabniškega imena in gesla ali telefonske številke) ali vmesni zaslon za prijavo SAML (če je omogočena s pravilnikom <ph name="LOGIN_AUTHENTICATION_BEHAVIOR_POLICY_NAME" />), razen če je konfigurirana upravljana seja. Če je konfigurirana upravljana seja, bodo prikazani samo računi upravljane seje in mogoče bo izbrati enega izmed njih.

      Upoštevajte, da ta pravilnik ne vpliva na to, ali naprava ohrani ali zavrže lokalne uporabniške podatke.</translation>
<translation id="4010738624545340900">Dovoli proženje pogovornih oken za izbiro datotek</translation>
<translation id="4012737788880122133">Če je pravilnik omogočen, so samodejne posodobitve onemogočene.

      Če nastavitev ni nastavljena ali je onemogočena, naprave s sistemom <ph name="PRODUCT_OS_NAME" /> samodejno preverijo, ali so na voljo posodobitve.

      Opozorilo: priporočamo, da so samodejne posodobitve omogočene, tako da bodo uporabniki lahko prejemali posodobitve programske opreme in nujne varnostne popravke. Če izklopite samodejne popravke, so uporabniki morda ogroženi.</translation>
<translation id="4020682745012723568">Aplikacije za Android do piškotkov, prenesenih v uporabnikov profili, ne morejo dostopati.</translation>
<translation id="402759845255257575">Nobenemu mestu ne dovoli izvajanja JavaScripta</translation>
<translation id="4027608872760987929">Omogoči privzeti iskalnik</translation>
<translation id="4039085364173654945">Določa, ali lahko podvsebina drugega ponudnika na strani odpre pojavno pogovorno okno HTTP Basic Auth.

          Običajno je to onemogočeno kot zaščita pred lažnim predstavljanjem. Če ta pravilnik ni nastavljen, je to onemogočeno in podvsebina drugega ponudnika ne bo mogla odpreti pojavnega pogovornega okna HTTP Basic Auth.</translation>
<translation id="4056910949759281379">Onemogoči protokol SPDY</translation>
<translation id="408029843066770167">Omogočanje poizvedb za Googlovo časovno storitev</translation>
<translation id="408076456549153854">Omogočanje prijave v brskalnik</translation>
<translation id="40853027210512570">Preglasi pravila za izbiro privzetega tiskalnika za <ph name="PRODUCT_NAME" />.

      Ta pravilnik določa pravila za izbiro privzetega tiskalnika v brskalniku <ph name="PRODUCT_NAME" />, do česar pride, ko je funkcija tiskanja prvič uporabljena s profilom.

      Če je ta pravilnik nastavljen, <ph name="PRODUCT_NAME" /> poskusi poiskati tiskalnik, ki se ujema z vsemi določenimi atributi, in ga izbere kot privzetega. Izbran je prvi tiskalnik, ki se ujema s pravilnikom. V primeru neenoličnega ujemanja je lahko izbran kateri koli tiskalnik, ki se ujema, odvisno od vrstnega reda odkrivanja tiskalnikov.

      Če ta pravilnik ni nastavljen ali v časovni omejitvi ni najden tiskalnik, ki se ujema, je privzeti tiskalnik vgrajeni tiskalnik PDF. Če ta ni na voljo, ni izbran noben tiskalnik.

      Tiskalniki, povezani v storitev <ph name="CLOUD_PRINT_NAME" />, se obravnavajo kot »<ph name="PRINTER_TYPE_CLOUD" />«, drugi tiskalniki pa so razvrščeni kot »<ph name="PRINTER_TYPE_LOCAL" />«.
      Če izpustite polje, se ujemajo vse vrednosti. Če na primer ne določite povezave, predogled tiskanja začne odkrivanje vseh vrst tiskalnikov – lokalnih in v oblaku.
      Vzorci regularnega izraza morajo upoštevati sintakso JavaScript RegExp in pri ujemanjih se razlikuje med malimi in velikimi črkami.</translation>
<translation id="4088589230932595924">Vsiljen način brez beleženja zgodovine</translation>
<translation id="4088983553732356374">Omogoča, da nastavite, ali je spletnim mestom dovoljeno nastavljanje lokalnih podatkov. Nastavljanje lokalnih podatkov je lahko dovoljeno za vsa mesta ali onemogočeno za vsa mesta.

          Če je ta pravilnik nastavljen na »Ohrani piškotke za obdobje trajanja seje«, se ob zaprtju seje piškotki izbrišejo. Če se <ph name="PRODUCT_NAME" /> izvaja v ozadju, se seja ob zaprtju zadnjega okna morda ne bo zaprla. Več informacij o konfiguriranju tega delovanja je na voljo v pravilniku »BackgroundModeEnabled«.

          Če ta pravilnik ni nastavljen, se uporabi »AllowCookies« in uporabnik bo lahko to spremenil.</translation>
<translation id="4103289232974211388">Preusmeritev na SAML IdP po potrditvi uporabnika</translation>
<translation id="410478022164847452">Določa trajanje uporabnikove nedejavnosti, po preteku katere se izvede dejanje ob nedejavnosti, če se naprava napaja iz električnega omrežja.

          Če je pravilnik nastavljen, določa, koliko časa mora biti uporabnik nedejaven, preden <ph name="PRODUCT_OS_NAME" /> izvede dejanje ob nedejavnosti, ki ga je mogoče konfigurirati posebej.

          Če pravilnik ni nastavljen, velja privzeto trajanje.

          Vrednost pravilnika naj bo navedena v milisekundah.</translation>
<translation id="4105884561459127998">Konfigurira vrsto preverjanja pristnosti za prijave SAML.

      Če ta pravilnik ni nastavljen ali je nastavljen na Default (privzeto, vrednost 0), delovanje prijav SAML določi brskalnik glede na druge dejavnike. V najbolj osnovnem scenariju preverjanje pristnosti uporabnikov in zaščita predpomnjenih uporabniških podatkov temeljita na geslih, ki jih uporabniki ročno vnesejo.

      Če je ta pravilnik nastavljen na ClientCertificate (potrdilo odjemalca, vrednost 1), se preverjanje pristnosti odjemalca uporabi za novo dodane uporabnike, ki se prijavljajo prek SAML-ja. Za take uporabnike se ne uporabljajo gesla in njihovi predpomnjeni lokalni podatki so zaščiteni z ustreznimi kriptografskimi ključi. Ta nastavitev na primer omogoča konfiguriranje preverjanja pristnosti uporabnikov s pametnimi karticami (nameščene morajo biti aplikacije za pametne kartice prek pravilnika DeviceLoginScreenAppInstallList).

      Ta pravilnik vpliva samo na uporabnike, katerih pristnost se preverja z uporabo SAML-ja.</translation>
<translation id="4105989332710272578">Onemogočanje uveljavljanja pravilnika o preglednosti potrdila za seznam URL-jev</translation>
<translation id="4121350739760194865">Onemogoči prikaz oglasov za aplikacije na novem zavihku s povezavami.</translation>
<translation id="412697421478384751">Omogoči uporabnikom nastavitev šibkih kod PIN za kodo PIN za zaklenjen zaslon.</translation>
<translation id="4138655880188755661">Časovna omejitev</translation>
<translation id="4144164749344898721">Ta pravilnik nadzira različne nastavitve za strategijo upravljanja energije, ko uporabnik postane nedejaven.

          Obstajajo štiri vrste dejanj:
          * Če je uporabnik nedejaven toliko časa, kot določa |ScreenDim|, se zaslon zatemni.
          * Če je uporabnik nedejaven toliko časa, kot določa |ScreenOff|, se zaslon izklopi.
          * Če je uporabnik nedejaven toliko časa, kot določa |IdleWarning|, se prikaže opozorilno pogovorno okno, ki uporabnika obvesti, da se bo izvedlo dejanje zaradi nedejavnosti. Opozorilno sporočilo je prikazano samo, če je dejanje ob nedejavnosti odjava ali izklop.
          * Če je uporabnik nedejaven toliko časa, kot določa |Idle|, se bo izvedlo dejanje, ki ga določa |IdleAction|.

          Za vsako od navedenih dejanj mora biti zakasnitev navedena v milisekundah, ustrezno dejanje pa se bo sprožilo samo, če je nastavljena vrednost, večja od nič. Če je zakasnitev nastavljena na nič, <ph name="PRODUCT_OS_NAME" /> ne bo izvedel ustreznega dejanja.

          Če za navedene zakasnitve trajanje ni določeno, bo uporabljena privzeta vrednost.

          Upoštevajte, da morajo biti vrednosti za |ScreenDim| manjše ali enake kot vrednosti za |ScreenOff|, vrednosti za |ScreenOff| in |IdleWarning| pa manjše ali enake kot za |Idle|.

          |IdleAction| je lahko eno od štirih dejanj:
          * |Suspend| (prekinitev)
          * |Logout| (odjava)
          * |Shutdown| (zaustavitev)
          * |DoNothing| (ne naredi ničesar)

          Če vrednost za |IdleAction| ni nastavljena, se bo izvedlo privzeto dejanje, ki je prekinitev.

          Obstajajo tudi ločene nastavitve za napajanje iz električnega omrežja in akumulatorja.
          </translation>
<translation id="4150201353443180367">Prikaz</translation>
<translation id="4157003184375321727">Pošiljanje podatkov o različici operacijskega sistema in vdelane programske opreme</translation>
<translation id="4157594634940419685">Omogoči dostop do izvornih tiskalnikov CUPS</translation>
<translation id="4160962198980004898">Vir naslova MAC naprave, ko je na stojalu</translation>
<translation id="4163705126749612234">Konfigurira potrebna imena domene odjemalcev, ki bodo vsiljena odjemalcem za oddaljeni dostop, in uporabnikom prepreči, da bi jih spremenili.

          Če je ta nastavitev omogočena, se lahko z gostiteljem povežejo samo odjemalci iz ene od navedenih domen.

          Če je ta nastavitev onemogočena ali ni nastavljena, se uporabi privzeti pravilnik za vrsto povezave. Za oddaljeno pomoč to omogoča povezovanje z gostiteljem odjemalcem iz poljubne domene. Za oddaljen dostop kadar koli se lahko poveže samo lastnik gostitelja.

          Ta nastavitev preglasi pravilnik RemoteAccessHostClientDomain, če je na voljo.

          Glejte tudi RemoteAccessHostDomainList.</translation>
<translation id="4164601239783385546">Omogočanje funkcije za ljudi s posebnimi potrebami za zaklepanje tipk.

          Če ta je pravilnik nastavljen na »true«, bo zaklepanje tipk vedno omogočeno.

          Če je ta pravilnik nastavljen na »false«, bo zaklepanje tipk vedno onemogočeno.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če tega pravilnika ne nastavite, je zaklepanje tipk prvotno onemogočeno, vendar ga lahko uporabnik kadar koli omogoči.</translation>
<translation id="4171331498167688968">Če je pravilnik onemogočen, lahko programska oprema drugih ponudnikov vstavlja izvedljivo kodo v Chromove procese. Če pravilnik ni nastavljen ali je omogočen, programska oprema drugih ponudnikov ne more vstavljati izvedljive kode v Chromove procese.

      Ne glede na vrednost tega pravilnika brskalnik programski opremi drugih ponudnikov trenutno ne bo preprečil vstavljanja izvedljive kode v procese brskalnika v računalniku, ki je pridružen v domeno <ph name="MS_AD_NAME" />.</translation>
<translation id="4183229833636799228">Privzeta nastavitev za <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="4192388905594723944">URL za preverjanje žetona za preverjanje pristnosti odjemalca za oddaljeni dostop</translation>
<translation id="4203389617541558220">Omejitev časa delovanja naprave z načrtovanjem samodejnih vnovičnih zagonov.

      Če je ta pravilnik nastavljen, določa, kako dolgo lahko deluje naprava, preden se izvede načrtovan samodejni vnovični zagon.

      Če ta pravilnik ni nastavljen, je čas delovanja naprav neomejen.

      Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

      Samodejni vnovični zagon se v napravi načrtuje za določeno uro, vendar se lahko odloži do 24 ur, če nekdo trenutno uporablja napravo.

      Opomba: Samodejni vnovični zagoni so trenutno omogočeni samo, ko je prikazan prijavni zaslon ali poteka seja aplikacije za kiosk. To se bo v prihodnosti spremenilo in pravilnik bo vedno veljal ne glede na to, ali poteka seja katere koli vrste.

Vrednost pravilnika mora vedno biti navedena v sekundah. Vrednosti so navzdol omejene na najmanj 3600 (eno uro).</translation>
<translation id="4203879074082863035">Uporabnikom so prikazani samo tiskalniki na seznamu dovoljenih.</translation>
<translation id="420512303455129789">Slovar, v katerem so URL-ji preslikani na logično zastavico, ki določa, ali naj bo dostop do gostitelja dovoljen (True) ali blokiran (False).

          Ta pravilnik je namenjen za notranjo uporabo v programu <ph name="PRODUCT_NAME" />.</translation>
<translation id="4224610387358583899">Zakasnitve za zaklepanje zaslona</translation>
<translation id="423797045246308574">Omogoča nastavitev seznama vzorcev URL-jev, s katerim so določena mesta, ki smejo uporabljati ustvarjanje ključev. Če je vzorec URL-ja v »KeygenAllowedForUrls«, ta pravilnik preglasi te izjeme.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena splošna privzeta vrednost iz pravilnika »DefaultKeygenSetting«, kadar je ta nastavljen, ali iz uporabnikove osebne konfiguracije, kadar pravilnik »DefaultKeygenSetting« ni nastavljen.</translation>
<translation id="4238997902172035160">Konfigurira imenik, ki ga bo izdelek <ph name="PRODUCT_NAME" /> uporabljal za shranjevanje kopij profilov za gostovanje.

      Če nastavite ta pravilnik, bo izdelek <ph name="PRODUCT_NAME" /> uporabljal naveden imenik za shranjevanje kopije profilov za gostovanje, kadar je pravilnik <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> omogočen. Če je pravilnik <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" /> onemogočen ali ni nastavljen, se vrednost, shranjena v tem pravilniku, ne uporabi.

      Na https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables si lahko ogledate seznam spremenljivk, ki jih je mogoče uporabiti.

      Če ta pravilnik ni nastavljen, se uporabi privzeta pot za profile za gostovanje.</translation>
<translation id="4239720644496144453">Predpomnilnik se ne uporablja za aplikacije za Android. Če več uporabnikov namesti enako aplikacijo za Android, bo za vsakega uporabnika znova prenesena.</translation>
<translation id="4243336580717651045">Omogoča zbiranje anonimiziranih podatkov, ki vključujejo URL-je, v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom preprečuje spreminjanje te nastavitve.

      Zbiranje anonimiziranih podatkov, ki vključujejo URL-je, pošlje Googlu URL-je strani, ki jih obišče uporabnik, zaradi izboljšanja iskanj in brskanja.

      Če ta pravilnik omogočite, je zbiranje anonimiziranih podatkov, ki vključujejo URL-je, vedno aktivno.

      Če ta pravilnik onemogočite, ni zbiranje anonimiziranih podatkov, ki vključujejo URL-je, nikoli aktivno.

      Če ta pravilnik ni nastavljen, bo zbiranje anonimiziranih podatkov, ki vključujejo URL-je, omogočeno, vendar bo lahko uporabnik to spremenil.</translation>
<translation id="4250680216510889253">Ne</translation>
<translation id="4261820385751181068">Jezik na zaslonu za prijavo v napravi</translation>
<translation id="427220754384423013">Določa tiskalnike, ki jih uporabnik lahko uporablja.

      Ta pravilnik se uporablja samo, če je za pravilnik <ph name="BULK_PRINTERS_ACCESS_MODE" /> izbrana možnost <ph name="PRINTERS_WHITELIST" />.

      Če se uporablja ta pravilnik, so uporabniku na voljo samo tiskalniki z ID-ji, ki se ujemajo z vrednostmi v tem pravilniku. ID-ji morajo ustrezati polju »id« ali »guid« v datoteki, določeni v pravilniku <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="427632463972968153">Določa parametre, uporabljene pri slikovnem iskanju z metodo POST. Sestavljena je iz parov ime/vrednost, ločenih z vejico. Če je vrednost parameter predloge, kot je v zgornjih primerih {imageThumbnail}, bo zamenjana s pravimi podatki sličice slike.

          Ta pravilnik je izbiren. Če ni nastavljen, bo zahteva za slikovno iskanje poslana z metodo GET.

          Ta pravilnik se upošteva samo, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="4285674129118156176">Omogočanje uporabe ARC-ja nepovezanim uporabnikom</translation>
<translation id="4289903996435140853">Omogoča nastavitev seznama URL-jev, ki določajo, katerim spletnim mestom bo samodejno podeljeno dovoljenje za dostop do naprave USB z danim ID-jem izdelka in dobavitelja. Pravilnik je veljaven samo, če vsak element na seznamu vsebuje tako naprave kot tudi URL-je. Vsak element v napravah lahko vsebuje polje z ID-jem dobavitelja in ID-jem izdelka. Vsak izpuščen ID se obravnava kot nadomestni znak z eno izjemo, in sicer, da ID izdelka ne more biti naveden, ne da bi bil naveden tudi ID dobavitelja. Pravilnik sicer ne bo veljaven in bo prezrt.

        Model dovoljenj za USB uporablja URL spletnega mesta, ki pošlje zahtevo (»URL z zahtevo«), in URL spletnega mesta z vrhnjim okvirjem (»URL za vdelavo«), da URL-ju z zahtevo podeli dovoljenje za dostop do naprave USB. URL z zahtevo se lahko razlikuje od URL-ja za vdelavo, če je stran, ki pošilja zahtevo, naložena v okviru iframe. Polje »urls« lahko tako vsebuje do dva niza z URL-jem, ločena z vejico, ki določata URL z zahtevo oziroma URL za vdelavo. Če je naveden samo en URL, bo dostop do ustreznih naprav USB podeljen, ko se URL spletnega mesta, ki pošilja zahtevo, ujema s tem URL-jem, ne glede na stanje vdelave. URL-ji v polju »urls« morajo biti veljavni URL-ji, sicer se pravilnik prezre.

        Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi globalna privzeta vrednost iz pravilnika »DefaultWebUsbGuardSetting«, če je nastavljen, sicer pa iz uporabnikove osebne konfiguracije.

        Vzorci URL-jev v tem pravilniku ne smejo biti v navzkrižju s tistimi, ki so konfigurirani prek pravilnika WebUsbBlockedForUrls. V primeru navzkrižja ima ta pravilnik prednost pred pravilnikoma WebUsbBlockedForUrls in WebUsbAskForUrls.

        Vrednosti za ta pravilnik in pravilnik WebUsbAllowDevicesForUrls so združene.</translation>
<translation id="4298509794364745131">Določa seznam aplikacij, ki jih je mogoče omogočiti kot aplikacije za zapiske na zaklenjenem zaslonu sistema <ph name="PRODUCT_OS_NAME" />.

      Če je prednostna aplikacija za zapiske omogočena na zaklenjenem zaslonu, je na njem element uporabniškega vmesnika za zagon te aplikacije.
      Aplikacija bo lahko po zagonu ustvarila svoje okno na zaklenjenem zaslonu ter ustvarila podatkovne elemente (zapiske) v kontekstu zaklenjenega zaslona. Lahko bo uvozila ustvarjene zapiske v sejo primarnega uporabnika, ko je seja odklenjena. Na zaklenjenem zaslonu so za zdaj podprte samo aplikacije za zapiske za Chrome.

      Če je pravilnik nastavljen, lahko uporabnik omogoči aplikacijo na zaklenjenem zaslonu samo, če je ID razširitve aplikacije vsebovan v vrednosti seznama pravilnika.
      Če ta pravilnik nastavite na prazen seznam, bo zato v celoti onemogočeno ustvarjanje zapiskov na zaklenjenem zaslonu.
      Če pravilnik vsebuje ID aplikacije, še ne pomeni, da lahko uporabnik omogoči aplikacijo kot aplikacijo za zapiske na zaklenjenem zaslonu – v Chromu 61 skupino razpoložljivih aplikacij na primer dodatno omejuje okolje.

      Če pravilnik ni nastavljen, ni omejitev pravilnika za skupino aplikacij, ki jih uporabnik lahko omogoči na zaklenjenem zaslonu.</translation>
<translation id="4313767483634435271">Določen naslov MAC za nosilec naprave</translation>
<translation id="4322842393287974810">Dovoli samodejno zagnani aplikaciji za kiosk brez zamika nadzor nad različico sistema <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="4325690621216251241">Dodajanje gumb za odjavo v sistemsko vrstico</translation>
<translation id="4332177773549877617">Beleženje dogodkov za namestitve aplikacije za Android</translation>
<translation id="4335292026668105285">Določa trajanje uporabnikove nedejavnosti, po preteku katere je prikazano opozorilno pogovorno okno, če se naprava napaja iz električnega omrežja.

          Če je ta pravilnik nastavljen, določa trajanje, med katerim mora biti uporabnik nedejaven, preden sistem <ph name="PRODUCT_OS_NAME" /> prikaže opozorilno pogovorno okno, ki uporabnika obvesti, da se bo izvedlo dejanje ob nedejavnosti.

          Če ta pravilnik ni nastavljen, ni prikazano opozorilno pogovorno okno.

          Vrednost pravilnika mora biti navedena v milisekundah. Vrednosti morajo biti manjše ali enake kot časovni zamik nedejavnosti.

          Opozorilno sporočilo je prikazano samo, če je dejanje ob nedejavnosti odjava ali izklop.</translation>
<translation id="4346674324214534449">Omogoča, da nastavite, ali je treba oglase blokirati na spletnih mestih z vsiljivimi oglasi.

      Če je ta pravilnik nastavljen na 2, bodo oglasi blokirani na spletnih mestih z vsiljivimi oglasi.
      To delovanje pa se ne bo sprožilo, če je onemogočen pravilnik »SafeBrowsingEnabled«.
      Če je ta pravilnik nastavljen na 1, oglasi ne bodo blokirani na spletnih mestih z vsiljivimi oglasi.
      Če ta pravilnik ni nastavljen, je uporabljena možnost 2.</translation>
<translation id="4347908978527632940">Če je omogočeno in je uporabnik zaščiteni uporabnik, lahko druge aplikacije za Android prek ponudnika vsebine pošljejo poizvedbe o uporabnikovih spletnih omejitvah.

          Če ni omogočeno ali ni nastavljeno, ponudnik vsebine ne pošlje podatkov.</translation>
<translation id="435461861920493948">Vsebuje seznam vzorcev, ki se uporabljajo za nadziranje vidnosti računov v storitvi <ph name="PRODUCT_NAME" />.

      Vsak Google Račun v napravi bo primerjan z vzorci, shranjenimi v tem pravilniku, zaradi vidnosti računa v storitvi <ph name="PRODUCT_NAME" />. Račun bo viden, če se njegovo ime ujema s katerim koli vzorcem na seznamu. V nasprotnem primeru bo račun skrit.

      Z nadomestnim znakom »*« nadomestite poljubno število poljubnih znakov (ali nobenega). Ubežni znak je »\«, zato morate za ujemanje z dejanskima znakoma »*« ali »\« pred njiju dati »\«.

      Če ta pravilnik ni nastavljen, so vsi Google Računi v napravi vidni v storitvi <ph name="PRODUCT_NAME" />.</translation>
<translation id="4360826270668210664">Če je ta pravilnik nastavljen, bo gostitelj za oddaljeni dostop zahteval, da odjemalci pridobijo žeton za preverjanje na tem URL-ju, če želijo vzpostaviti povezavo. Uporabljati ga je treba v povezavi s pravilnikom RemoteAccessHostTokenValidationUrl.

          Ta funkcija je trenutno onemogočena na strani strežnika.</translation>
<translation id="4363057787588706121">Omogočanje združevanja pravilnikov s seznami iz različnih virov</translation>
<translation id="436581050240847513">Poročanje o omrežnih vmesnikih naprave</translation>
<translation id="4372704773119750918">Ne dovoli uporabnikom v podjetjih, da so del večkratnega profila (primarnega ali sekundarnega)</translation>
<translation id="4377599627073874279">Dovoli vsem mestom, da pokažejo vse slike</translation>
<translation id="437791893267799639">Preklic nastavitev pravilnika, prepoved selitve podatkov in ARC-ja</translation>
<translation id="4389073105055031853">Uporabnikom dovoli upravljanje vseh potrdil</translation>
<translation id="4389091865841123886">Konfiguriranje potrditve na daljavo z mehanizmom TPM.</translation>
<translation id="4408428864159735559">Seznam vnaprej konfiguriranih omrežnih datotečnih sredstev v skupni rabi.</translation>
<translation id="4410236409016356088">Omogoči omejevanje omrežne pasovne širine</translation>
<translation id="441217499641439905">Onemogoči sinhronizacijo z Googlom Drive prek povezav v mobilnih omrežjih v aplikaciji Datoteke za <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="4415603335307944578">Če je ta pravilnik omogočen ali ni nastavljen, bo brskalnik ob prvem zagonu po nadgradnji operacijskega sistema znova prikazal pozdravno stran.

      Če je ta pravilnik onemogočen, brskalnik ob prvem zagonu po nadgradnji operacijskega sistema ne bo znova prikazal pozdravne strani.</translation>
<translation id="4418726081189202489">Če onemogočite ta pravilnik, izdelku <ph name="PRODUCT_NAME" /> preprečite občasno pošiljanje poizvedb v Googlove storitve zaradi prejemanja točnega časovnega žiga. Te poizvedbe bodo omogočene, če je ta pravilnik omogočen ali ni nastavljen.</translation>
<translation id="4423597592074154136">Ročna izbira nastavitev proxyja</translation>
<translation id="4429220551923452215">Omogoči ali onemogoči bližnjico za aplikacije v vrstici z zaznamki.

      Če pravilnik ni nastavljen, lahko uporabnik izbere, da je bližnjica za aplikacije v kontekstnem meniju vrstice z zaznamki prikazana ali skrita.

      Če je pravilnik nastavljen, ga uporabnik ne more spremeniti, bližnjica za aplikacije pa je vedno prikazana ali pa ni nikoli prikazana.</translation>
<translation id="4432762137771104529">Omogočanje razširjenega poročanja za Varno brskanje</translation>
<translation id="443454694385851356">Starejše (ni varno)</translation>
<translation id="443665821428652897">Izbris podatkov mesta, ko se brskalnik zapre (zastarelo)</translation>
<translation id="4439132805807595336">Omogočanje izvajanja vtičnika PluginVm v tej napravi.

      Če je pravilnik nastavljen na »False« ali ni nastavljen, vtičnik <ph name="PLUGIN_VM_NAME" /> za napravo ni omogočen. Če je pravilnik omogočen, je vtičnik <ph name="PLUGIN_VM_NAME" /> za napravo omogočen, če je omogočen tudi z drugimi nastavitvami. <ph name="PLUGIN_VM_ALLOWED_POLICY_NAME" /> mora biti omogočeno, <ph name="PLUGIN_VM_LICENSE_KEY_POLICY_NAME" /> in <ph name="PLUGIN_VM_IMAGE_POLICY_NAME" /> morata biti nastavljena, da je omogočeno izvajanje vtičnika <ph name="PLUGIN_VM_NAME" />.</translation>
<translation id="4439336120285389675">Določanje seznama zastarelih funkcij spletnega okolja za vnovično začasno omogočanje.

      Ta pravilnik skrbnikom omogoča vnovično omogočanje zastarelih funkcij spletnega okolja za omejen čas. Funkcije določajo oznake nizov in funkcije, ki ustrezajo oznakam, vključenim na seznam, ki ga določa ta pravilnik, bodo znova omogočene.

      Če ta pravilnik ni nastavljen ali je seznam prazen oziroma se ne ujema z nobeno od podprtih oznak nizov, bodo ostale vse zastarele funkcije spletnega okolja onemogočene.

      Medtem ko je ta pravilnik podprt v zgornjih okoljih, je funkcija, ki jo omogoča, morda na voljo v manj okoljih. Vseh zastarelih funkcij spletnega okolja ni mogoče znova omogočiti; za omejen čas (različno od funkcije do funkcije) je mogoče samo tiste, ki so izrecno navedene spodaj. Splošna oblika zapisa oznake niza bo [DeprecatedFeatureName]_EffectiveUntil[yyyymmdd]. Če vas zanima referenčno gradivo in namen spremembe funkcij spletnega okolja, obiščite http://bit.ly/blinkintents.
      </translation>
<translation id="4442582539341804154">Omogoči zaklepanje, ko je naprava nedejavna ali preide v stanje pripravljenosti</translation>
<translation id="4449469846627734399">Nastavitev dnevne konfiguracije funkcije preklopa na akumulatorsko napajanje ob konicah</translation>
<translation id="4449545651113180484">Sukanje zaslona v smeri urnega kazalca za 270 stopinj</translation>
<translation id="445270821089253489">Nadzira, kateri podatki o uporabniku in napravi se poročajo.</translation>
<translation id="4454820008017317557">Pokaži ikono orodne vrstice <ph name="PRODUCT_NAME" /></translation>
<translation id="4467952432486360968">Blokiraj piškotke drugih spletnih mest</translation>
<translation id="4474167089968829729">Omogočanje shranjevanja gesel v upravitelju gesel</translation>
<translation id="4476769083125004742">Če je ta pravilnik nastavljen na <ph name="BLOCK_GEOLOCATION_SETTING" />, aplikacije za Android ne morejo dostopati do podatkov o lokaciji. Če pravilnik nastavite na katero koli drugo vrednost ali ga ne nastavite, je uporabnik pozvan, da poda soglasje, kadar želi aplikacija za Android dostopati do podatkov o lokaciji.</translation>
<translation id="4480694116501920047">Uveljavitev Google Varnega iskanja</translation>
<translation id="4482640907922304445">Pokaže gumb za domačo stran v orodni vrstici brskalnika <ph name="PRODUCT_NAME" />.

      Če to nastavitev omogočite, bo gumb za domačo stran vedno prikazan.

      Če to nastavitev onemogočite, gumb za domačo stran ne bo prikazan.

      Če to nastavitev omogočite ali onemogočite, je uporabniki v brskalniku <ph name="PRODUCT_NAME" /> ne morejo spremeniti ali preglasiti.

      Če tega pravilnika ne nastavite, lahko uporabnik izbere, ali bo gumb za domačo stran prikazan.</translation>
<translation id="4483649828988077221">Onemogoči samodejno posodabljanje</translation>
<translation id="4485425108474077672">Konfiguriranje URL-ja novega zavihka s povezavami</translation>
<translation id="4492287494009043413">Onemogoči ustvarjanje posnetkov zaslona</translation>
<translation id="4494132853995232608">Wilco DTC</translation>
<translation id="449423975179525290">Konfiguriranje pravilnikov, povezanih z vtičnikom <ph name="PLUGIN_VM_NAME" />.</translation>
<translation id="450537894712826981">Nastavi velikost predpomnilnika, ki ga bo izdelek <ph name="PRODUCT_NAME" /> uporabljal za shranjevanje predpomnjenih predstavnostnih datotek na disku.

Če nastavite ta pravilnik, bo <ph name="PRODUCT_NAME" /> uporabil navedeno velikost predpomnilnika, ne glede na to, ali je uporabnik nastavil zastavico »--media-cache-size«. Vrednost, navedena v tem pravilniku, ni fiksna omejitev, temveč predlog predpomnilniškemu sistemu. Vrednosti pod nekaj megabajti so premajhne in bodo zaokrožene na razumno minimalno vrednost.

Če je vrednost tega pravilnika nastavljena na 0, bo uporabljena privzeta velikost predpomnilnika, vendar je uporabnik ne bo mogel spremeniti.

Če ta pravilnik ni nastavljen, bo uporabljena privzeta vrednost in jo bo uporabnik lahko preglasil z zastavico »--media-cache-size«.</translation>
<translation id="4508686775017063528">Če je pravilnik omogočen ali ni nastavljen, je naprava <ph name="PRODUCT_NAME" /> omogočena, uporabniki pa jo lahko zaženejo v meniju z aplikacijami, v kontekstnih menijih na straneh, s kontrolniki predstavnosti na spletnih mestih, ki podpirajo Google Cast, in (če je prikazana) z ikono za Google Cast v orodni vrstici.

          Če pravilnik ni omogočen, je naprava <ph name="PRODUCT_NAME" /> onemogočena.</translation>
<translation id="4515404363392014383">Omogočanje Varnega brskanja za zaupanja vredne vire</translation>
<translation id="4518251772179446575">Vprašaj, ko želi mesto spremljati fizično lokacijo uporabnika</translation>
<translation id="4519046672992331730">Omogoča predloge za iskanje v naslovni vrstici brskalnika <ph name="PRODUCT_NAME" /> in preprečuje uporabnikom spreminjanje te nastavitve.

      Če to nastavitev omogočite, bodo uporabljeni predlogi za iskanje.

      Če to nastavitev onemogočite, predlogi za iskanje ne bodo uporabljeni.

      Če to nastavitev omogočite ali onemogočite, jo uporabniki v brskalniku <ph name="PRODUCT_NAME" /> ne bodo mogli spremeniti ali preglasiti.

     Če ta pravilnik ni nastavljen, bo to omogočeno, vendar bo lahko uporabnik to spremenil.</translation>
<translation id="4531706050939927436">Aplikacije za Android je mogoče vsiljeno namestiti iz konzole Admin console z Googlom Play, ki tega pravilnika ne uporabljata.</translation>
<translation id="4534500438517478692">Ime omejitve za Android:</translation>
<translation id="4541530620466526913">Lokalni računi za napravo</translation>
<translation id="4543502256674577024">Nastavitve posodobitve naprave</translation>
<translation id="4554651132977135445">Način obdelave povratnih zank pri uporabniških pravilnikih</translation>
<translation id="4554841826517980623">Ta pravilnik nadzira, ali naj funkcija omrežnih datotečnih sredstev v skupni rabi za izdelek <ph name="PRODUCT_NAME" /> uporablja protokol <ph name="NETBIOS_PROTOCOL" /> za odkrivanje sredstev v skupni rabi v omrežju.
      Če je ta pravilnik omogočen, bo mehanizem za odkrivanje sredstev v skupni rabi uporabljal protokol <ph name="NETBIOS_PROTOCOL" /> za odkrivanje sredstev v skupni rabi v omrežju.
      Če je ta pravilnik onemogočen, mehanizem za odkrivanje sredstev v skupni rabi ne bo uporabljal protokola <ph name="NETBIOS_PROTOCOL" /> za odkrivanje sredstev v skupni rabi v omrežju.
      Če pravilnik ni nastavljen, je funkcija privzeto onemogočena za uporabnike, ki jih upravlja podjetje, in omogočena za uporabnike, ki niso upravljani.</translation>
<translation id="4555850956567117258">Omogoči oddaljeno potrditev za uporabnika</translation>
<translation id="4557134566541205630">URL novega zavihka s povezavami privzetega iskalnika</translation>
<translation id="4567137030726189378">Omogočena uporaba orodij za izvajalce</translation>
<translation id="4578265298946081589">Brez vnovičnega zagona ob odjavi uporabnika.</translation>
<translation id="4578912515887794133">Če je ta nastavitev omogočena, gostitelj za oddaljeni dostop primerja ime lokalnega uporabnika (s katerim je povezan gostitelj) in ime računa za Google, ki je registriran kot lastnik gostitelja (tj. »janeznovak«, če je lastnik gostitelja račun za Google »janeznovak@example.com«).  Gostitelj za oddaljeni dostop se ne bo zagnal, če se ime lastnika gostitelja razlikuje od imena lokalnega uporabnika, s katerim je povezan gostitelj.  Pravilnik RemoteAccessHostMatchUsername se mora uporabljati skupaj s pravilnikom RemoteAccessHostDomain, da se prav tako uveljavi, da je račun za Google lastnika gostitelja povezan s točno določeno domeno (tj. »example.com«).

          Če je ta nastavitev onemogočena ali ni nastavljena, je mogoče gostitelja za oddaljeni dostop povezati s poljubnim lokalnim uporabnikom.</translation>
<translation id="4591366717022345234">Posredovanje delovne različice Quick Fixa uporabnikom</translation>
<translation id="4600786265870346112">Omogoči velik kazalec</translation>
<translation id="4604931264910482931">Konfiguracija seznama blokiranih za izvorno pošiljanje sporočil</translation>
<translation id="4617338332148204752">Preskoči preverjanje metaoznak v izdelku <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="4625915093043961294">Nastavi seznam razširitev, katerih namestitev je dovoljena</translation>
<translation id="4632343302005518762">Dovoli, da <ph name="PRODUCT_FRAME_NAME" /> obravnava navedene vrste vsebine.</translation>
<translation id="4632566332417930481">Prepoved uporabe orodij za razvijalce v razširitvah, nameščenih s pravilnikom podjetja, omogočena uporaba orodij za razvijalce v drugih kontekstih</translation>
<translation id="4633786464238689684">Spremeni privzeti način delovanja zgornje vrstice tipk, da delujejo kot funkcijske tipke.

          Če je ta pravilnik nastavljen na »true«, bo zgornja vrstica tipk privzeto pošiljala ukaze funkcijskih tipk. Če želite, da spet delujejo kot predstavnostne tipke, morate pritisniti tipko za iskanje.

          Če je ta pravilnik nastavljen na »false« ali ni nastavljen, bo tipkovnica privzeto pošiljala ukaze predstavnostnih tipk, če je pritisnjena tipka za iskanje, pa ukaze funkcijskih tipk.</translation>
<translation id="4639407427807680016">Imena gostiteljev izvornega pošiljanja sporočil, ki se ne vključijo na seznam blokiranih</translation>
<translation id="4650759511838826572">Onemogoči protokolne sheme URL-ja</translation>
<translation id="465099050592230505">URL spletne trgovine podjetja (zastarelo)</translation>
<translation id="4661889655253181651">Z nastavitvami vsebine lahko določite, kako se obravnava vsebina različnih vrst (npr. piškotki, slike ali JavaScript).</translation>
<translation id="4665897631924472251">Nastavitve upravljanja razširitev</translation>
<translation id="4668325077104657568">Nastavitev privzetih slik</translation>
<translation id="4670865688564083639">Najmanj:</translation>
<translation id="4671708336564240458">Omogoča, da nastavite, ali je treba spletnim mestom, ki izvajajo zlorabe, preprečiti odpiranje novih oken ali zavihkov.

      Če je ta pravilnik omogočen, bo spletnim mestom, ki izvajajo zlorabe, preprečeno odpiranje novih oken ali zavihkov.
      To delovanje pa se ne bo sprožilo, če je onemogočen pravilnik »SafeBrowsingEnabled«.
      Če je ta pravilnik onemogočen, bo spletnim mestom, ki izvajajo zlorabe, dovoljeno odpiranje novih oken ali zavihkov.
      Če ta pravilnik ni nastavljen, bo izbrana možnost, da je omogočen.</translation>
<translation id="467236746355332046">Podprte funkcije:</translation>
<translation id="4674167212832291997">Prilagaja seznam vzorcev URL-jev, ki jih vedno upodobi <ph name="PRODUCT_FRAME_NAME" />.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljen privzeti upodabljalnik, kot ga določa pravilnik »ChromeFrameRendererSettings«.

          Primere vzorcev si lahko ogledate na https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="467449052039111439">Odpri seznam URL-jev</translation>
<translation id="4674871290487541952">Omogočanje algoritmov, ki niso varni, pri preverjanju celovitosti posodobitev in namestitev razširitev</translation>
<translation id="4680936297850947973">Zastarelo v M68. Uporabite pravilnik DefaultPopupsSetting.

      Podrobno pojasnilo je na strani https://www.chromestatus.com/features/5675755719622656.
      Če je ta pravilnik omogočen, bo spletnim mestom dovoljeno hkratno premikanje in odpiranje novih oken/zavihkov.
      Če je ta pravilnik onemogočen ali ni nastavljen, spletnim mestom ne bo dovoljeno hkratno premikanje in odpiranje novih oken/zavihkov.</translation>
<translation id="4680961954980851756">Omogoči samodejno izpolnjevanje</translation>
<translation id="4703402283970867140">Omogoči pametni model zatemnitve za podaljšanje časa do zatemnitve zaslona</translation>
<translation id="4722122254122249791">Omogočanje osamitve spletnih mest za določene izvore</translation>
<translation id="4722399051042571387">Če je nastavitev onemogočena, uporabniki ne bodo mogli nastaviti kod PIN, ki so šibke in jih je mogoče preprosto uganiti.

          Nekaj primerov šibkih kod PIN: kode, ki vsebujejo samo eno števko (1111), kode, pri katerih se števke povečujejo za številko 1 (1234), kode, pri katerih se števke zmanjšujejo za številko 1 (4321), in kode, ki so preveč pogoste.

          Če se koda PIN smatra za šibko, uporabniki privzeto prejmejo opozorilo, ne pa napake.</translation>
<translation id="4723829699367336876">Omogoči prehod skozi požarni zid iz odjemalca za oddaljeni dostop</translation>
<translation id="4725528134735324213">Omogočanje storitve Android Backup Service</translation>
<translation id="4725801978265372736">Zahteva, da se ujemata ime lokalnega uporabnika in lastnika gostitelja za oddaljeni dostop</translation>
<translation id="4733471537137819387">Pravilniki, povezani z integriranim preverjanjem pristnosti HTTP.</translation>
<translation id="4744190513568488164">Strežniki, v katere lahko <ph name="PRODUCT_NAME" /> delegira.

          Imena strežnikov ločite z vejicami. Nadomestni znaki (*) so dovoljeni.

          Če tega pravilnika ne nastavite, <ph name="PRODUCT_NAME" /> ne bo delegiral uporabniških poverilnic, tudi če je strežnik zaznan kot intranet.</translation>
<translation id="4752880493649142945">Potrdilo odjemalca za vzpostavljanje povezave s tem: RemoteAccessHostTokenValidationUrl</translation>
<translation id="4757671984625088193">Če je pravilnik omogočen ali ni nastavljen, bo <ph name="PRODUCT_NAME" /> predlagal strani, povezane s trenutno stranjo.
      Ti predlogi se prenesejo oddaljeno iz Googlovih strežnikov.

      Če je ta nastavitev onemogočena, se predlogi ne bodo prenesli ali prikazali.</translation>
<translation id="4759650396863318477">Omogoči nastavitev časovnega obdobja v milisekundah, v katerem so uporabniki obveščeni, da mora biti brskalnik <ph name="PRODUCT_NAME" /> znova zagnan ali da mora biti naprava <ph name="PRODUCT_OS_NAME" /> znova zagnana za uveljavitev čakajoče posodobitve.

      V tem časovnem obdobju je uporabnik večkrat obveščen glede potrebe po posodobitvi. V skladu s pravilnikom <ph name="RELAUNCH_HEADS_UP_PERIOD_POLICY_NAME" /> se za naprave <ph name="PRODUCT_OS_NAME" /> v sistemski vrstici pojavi obvestilo o vnovičnem zagonu. Za brskalnike <ph name="PRODUCT_NAME" /> se meni aplikacije spremeni, da ponazori, da je potreben vnovični zagon, ko mine ena tretjina obdobja za obveščanje. Barva tega obvestila se spremeni, ko mineta dve tretjini obdobja za obveščanje, in znova, ko mine celotno obdobje za obveščanje. Za dodatna obvestila, ki jih je omogočil pravilnik <ph name="RELAUNCH_NOTIFICATION_POLICY_NAME" />, prav tako velja ta pravilnik.

      Če pravilnik ni nastavljen, se za naprave <ph name="PRODUCT_OS_NAME" /> kot privzeto časovno obdobje uporabi 345.600.000 milisekund (štirje dnevi), za brskalnike <ph name="PRODUCT_NAME" /> pa 604.800.000 milisekund (en teden).</translation>
<translation id="4788252609789586009">Omogoči funkcijo za samodejno izpolnjevanje v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom omogoča samodejno izpolnjevanje podatkov o kreditni kartici v spletnih obrazcih s predhodno shranjenimi podatki.

      Če je ta nastavitev onemogočena, samodejno izpolnjevanje ne bo nikoli predlagalo ali vneslo podatkov o kreditni kartici in prav tako ne bo shranilo dodatnih podatkov o kreditni kartici, ki jih uporabnik lahko pošlje med brskanjem v spletu.

      Če je ta nastavitev omogočena ali nima nastavljene vrednosti, bo uporabnik lahko nadziral samodejno izpolnjevanje za kreditne kartice v uporabniškem vmesniku.</translation>
<translation id="4791031774429044540">Omogočanje funkcije velikega kazalca za ljudi s posebnimi potrebami.

          Če ta pravilnik vklopite, bo prikaz velikega kazalca vedno omogočen.

          Če ta pravilnik izklopite, bo prikaz velikega kazalca vedno onemogočen.

          Če ta pravilnik nastavite, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če pravilnika ne nastavite, je velik kazalec prvotno onemogočen, vendar ga lahko uporabniki kadar koli omogočijo.</translation>
<translation id="4802905909524200151">Konfiguriranje delovanja posodobitve vdelane programske opreme modula <ph name="TPM_FIRMWARE_UPDATE_TPM" /></translation>
<translation id="4804828344300125154">Ob odjavi uporabnika vedno vnovičen zagon.</translation>
<translation id="4807950475297505572">Uporabniki, pri katerih je minilo največ časa, odkar so bili uporabljeni, se odstranijo, dokler ni dovolj prostora</translation>
<translation id="4816674326202173458">Dovoli poslovnemu uporabniku, da je primarni in sekundarni uporabnik (privzeti način delovanja za neupravljane uporabnike)</translation>
<translation id="4826326557828204741">Dejanje, ki se izvede, ko pri akumulatorskem napajanju dosežena zakasnitev zaradi nedejavnosti</translation>
<translation id="4832852360828533362">Poročanje o uporabniku in napravi</translation>
<translation id="4834526953114077364">Uporabniki, pri katerih je minilo največ časa, odkar so bili uporabljeni, in se niso prijavili v zadnjih treh mesecih, se odstranijo, dokler ni dovolj prostora</translation>
<translation id="4835622243021053389">Omogočanje preverjanja pristnosti NTLMv2.</translation>
<translation id="4858735034935305895">Dovoli celozaslonski način</translation>
<translation id="4861767323695239729">Konfiguriranje dovoljenih načinov vnosa v uporabniški seji</translation>
<translation id="487460824085252184">Samodejna selitev brez spraševanja za privolitev uporabnika.</translation>
<translation id="4874982543810021567">Blokiranje WebUSB-ja na teh spletnih mestih</translation>
<translation id="4876805738539874299">Najvišja omogočena različica protokola SSL</translation>
<translation id="4887274746092315609">Omogoča stran za spremembo gesla med sejo za uporabnike prijave SAML</translation>
<translation id="4897928009230106190">Določa parametre, uporabljene pri iskanju predlogov z metodo POST. Sestavljena je iz parov ime/vrednost, ločenih z vejico. Če je vrednost parameter predloge, kot je v zgornjih primerih {searchTerms}, bo zamenjana s pravimi podatki iskalnih izrazov.

          Ta pravilnik je izbiren. Če ni nastavljen, bo zahteva za iskanje predlogov poslana z metodo GET.

          Ta pravilnik se upošteva samo, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="489803897780524242">Parameter, ki nadzira umestitev iskalnega izraza za privzetega ponudnika iskanja</translation>
<translation id="4899708173828500852">Omogoči varno brskanje</translation>
<translation id="4899802251198446659">Omogoča nadziranje, ali se lahko videoposnetki samodejno predvajajo (brez soglasja uporabnika) z zvočno vsebino v brskalniku <ph name="PRODUCT_NAME" />.

      Če je pravilnik omogočen, je v brskalniku <ph name="PRODUCT_NAME" /> dovoljeno samodejno predvajanje predstavnosti.
      Če je pravilnik onemogočen, v brskalniku <ph name="PRODUCT_NAME" /> ni dovoljeno samodejno predvajanje predstavnosti. Če želite za določene vzorce URL to preglasiti, lahko uporabite pravilnik AutoplayWhitelist.
      V brskalniku <ph name="PRODUCT_NAME" /> privzeto ni dovoljeno samodejno predvajanje predstavnosti. Če želite za določene vzorce URL to preglasiti, lahko uporabite pravilnik AutoplayWhitelist.

      Opomba: če se <ph name="PRODUCT_NAME" /> izvaja in se ta pravilnik spremeni, bo uporabljen samo za novoodprte zavihke. Nekateri zavihki bodo zato morda še vedno delovali po starem.
      </translation>
<translation id="4906194810004762807">Osveži oceno za pravilnik za naprave</translation>
<translation id="4917385247580444890">Močan</translation>
<translation id="4923806312383904642">Omogočanje, da funkcija WebDriver preglasi nezdružljive pravilnike</translation>
<translation id="494613465159630803">Sprejemnik za Google Cast</translation>
<translation id="494924690085329212">Vnovičen zagon ob odjavi uporabnika, če se je zagnal Android.</translation>
<translation id="4962262530309732070">Če je ta pravilnik omogočen ali ni nastavljen, <ph name="PRODUCT_NAME" /> dovoli dodajanje osebe v upravitelju uporabnikov.

      Če je ta pravilnik onemogočen, <ph name="PRODUCT_NAME" /> ne dovoli ustvarjanja novih profilov v upravitelju uporabnikov.</translation>
<translation id="4970855112942626932">Onemogočanje prijave v brskalnik</translation>
<translation id="4978405676361550165">Če je nastavljen pravilnik »OffHours«, so določeni pravilniki za naprave prezrti (uporaba privzetih nastavitev teh pravilnikov) med določenimi časovnimi intervali. Chrome znova uporabi pravilnike za naprave pri vsakem dogodku, ko se začne ali konča obdobje »OffHours«. Uporabnik bo obveščen in prisiljen, da se odjavi, ko bodo spremenjeni konec obdobja »OffHours« in nastavitve pravilnikov za naprave (npr. če je uporabnik prijavljen z nedovoljenim računom).</translation>
<translation id="4980635395568992380">Vrsta podatkov:</translation>
<translation id="4983201894483989687">Dovoli izvajanje zastarelih vtičnikov</translation>
<translation id="4986560318567565414">Pot do Chroma za preklop z nadomestnega brskalnika.</translation>
<translation id="4988291787868618635">Dejanje, ki naj se izvede, ko preteče časovni zamik nedejavnosti</translation>
<translation id="5034604678285451405">Nastavitev praga za funkcijo preklopa na akumulatorsko napajanje ob konicah v odstotkih.

          Ta pravilnik se uporablja samo, če je omogočen pravilnik DevicePowerPeakShiftEnabled.

          Če ta pravilnik ni konfiguriran ali nastavljen, je funkcija preklopa na akumulatorsko napajanje ob konicah vedno onemogočena.</translation>
<translation id="5047604665028708335">Omogoči dostop do spletnih mest zunaj paketov vsebine</translation>
<translation id="5052081091120171147">Če je ta pravilnik omogočen, se zgodovina brskanja uvozi iz trenutnega privzetega brskalnika. Če je omogočen, ta pravilnik vpliva tudi na pogovorno okno za uvoz.

     Če je onemogočen, se zgodovina brskanja stran ne uvozi.

      Če ni nastavljen, bo uporabnik morda vprašan, ali naj jo uvozi, ali pa bo uvoz izveden samodejno.</translation>
<translation id="5055312535952606505">Določi nastavitve strežnika proxy za izdelek <ph name="PRODUCT_NAME" />. Te nastavitve strežnika proxy so na voljo tudi za aplikacije ARC.

          Če omogočite to nastavitev, <ph name="PRODUCT_NAME" /> in aplikacije ARC prezrejo vse možnosti, povezane s strežnikom proxy, navedene v ukazni vrstici.

          Če ta pravilnik ni nastavljen, lahko uporabniki sami izberejo nastavitve strežnika proxy.

          Če je nastavljen pravilnik <ph name="PROXY_SETTINGS_POLICY_NAME" />, preglasi katere koli posamezne pravilnike <ph name="PROXY_MODE_POLICY_NAME" />, <ph name="PROXY_PAC_URL_POLICY_NAME" />, <ph name="PROXY_SERVER_POLICY_NAME" />, <ph name="PROXY_BYPASS_POLICY_NAME" /> in <ph name="PROXY_SERVER_MODE_POLICY_NAME" />.

          V polju <ph name="PROXY_MODE_PROXY_SETTINGS_FIELD" /> lahko določite strežnik proxy, ki naj ga uporablja <ph name="PRODUCT_NAME" /> in uporabnikom prepreči spreminjanje nastavitev strežnika proxy.

          Polje <ph name="PROXY_PAC_URL_PROXY_SETTINGS_FIELD" /> je URL za datoteko .pac strežnika proxy.

          Polje <ph name="PROXY_SERVER_PROXY_SETTINGS_FIELD" /> je URL strežnika proxy.

          Polje <ph name="PROXY_BYPASS_LIST_PROXY_SETTINGS_FIELD" /> je seznam gostiteljev strežnika proxy, ki jih <ph name="PRODUCT_NAME" /> obide.

          Polje <ph name="PROXY_SERVER_MODE_PROXY_SETTINGS_FIELD" /> je zastarelo. Uporablja se polje »ProxyMode«. Omogoča določanje strežnika proxy, ki naj ga uporablja <ph name="PRODUCT_NAME" />, in uporabnikom prepreči spreminjanje nastavitev strežnika proxy.

          Če izberete vrednost »direct« kot »ProxyMode«, strežnik proxy ne bo uporabljen in vsa druga polja bodo prezrta.

          Če izberete vrednost »system« kot »ProxyMode«, bo uporabljen strežnik proxy sistema in vsa druga polja bodo prezrta.

          Če izberete vrednost »auto_detect« kot »ProxyMode«, bodo vsa druga polja prezrta.

          Če izberete vrednost »fixed_server« kot »ProxyMode, se uporabita polji »ProxyServer« in »ProxyBypassList«.

          Če izberete vrednost »pac_script« kot »ProxyMode, se uporabita polji »ProxyPacUrl« in »ProxyBypassList«.</translation>
<translation id="5056708224511062314">Izklop lupe</translation>
<translation id="5058573563327660283">Izbere strategijo za sproščanje prostora na disku med samodejnim čiščenjem (zastarelo)</translation>
<translation id="5067143124345820993">Seznam odobrenih uporabnikov za prijavo</translation>
<translation id="5075834892754086022">Če je ta pravilnik nastavljen, se uveljavi najmanjša dovoljena dolžina kode
          PIN. (Absolutna najmanjša dovoljena dolžina kode PIN je 1; manjše vrednosti kot 1
          se obravnavajo kot 1.)

          Če pravilnik ni nastavljen, se uveljavi najmanjša dovoljena dolžina kode PIN, ki je
          6-mestna. To je priporočena najmanjša dovoljena dolžina.</translation>
<translation id="5076274878326940940">Omogoča uporabo privzetega ponudnika iskanja.

          Če omogočite to nastavitev, se izvede privzeto iskanje, če uporabnik v naslovni vrstici vnese besedilo, ki ni URL.

          Privzetega ponudnika iskanja, ki naj se uporablja, lahko določite tako, da nastavite preostale pravilnike za privzeto iskanje. Če pustite prazne, lahko uporabnik sam izbere privzetega ponudnika.

          Če onemogočite to nastavitev, se ne izvede nobeno iskanje, ko uporabnik v naslovni vrstici vnese besedilo, ki ni URL.

          Če to nastavitev omogočite ali onemogočite, uporabniki te nastavitve v brskalniku <ph name="PRODUCT_NAME" /> ne morejo spremeniti ali preglasiti.

          Če ta pravilnik ni nastavljen, je omogočen privzeti ponudnik iskanja, uporabnik pa bo lahko nastavil seznam ponudnikov iskanja.

          Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="5085647276663819155">Onemogoči predogled tiskanja</translation>
<translation id="5090209345759901501">Razširitev nastavitve za vsebino Flash na vso vsebino</translation>
<translation id="5090791951240382356">Omogočanje združevanja pravilnikov o slovarjih iz različnih virov</translation>
<translation id="5093540029655764852">Določa, kako pogosto (v dnevih) odjemalec spremeni geslo računa v napravi. Geslo naključno generira odjemalec in ni vidno uporabniku.

      Tako kot gesla uporabnikov je treba redno spreminjati tudi gesla računov v napravi. Če onemogočite ta pravilnik ali nastavite veliko število dni, lahko to negativno vpliva na varnost, saj morebitnim napadalcem daje več časa, da uganejo geslo računa v napravi in ga uporabijo.

      Če pravilnik ni nastavljen, se geslo računa v napravi spremeni vsakih 30 dni.

      Če je pravilnik nastavljen na 0, je geslo računa v napravi onemogočeno.

      Če je odjemalec dalj časa brez povezave, so lahko zgodi, da so gesla starejša od navedenega števila dni.</translation>
<translation id="510196893779239086">Ta pravilnik nadzira, ali naj se Chrome povsem zapre, ko bi zadnji zavihek preklopil na drug brskalnik.

      Če tega pravilnika ne nastavite ali ga nastavite na »true«, bo Chrome po preklopu na drug brskalnik ohranil odprt vsaj en zavihek.

      Če je ta pravilnik nastavljen na »false«, bo Chrome po preklopu na drug brskalnik zaprl zavihek, tudi če gre za zadnji zavihek. S tem se bo Chrome povsem zaprl.</translation>
<translation id="5102203758995933166">Omogoča pošiljanje omrežne konfiguracije, ki se uporablja glede na uporabnika, v napravo z operacijskim sistemom <ph name="PRODUCT_OS_NAME" />. Omrežna konfiguracija je niz v obliki zapisa JSON, kot je določeno z obliko konfiguracije odprtega omrežja.</translation>
<translation id="5105313908130842249">Časovni zamik zaklepa zaslona, če se napaja iz akumulatorja</translation>
<translation id="5108031557082757679">Onemogočeni tiskalniki za naprave v podjetjih</translation>
<translation id="5124368997194894978">Omogočanje zagona pri napajanju iz električnega omrežja (izmenični tok)</translation>
<translation id="5131211790949066746">Omogoča združevanje pravilnikov o seznamu namestitev razširitev <ph name="EXTENSION_INSTALL_BLACKLIST_POLICY_NAME" />, <ph name="EXTENSION_INSTALL_WHITELIST_POLICY_NAME" /> in <ph name="EXTENSION_INSTALL_FORCELIST_POLICY_NAME" />.

      Če omogočite to nastavitev, so vrednosti iz pravilnika o okolju naprave, pravilnika o oblaku naprave in pravilnika o okolju uporabnikov združene na enem seznamu in so uporabljene kot celota, namesto uporabe samo vrednosti iz enega vira z največjo prednostjo.

      Če to nastavitev onemogočite ali je ne nastavite, se vzamejo samo vnosi na seznamu iz vira z največjo prednostjo, vsi drugi viri pa so prikazani kot spori in so prezrti.</translation>
<translation id="5141670636904227950">Nastavitev privzete vrste lupe, omogočene na prijavnem zaslonu</translation>
<translation id="5142301680741828703">Vedno upodobi te vzorce URL-jev v programu <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="5148753489738115745">Določite lahko dodatne parametre, ki so uporabljeni, ko <ph name="PRODUCT_FRAME_NAME" /> zažene <ph name="PRODUCT_NAME" />.

          Če ta pravilnik ni nastavljen, je uporabljena privzeta ukazna vrstica.</translation>
<translation id="5159469559091666409">Kako pogosto se pošiljajo omrežni paketi za spremljanje (v milisekundah).

      Če ta pravilnik ni nastavljen, je privzeti interval 3 minute.
      Najmanjši interval je 30 sekund, največji pa 24 ur –
      vrednosti zunaj tega obsega bodo omejene na ta obseg.</translation>
<translation id="5163002264923337812">Omogoči stari spletni potek prijave</translation>
<translation id="5168529971295111207">Ta pravilnik je zastarel, namesto njega uporabite ProxyMode.

          Omogoča izbiro strežnika proxy, ki naj ga uporablja <ph name="PRODUCT_NAME" />, in uporabnikom prepreči spreminjanje nastavitev strežnika proxy.

          Ta pravilnik ima vpliv samo, če je onemogočen pravilnik <ph name="PROXY_SETTINGS_POLICY_NAME" />.

          Če izberete, da se strežnik proxy nikoli ne uporablja in se vedno vzpostavi neposredna povezava, so vse druge možnosti prezrte.

          Če izberete uporabo sistemskih nastavitev strežnika proxy ali samodejno zaznavanje strežnika proxy, bodo vse druge možnosti prezrte.

          Če izberete ročno nastavitev strežnika proxy, lahko v možnostih »Naslov ali URL strežnika proxy«, »URL datoteke .pac za proxy« in »Seznam pravil za obvod strežnika proxy, ločenih z vejicami« izberete dodatne nastavitve. Za aplikacije ARC je na voljo samo strežnik proxy HTTP z največjo prednostjo.

          Podrobne primere si lahko ogledate tukaj:
          <ph name="PROXY_HELP_URL" />.

          Če omogočite to nastavitev, <ph name="PRODUCT_NAME" /> prezre vse možnosti, povezane s strežnikom proxy, navedene v ukazni vrstici.

          Če ta pravilnik ni nastavljen, lahko uporabniki sami izberejo nastavitve strežnika proxy.</translation>
<translation id="5182055907976889880">Konfigurira Google Drive v brskalniku <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="5183383917553127163">Omogoča, da določite, za katere razširitve ne velja seznam prepovedanih.

          Vrednost * na seznamu prepovedanih pomeni, da so prepovedane vse razširitve in lahko uporabniki namestijo samo razširitve s seznama dovoljenih.

          Privzeto so dovoljene vse razširitve, če pa so vse prepovedane s pravilnikom, ga lahko preglasite s seznamom dovoljenih.</translation>
<translation id="519247340330463721">Konfigurirajte pravilnike, povezane s funkcijo varnega brskanja.</translation>
<translation id="5192837635164433517">Omogoča uporabo nadomestnih strani za napake, ki so vgrajene v <ph name="PRODUCT_NAME" /> (na primer »Strani ni mogoče najti«), in preprečuje uporabnikom spreminjanje te nastavitve.

      Če to nastavitev omogočite, se nadomestne spletne strani uporabljajo.

      Če to nastavitev onemogočite, jo uporabniki v programu <ph name="PRODUCT_NAME" /> ne morejo spremeniti ali preglasiti.

      Če ta pravilnik ni nastavljen, bo to omogočeno, vendar bo lahko uporabnik to spremenil.</translation>
<translation id="5196805177499964601">Blokiranje načina za razvijalce.

      Če je ta pravilnik vklopljen, bo sistem <ph name="PRODUCT_OS_NAME" /> preprečil, da bi se naprava zagnala v načinu za razvijalce. Če je stikalo za razvijalce vklopljeno, sistem ne bo dovolil zagona in bo prikazal zaslon z napako.

      Če ta pravilnik ni nastavljen ali je izklopljen, bo način za razvijalce v napravi še naprej na voljo.</translation>
<translation id="520403427390290017">Funkcija življenjskih ciklov povrne sredstva CPE-ja, sčasoma pa tudi pomnilnika, povezana z zavihki, ki se izvajajo, vendar že dalj časa niso bili uporabljeni, in sicer tako, da jim najprej omeji delovanje, nato jih zamrzne, na koncu pa zavrže.

      Če je pravilnik onemogočen, so življenjski cikli zavihkov onemogočeni in vsi zavihki se bodo še naprej normalno izvajali.

      Če je pravilnik omogočen ali ni opredeljen, so življenjski cikli zavihkov omogočeni.</translation>
<translation id="5207823059027350538">Konfigurira privzeti URL novega zavihka s povezavami in uporabnikom prepreči, da ga bi spremenili.

          Novi zavihek s povezavami je stran, ki se odpre, ko so ustvarjeni novi zavihki (vključno s stranjo, odprto v novih oknih).

          Ta pravilnik ne odloča o tem, katere strani se odprejo ob zagonu. Te nadzirajo pravilniki <ph name="RESTORE_ON_STARTUP_POLICY_NAME" />. Ta pravilnik pa vpliva na domačo stran, če je nastavljena tako, da se odpre nov zavihek s povezavami, in na začetno stran, če je nastavljena tako, da se odpre nov zavihek s povezavami.

          Če pravilnik ni nastavljen ali pustite praznega, se uporabi privzeti nov zavihek s povezavami.

          Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="5208240613060747912">Omogoča nastavitev seznama vzorcev URL-jev, s katerim so določena spletna mesta, ki jim ni dovoljeno prikazovati obvestil.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena splošna privzeta vrednost iz pravilnika »DefaultNotificationsSetting«, kadar je ta nastavljen, ali iz uporabnikove osebne konfiguracije, kadar pravilnik »DefaultImagesSetting« ni nastavljen.</translation>
<translation id="5213038356678567351">Spletna mesta, ki naj nikoli ne sprožijo preklopa brskalnika.</translation>
<translation id="5219844027738217407">Pri aplikacijah za Android ta pravilnik vpliva samo na mikrofon. Če je ta pravilnik omogočen, ima mikrofon brez izjem izklopljen zvok pri vseh aplikacijah za Android.</translation>
<translation id="5221394278852982313">Omogoča nastavitev seznama URL-jev, ki določajo, katerim spletnim mestom bo samodejno podeljeno dovoljenje za dostop do naprave USB z danim ID-jem izdelka in dobavitelja. Pravilnik je veljaven samo, če vsak element na seznamu vsebuje tako naprave kot tudi URL-je. Vsak element v napravah lahko vsebuje polje z ID-jem dobavitelja in ID-jem izdelka. Vsak izpuščen ID se obravnava kot nadomestni znak z eno izjemo, in sicer, da ID izdelka ne more biti naveden, ne da bi bil naveden tudi ID dobavitelja. Pravilnik sicer ne bo veljaven in bo prezrt.

        Model dovoljenj za USB uporablja URL spletnega mesta, ki pošlje zahtevo (»URL z zahtevo«), in URL spletnega mesta z vrhnjim okvirjem (»URL za vdelavo«), da URL-ju z zahtevo podeli dovoljenje za dostop do naprave USB. URL z zahtevo se lahko razlikuje od URL-ja za vdelavo, če je stran, ki pošilja zahtevo, naložena v okviru iframe. Polje »urls« lahko tako vsebuje do dva niza z URL-jem, ločena z vejico, ki določata URL z zahtevo oziroma URL za vdelavo. Če je naveden samo en URL, bo dostop do ustreznih naprav USB podeljen, ko se URL spletnega mesta, ki pošilja zahtevo, ujema s tem URL-jem, ne glede na stanje vdelave. URL-ji v polju »urls« morajo biti veljavni URL-ji, sicer se pravilnik prezre.

        Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi globalna privzeta vrednost iz pravilnika »DefaultWebUsbGuardSetting«, če je nastavljen, sicer pa iz uporabnikove osebne konfiguracije.

        Vzorci URL-jev v tem pravilniku ne smejo biti v navzkrižju s tistimi, ki so konfigurirani prek pravilnika WebUsbBlockedForUrls. V primeru navzkrižja ima ta pravilnik prednost pred pravilnikoma WebUsbBlockedForUrls in WebUsbAskForUrls.

        Vrednosti za ta pravilnik in pravilnik DeviceWebUsbAllowDevicesForUrls so združene.</translation>
<translation id="5228316810085661003">Zamik samodejne prijave v lokalni račun v napravi.

      Če pravilnik |DeviceLocalAccountAutoLoginId| ni nastavljen, ta pravilnik nima vpliva. V nasprotnem primeru:

      Če je ta pravilnik nastavljen, določa čas nedejavnosti uporabnika, ki mora preteči pred samodejno prijavo v lokalni račun v napravi, ki jo določa pravilnik |DeviceLocalAccountAutoLoginId|.

      Če ta pravilnik ni nastavljen, se za časovno omejitev uporabi 0 milisekund.

      Ta pravilnik je določen v milisekundah.</translation>
<translation id="523505283826916779">Nastavitve funkcij za ljudi s posebnimi potrebami</translation>
<translation id="5236882091572996759">Če je vrednost pravilnika nastavljena na »True« ali če pravilnik ni nastavljen, uporabnik ne velja za nedejavnega, če se predvaja zvočni posnetek. S tem se prepreči, da bi se dosegla časovna omejitev nedejavnosti in bi se izvedlo dejanje ob nedejavnosti. Zatemnitev zaslona, izklop zaslona in zaklep zaslona se izvedejo po preteku konfigurirane časovne omejitve ne glede na zvočno dejavnost.

          Če je vrednost pravilnika nastavljena na »False«, uporabnik kljub zvočni dejavnosti velja za nedejavnega.</translation>
<translation id="5246700266104954355">Ta pravilnik je zastarel. Uporabite pravilnik <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" /> za nadziranje razpoložljivosti vtičnika za Flash in pravilnik <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> za nadziranje, ali je za odpiranje datotek PDF treba uporabiti vdelan pregledovalnik PDF-jev.

      Določi seznam vtičnikov, ki so omogočeni v brskalniku <ph name="PRODUCT_NAME" />, in uporabnikom prepreči, da bi to nastavitev spremenili.

      Nadomestna znaka * in ? je mogoče uporabiti za nadomeščanje zaporedij poljubnih znakov. Znak * nadomešča poljubno število znakov, znak ? pa izbirni posamezen znak, tj. nadomešča nič znakov ali en znak. Ubežni znak je \; če torej želite nadomestiti dejanske znake *, ? ali \, lahko postavite prednje znak \.

      Določen seznam vtičnikov je v brskalniku <ph name="PRODUCT_NAME" /> vedno uporabljen, če so nameščeni. Vtičniki so v »about:plugins« označeni kot omogočeni in uporabniki jih ne morejo onemogočiti.

      Ta pravilnik preglasi pravilnika DisabledPlugins in DisabledPluginsExceptions.

      Če ta pravilnik ni nastavljen, lahko uporabnik onemogoči kateri koli vtičnik, nameščen v sistemu.</translation>
<translation id="5247006254130721952">Blokiraj nevarne prenose</translation>
<translation id="5248863213023520115">Nastavi dovoljenje vrste šifriranja pri zahtevah za vstopnice Kerberos od strežnika <ph name="MS_AD_NAME" />.

      Če je pravilnik nastavljen na »Vse«, sta dovoljeni vrsti šifriranja AES »aes256-cts-hmac-sha1-96« in »aes128-cts-hmac-sha1-96« ter vrsta šifriranja RC4 »rc4-hmac«. Če strežnik podpira obe vrsti, ima prednost šifriranje AES. Upoštevajte, da šifriranje RC4 ni varno, in če je mogoče, je treba strežnik konfigurirati tako, da bo podpiral šifriranje AES.

      Če je ta pravilnik nastavljen na »Močno« ali ni nastavljen, sta dovoljeni samo vrsti šifriranja AES.

      Če je pravilnik nastavljen na »Starejše«, je dovoljena samo vrsta šifriranja RC4. Ta možnost ni varna in jo uporabite samo v zelo posebnih okoliščinah.

      Glejte tudi: https://wiki.samba.org/index.php/Samba_4.6_Features_added/changed#Kerberos_client_encryption_types.</translation>
<translation id="5249453807420671499">Uporabniki lahko dodajo račune za Kerberos</translation>
<translation id="5255162913209987122">Lahko se priporoča</translation>
<translation id="527237119693897329">Omogoča, da določite, kateri gostitelji izvornega pošiljanja sporočil se ne naložijo.

          Vrednost * na seznamu blokiranih pomeni, da so vsi gostitelji izvornega pošiljanja sporočil blokirani, razen če niso izrecno navedeni na seznamu dovoljenih.

          Če ta pravilnik ni nastavljen, bo izdelek <ph name="PRODUCT_NAME" /> naložil vse nameščene gostitelje izvornega pošiljanja sporočil.</translation>
<translation id="5272684451155669299">Če je pravilnik omogočen, lahko uporabnik overitelju potrdil za zasebnost s strojno opremo v napravah Chrome na daljavo potrdi svojo identiteto z metodo <ph name="CHALLENGE_USER_KEY_FUNCTION" /> prek API-ja <ph name="ENTERPRISE_PLATFORM_KEYS_API" />.

          Če je onemogočen ali če ni nastavljen, pozivi API-ju ne bodo uspeli in bo vrnjena koda napake.</translation>
<translation id="5277806246014825877">Omogočanje temu uporabniku, da lahko izvaja Crostini.

      Če je pravilnik onemogočen, Crostini ni omogočen za uporabnika.
      Če je pravilnik omogočen ali ni nastavljen, je Crostini omogočen za uporabnika, če to omogočajo tudi druge nastavitve.
      Vsi trije pravilniki – VirtualMachinesAllowed, CrostiniAllowed in DeviceUnaffiliatedCrostiniAllowed – morajo biti omogočeni, ko se prijavijo za omogočanje izvajanja Crostinija.
      Če je ta pravilnik spremenjen na onemogočeno stanje, se uporablja za zagon novih vsebnikov Crostinija, vendar ne ustavi vsebnikov, ki se že izvajajo.</translation>
<translation id="5283457834853986457">Onemogočanje iskalnika vtičnikov (zastarelo)</translation>
<translation id="5288772341821359899">Če je pravilnik nastavljen, je obseg vrat UDP, ki jih uporablja tehnologija WebRTC, omejen na navedeni interval vrat (vključno s končnimi točkami).

      Če pravilnik ni nastavljen ali je nastavljen na prazen niz oziroma neveljaven obseg vrat, je tehnologiji WebRTC dovoljeno uporabljati katera koli lokalna vrata UDP, ki so na voljo.</translation>
<translation id="5290940294294002042">Določite seznam vtičnikov, ki jih lahko uporabnik omogoči ali onemogoči</translation>
<translation id="5306186200045823863">Omogočanje zaupanja starejši infrastrukturi PKI družbe Symantec Corporation</translation>
<translation id="5307432759655324440">Razpoložljivost načina brez beleženja zgodovine</translation>
<translation id="5318185076587284965">Gostitelju oddaljenega dostopa omogoči uporabo posredovalnih strežnikov</translation>
<translation id="5323128137188992869">Omogočanje predvajanja vsebine v napravi z napravo <ph name="PRODUCT_NAME" />.

          Če je ta pravilnik onemogočen, uporabniki ne bodo mogli predvajati vsebine v tej napravi. Če je pravilnik omogočen, je uporabnikom dovoljeno predvajanje vsebine. Če ta pravilnik ni nastavljen, uporabnikom ni dovoljeno predvajati vsebine v včlanjenih napravah OS Chrome, vendar jo lahko predvajajo v napravah, ki niso včlanjene.</translation>
<translation id="5329007337159326804">Opozorilo: pravilnik za najvišjo različico protokola TLS bo v celoti odstranjen iz izdelka <ph name="PRODUCT_NAME" /> okoli različice 75 (okoli junija 2019).

      Če ta pravilnik ni konfiguriran, <ph name="PRODUCT_NAME" /> uporablja privzeto najvišjo različico.

      Sicer bo nastavljen na eno od teh vrednosti: »tls1.2« ali »tls1.3«. Če je nastavljen, <ph name="PRODUCT_NAME" /> ne bo uporabljal različic protokolov SSL/TLS, višjih od navedene različice. Neprepoznane vrednosti bodo prezrte.</translation>
<translation id="5330684698007383292">Dovoli, da <ph name="PRODUCT_FRAME_NAME" /> obravnava te vrste vsebine.</translation>
<translation id="5331746669335642668">Pravilnik o oblaku za <ph name="PRODUCT_NAME" /> preglasi pravilnik o okolju.</translation>
<translation id="5365476955714838841">Parametri ukazne vrstice za nadomestni brskalnik.</translation>
<translation id="5365946944967967336">V orodni vrstici pokaži gumb »Domov«</translation>
<translation id="5366745336748853475">Omogoča, da določite seznam vzorcev URL-jev, ki določajo spletna mesta, za katera je potrdilo odjemalca samodejno izbrano na zaslonu za prijavo v okviru, v katerem gostuje potek SAML, če spletno mesto zahteva potrdilo. Primer uporabe je konfiguriranje potrdila v napravi, ki je predloženo SAML IdP.

      Vrednost mora biti polje slovarjev JSON v obliki nizov. Vsak slovar mora imeti obliko { "pattern": "$URL_PATTERN", "filter" : $FILTER }, pri čemer je $URL_PATTERN vzorec nastavljanja vsebine. $FILTER omejuje, katera potrdila odjemalcev bo brskalnik izbral samodejno. Ne glede na filter bodo izbrana samo potrdila, ki se ujemajo z zahtevo strežnika za potrdilo. Če ima $FILTER obliko { "ISSUER": { "CN": "$ISSUER_CN" } }, so poleg tega izbrana samo potrdila odjemalcev, ki jih izda izdajatelj potrdila s pravim imenom $ISSUER_CN. Če je $FILTER prazen slovar {}, izbor potrdil odjemalcev ni dodatno omejen.

      Če ta pravilnik ni nastavljen, se za nobeno spletno mesto ne bo izvajal samodejni izbor.</translation>
<translation id="5366977351895725771">Če pravilnik ni vklopljen, ta uporabnik ne more ustvarjati zaščitenih uporabnikov. Obstoječi zaščiteni uporabniki so še vedno na voljo.

          Če je pravilnik vklopljen ali ni nastavljen, lahko ta uporabnik ustvarja in upravlja zaščitene uporabnike.</translation>
<translation id="5369937289900051171">Samo barvno tiskanje</translation>
<translation id="5370279767682621504">Omogoči podporo za protokol HTTP/0.9 za vrata, ki niso privzeta</translation>
<translation id="5378985487213287085">Omogoča nastavitev, ali lahko spletna mesta prikažejo obvestila na namizju. Prikazovanje obvestil na namizju je lahko privzeto dovoljeno, privzeto zavrnjeno ali pa je uporabnik vprašan, ko želi spletno mesti prikazati obvestilo na namizju.

          Če ta pravilnik ni nastavljen, bo uporabljen pravilnik »AskNotifications« in uporabnik bo lahko to spremenil.</translation>
<translation id="538108065117008131">Dovoli, da <ph name="PRODUCT_FRAME_NAME" /> obravnava te vrste vsebine.</translation>
<translation id="5391388690191341203">Lokalni račun v napravi za samodejno prijavo</translation>
<translation id="5392172595902933844">Podatki o stanju Androida se pošljejo nazaj v
      strežnik.

      Če je pravilnik onemogočen ali ni nastavljen, se podatki o stanju ne poročajo.
      Če je omogočen, se podatki o stanju poročajo.

      Ta pravilnik se uporabi samo, če so aplikacije za Android omogočene.</translation>
<translation id="5395271912574071439">Omogoča zakrivanja gostiteljev za oddaljeni dostop, ko je vzpostavljena povezava.

          Če je ta nastavitev omogočena, so vhodne in izhodne naprave gostitelja onemogočene, ko je vzpostavljena povezava na daljavo.

          Če je ta nastavitev onemogočena ali ni nastavljena, lahko lokalni in oddaljeni uporabniki komunicirajo z gostiteljem, ko je v skupni rabi.</translation>
<translation id="5396049152026347991">Uporabniku omogoča upravljanje povezav VPN.

      Če je ta pravilnik onemogočen, so vsi uporabniški vmesniki sistema <ph name="PRODUCT_NAME" />, ki bi uporabniku omogočali prekinjanje ali spreminjanje povezav VPN, onemogočeni.

      Če ta pravilnik ni nastavljen ali je omogočen, lahko uporabniki prekinjajo ali spreminjaj povezave VPN kot običajno.

      Če je povezava VPN ustvarjena prek aplikacije za VPN, ta pravilnik na uporabniški vmesnik v aplikaciji ne vpliva. Uporabnik lahko še vedno uporablja aplikacijo za spreminjanje povezave VPN.

      Ta pravilnik je namenjen uporabi s funkcijo »Stalno vklopljen VPN«, ki skrbniku dovoljuje, da se odloči za vzpostavitev povezave VPN ob zagonu.</translation>
<translation id="5405289061476885481">Konfigurira, katere postavitve tipkovnice so dovoljene na zaslonu za prijavo sistema <ph name="PRODUCT_OS_NAME" />.

      Če je ta pravilnik nastavljen na seznam identifikatorjev načinov vnosa, so dani načini vnosa na voljo na zaslonu za prijavo. Prvi dani način vnosa je vnaprej izbran. Medtem ko je sklop za uporabnika osredotočen na zaslon za prijavo, je poleg načinov vnosa, ki jih zagotavlja ta pravilnik, na voljo tudi način vnosa, ki ga je uporabnik nazadnje uporabljal. Če ta pravilnik ni nastavljen, se načini vnosa na zaslonu za prijavo izpeljejo iz jezika, v katerem je prikazan zaslon za prijavo. Vrednosti, ki niso veljavni identifikatorji načinov vnosa, bodo prezrte.</translation>
<translation id="5412057811596122582">Če je ta pravilnik omogočen ali ni nastavljen (privzeto), bo uporabnik pozvan, da
      dovoli zajem zvoka, razen za URL-je, nastavljene na seznamu
      AudioCaptureAllowedUrls, za katere bo zajem dovoljen brez poziva uporabniku.

      Če je ta pravilnik onemogočen, uporabnik ne bo nikoli pozvan in bo zajem
      zvoka na voljo samo URL-jem na seznamu AudioCaptureAllowedUrls.

      Pravilnik velja za vgrajeni mikrofon in vse druge načine zvočnega vnosa.</translation>
<translation id="5422643441807528365">Licenčni ključ <ph name="PLUGIN_VM_NAME" /></translation>
<translation id="5423001109873148185">Če je ta pravilnik omogočen, se iskalniki uvozijo iz trenutnega privzetega brskalnika. Če je omogočen, ta pravilnik vpliva tudi na pogovorno okno za uvoz. 

      Če je onemogočen, se privzeti iskalnik ne uvozi.

      Če ni nastavljen, bo uporabnik morda vprašan, ali naj ga uvozi, ali pa bo uvoz izveden samodejno.</translation>
<translation id="5423197884968724595">Ime omejitve za Android WebView:</translation>
<translation id="5424147596523390018">Dovoli vse barvne načine</translation>
<translation id="5427003226809696696">Ta pravilnik nadzira, ali se okno brskalnika odpre na začetku seje.

          Če je ta pravilnik omogočen, se okno brskalnika ne odpre.

          Če je ta pravilnik onemogočen ali ni nastavljen, se je oknu brskalnika dovoljeno odpreti. Upoštevajte, da se okno brskalnika morda ne bo odprlo zaradi drugih pravilnikov ali zastavic ukazne vrstice.</translation>
<translation id="5427879482805712214">S tem pravilnikom lahko nastavite sliko avatarja, ki na zaslonu za prijavo predstavlja uporabnika. Pravilnik se nastavi tako, da določite URL, s katerega lahko operacijski sistem <ph name="PRODUCT_OS_NAME" /> prenese sliko za avatar, in kriptografsko zgoščeno vrednost za preverjanje celovitosti prenosa. Slika mora biti v obliki JPEG in njena velikost ne sme presegati 512 KB. URL mora biti dostopen brez preverjanja pristnosti.

      Slika za avatar se prenese in shrani v predpomnilnik. Če se spremeni URL ali zgoščena vrednost, se znova prenese.

      Če je ta pravilnik nastavljen, bo operacijski sistem <ph name="PRODUCT_OS_NAME" /> prenesel in uporabil sliko za avatar.

      Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

      Če tega pravilnika ne nastavite, lahko uporabnik izbere sliko za avatar, ki ga predstavlja na zaslonu za prijavo.</translation>
<translation id="5432219358069697932">S tem pravilnikom lahko nastavite sliko za ozadje, prikazano na namizju in na prijavni strani za uporabnika. Pravilnik se nastavi tako, da navedete URL, s katerega lahko <ph name="PRODUCT_OS_NAME" /> prenese sliko za ozadje, in kriptografsko zgoščeno vrednost, ki se uporabi za preverjanje celovitosti prenosa. Slika mora biti v obliki JPEG in njena velikost ne sme presegati 16 MB. URL mora biti dostopen brez preverjanja pristnosti.

      Slika za ozadje se prenese in predpomni. Če se spremeni URL ali zgoščena vrednost, se znova prenese.

      Če je ta pravilnik nastavljen, bo sistem <ph name="PRODUCT_OS_NAME" /> prenesel in uporabil sliko za ozadje.

      Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

      Če tega pravilnika ne nastavite, lahko uporabnik izbere sliko, ki bo prikazana na namizju in v ozadju zaslona za prijavo.</translation>
<translation id="5437733496511628148">Če omogočite to nastavitev, preprečite, da bi piškotke nastavljali elementi spletnih strani, ki niso iz domene, navedene v naslovni vrstici brskalnika.

      Če jo onemogočite, dovolite, da piškotke nastavljajo elementi spletnih strani, ki niso iz domene, navedene v naslovni vrstici brskalnika, in uporabnikom preprečite spreminjanje te nastavitve.

      Če ta pravilnik ni nastavljen, bodo piškotki drugih spletnih mest omogočeni, vendar bo lahko uporabnik to spremenil.</translation>
<translation id="5442026853063570579">Ta pravilnik prav tako nadzira dostop do možnosti za razvijalce za Android. Če ta pravilnik nastavite na »DeveloperToolsDisallowed« (vrednost 2), uporabniki ne morejo dostopati do možnosti za razvijalce. Če ta pravilnik onemogočite ali ga ne nastavite, uporabniki lahko dostopajo do možnosti za razvijalce tako, da se v aplikaciji Nastavitve za Android sedemkrat dotaknejo številke gradnje.</translation>
<translation id="544342220587994947">Omogoča, da določite seznam vzorcev spletnih naslovov, ki določajo spletna mesta, za katera mora <ph name="PRODUCT_NAME" /> samodejno izbrati potrdilo odjemalca, če ga spletno mesto zahteva.

          Vrednost mora biti polje slovarjev JSON v obliki nizov. Vsak slovar mora imeti obliko { "pattern": "$URL_PATTERN", "filter" : $FILTER }, pri čemer je $URL_PATTERN vzorec nastavljanja vsebine. $FILTER omejuje, katera potrdila odjemalcev bo brskalnik izbral samodejno. Ne glede na filter bodo izbrana samo potrdila, ki se ujemajo z zahtevo strežnika za potrdilo. Če ima na primer $FILTER obliko { "ISSUER": { "CN": "$ISSUER_CN" } }, so poleg tega izbrana samo potrdila odjemalcev, ki jih izda izdajatelj potrdila s pravim imenom CommonName $ISSUER_CN. Če $FILTER vsebuje razdelka »ISSUER« in »SUBJECT«, mora potrdilo odjemalca izpolnjevati oba pogoja, da je izbrano. Če $FILTER določa organizacijo (»O«), mora imeti potrdilo vsaj eno organizacijo, ki se ujema z določeno vrednostjo, da je izbrano. Če $FILTER določa organizacijsko enoto (»OU«), mora imeti potrdilo vsaj eno organizacijsko enoto, ki se ujema z določeno vrednostjo, da je izbrano. Če je $FILTER prazen slovar {}, izbor potrdil odjemalcev ni dodatno omejen.

          Če ta pravilnik ni nastavljen, se za nobeno spletno mesto ne bo izvajal samodejni izbor.</translation>
<translation id="5447306928176905178">Omogoči poročanje o podatkih pomnilnika (velikost kopice JS) strani (zastarelo)</translation>
<translation id="5457065417344056871">Omogočanje načina za goste v brskalniku</translation>
<translation id="5457924070961220141">Omogoča nastavitev privzetega upodabljalnika HTML, ko je <ph name="PRODUCT_FRAME_NAME" /> nameščen.
          Če ta pravilnik ni nastavljen, je gostiteljskemu brskalniku upodabljanje privzeto dovoljeno, vendar lahko po želji to preglasite in določite, da bo <ph name="PRODUCT_FRAME_NAME" /> privzeto upodabljal strani HTML.</translation>
<translation id="5458584148602890023">Omogočanje funkcije preklopa na akumulatorsko napajanje ob konicah</translation>
<translation id="5464816904705580310">Konfiguriranje nastavitev za upravljane uporabnike.</translation>
<translation id="546726650689747237">Časovni zamik zatemnitve zaslona ob napajanju iz električnega omrežja</translation>
<translation id="5469143988693423708">Uporabniku je omogočeno izvajanje Crostinija</translation>
<translation id="5469825884154817306">Blokiranje slik na teh mestih</translation>
<translation id="5472668698895343595">Ta pravilnik nadzira seznam spletnih mest, ki naj se odprejo v nadomestnem brskalniku.

      Upoštevajte, da je mogoče elemente tudi dodati na ta seznam s pravilnikoma <ph name="USE_IE_SITELIST_POLICY_NAME" /> in <ph name="EXTERNAL_SITELIST_URL_POLICY_NAME" />.

      Če ta pravnik ni nastavljen, nobeno spletno mesto ni dodano na seznam.

      Če je ta pravilnik nastavljen, se vsak element obravnava kot pravilo za nekaj, kar naj se odpre v nadomestnem brskalniku. <ph name="PRODUCT_NAME" /> uporablja ta pravila pri izbiranju, ali naj se URL odpre v nadomestnem brskalniku.

      Če je nameščen in omogočen dodatek za Internet Explorer, Internet Explorer preklopi nazaj na <ph name="PRODUCT_NAME" />, če se pravila ne ujemajo.

      Če si pravila nasprotujejo, <ph name="PRODUCT_NAME" /> uporablja najbolj podrobno pravilo.</translation>
<translation id="5475361623548884387">Omogoči tiskanje</translation>
<translation id="547601067149622666">Ne dovoli oglasov na spletnih mestih z vsiljivimi oglasi</translation>
<translation id="5483065054530244863">Omogočanje potrdil, podpisanih z algoritmom SHA-1, ki jih izdajo lokalna sidra zaupanja</translation>
<translation id="5483777239978559943">Ta pravilnik je zastarel. Uporabite pravilnik <ph name="DEFAULT_PLUGINS_SETTING_POLICY_NAME" /> za nadziranje razpoložljivosti vtičnika za Flash in pravilnik <ph name="ALWAYS_OPEN_PDF_EXTERNALLY_POLICY_NAME" /> za nadziranje, ali je za odpiranje datotek PDF treba uporabiti vdelan pregledovalnik PDF-jev.

      Določa seznam vtičnikov, ki jih lahko uporabnik omogoči ali onemogoči v brskalniku <ph name="PRODUCT_NAME" />.

      Nadomestna znaka * in ? je mogoče uporabiti za nadomeščanje zaporedij poljubnih znakov. Znak * nadomešča poljubno število znakov, znak ? pa izbirni posamezen znak, tj. nadomešča nič znakov ali en znak. Ubežni znak je \; če torej želite nadomestiti dejanske znake *, ? ali \, lahko postavite prednje znak \.

      Če to nastavitev omogočite, je mogoče v brskalniku <ph name="PRODUCT_NAME" /> uporabiti določen seznam vtičnikov. Uporabniki jih lahko omogočijo ali onemogočijo na strani »about:plugins«, tudi če se vtičnik ujema z vzorcem v pravilniku »DisabledPlugins«. Uporabniki lahko omogočijo ali onemogočijo tudi vtičnike, ki se ne ujemajo z nobenim vzorcem na seznamih »DisabledPlugins«, »DisabledPluginsExceptions« in »EnabledPlugins«.

      Namen tega pravilnika je omogočiti strog seznam blokiranih vtičnikov, pri čemer so na seznamu »DisabledPlugins« vnosi z nadomestnimi znaki, na primer »onemogoči vse vtičnike» (*) ali »onemogoči vse vtičnike Java» (*Java*), vendar želi skrbnik omogočiti določeno različico, na primer »IcedTea Java 2.3«. Te različice je mogoče navesti v tem pravilniku.

      Ime vtičnika in skupinsko ime vtičnika morata biti izvzeta. Vsaka skupina vtičnikov je v polju »about:plugins« prikazana v ločenem razdelku; v vsakem razdelku je morda več vtičnikov. Vtičnik »Shockwave Flash« na primer spada v skupino »Adobe Flash Player« in obe imeni morata biti navedeni na seznamu izjem, če želite, da je ta vtičnik izvzet s seznama blokiranih vtičnikov.

      Če ta pravilnik ni nastavljen, bodo vsi vtičniki, ki se ujemajo z vzorci na seznamu »DisabledPlugins«, onemogočeni z zaklepanjem in uporabnik jih ne bo mogel omogočiti.</translation>
<translation id="5499375345075963939">Ta pravilnik je aktiven samo v maloprodajnem načinu.

      Ko je vrednost tega pravilnika nastavljena in ni 0, bo trenutno prijavljen uporabnik predstavitvenega načina samodejno odjavljen po določenem času nedejavnosti.

      Vrednost pravilnika mora biti v milisekundah.</translation>
<translation id="5508307164752647432">Omogočanje funkcije Kerberos</translation>
<translation id="5511702823008968136">Omogoči vrstico z zaznamki</translation>
<translation id="5512418063782665071">URL domače strani</translation>
<translation id="551639594034811656">Ta pravilnik opredeljuje seznam odstotkov, ki določajo delež naprav s sistemom <ph name="PRODUCT_OS_NAME" /> v organizacijski enoti, ki prejmejo posodobitev dnevno od dneva, ko je posodobitev prvič odkrita. Čas odkrivanja je poznejši od časa objave posodobitve, saj lahko po objavi posodobitve preteče nekaj časa, preden naprava preveri, ali je na voljo posodobitev.

      Vsak par (dan, odstotek) vsebuje odstotek opreme, ki mora biti posodobljena v danem številu dni po odkritju posodobitve. Če so na primer na voljo pari [(4, 40), (10, 70), (15, 100)], mora biti 40 % naprav posodobljenih v 4 dneh po odkritju posodobitve, 70 % naprav v 10 dneh po odkritju in tako naprej.

      Če je za ta pravilnik določena vrednost, posodobitve prezrejo pravilnik <ph name="DEVICE_UPDATE_SCATTER_FACTOR_POLICY_NAME" /> in upoštevajo ta pravilnik.

      Če je seznam prazen, ni postopnega nameščanja posodobitev in bodo posodobitve uveljavljene glede na druge pravilnike naprave.

      Ta pravilnik se ne uporablja pri preklapljanju med kanali.</translation>
<translation id="5526701598901867718">Vse (ni varno)</translation>
<translation id="5529037166721644841">Določa obdobje v milisekundah, po katerem se storitvi za upravljanje naprave pošlje poizvedba za podatke pravilnika naprave.

      Z nastavitvijo tega pravilnika se preglasi privzeta vrednost 3 ur. Veljavne vrednosti za ta pravilnik so med 1.800.000 (30 minut) in 86.400.000 (1 dan). Vrednosti, ki niso v tem obsegu, bodo spremenjene na ustrezno mejo obsega. 

      Če tega pravilnika ne nastavitev, bo brskalnik <ph name="PRODUCT_OS_NAME" /> uporabljal privzeto vrednost 3 ur.

      Če okolje podpira obvestila pravilnika, je zakasnitev osvežitve nastavljena na 24 ur (prezrejo se vse privzete nastavitve in vrednost tega pravilnika), ker je pričakovano, da obvestila pravilnika ob vsakokratni zamenjavi pravilnika samodejno vsilijo osvežitev, zaradi česar so pogostejše osvežitve nepotrebne.</translation>
<translation id="5530347722229944744">Blokiraj morebitne nevarne prenose</translation>
<translation id="5535973522252703021">Seznam dovoljenih delegacijskih strežnikov za Kerberos</translation>
<translation id="554903022911579950">Kerberos</translation>
<translation id="555077880566103058">Omogoči vsem spletnim mestom samodejno izvajanje vtičnika <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="5559079916187891399">Ta pravilnik ne vpliva na aplikacije za Android.</translation>
<translation id="5560039246134246593">Dodajanje parametra prejemanju semen različic v izdelku <ph name="PRODUCT_NAME" />.

      Če je pravilnik določen, se URL-ju za prenos semen različic doda parameter poizvedbe »restrict«. Vrednost parametra je vrednost, določena v tem pravilniku.

      Če pravilnik ni določen, se URL semen različic ne spremeni.</translation>
<translation id="5561811616825571914">Samodejni izbor potrdila odjemalcev za ta spletna mesta na zaslonu za prijavo</translation>
<translation id="5565178130821694365">Vnos gesla je obvezen vsaka dva dneva (48 ur)</translation>
<translation id="5566210228171064229">Omogočanje tiskanja s kodo PIN in brez nje</translation>
<translation id="556865034069957245">Ta pravilnik nadzira razpoložljivost celozaslonskega načina, v katerem je celoten uporabniški vmesnik za <ph name="PRODUCT_NAME" /> skrit in je vidna samo spletna vsebina.

      Če je ta pravilnik nastavljen na »true« ali ni nastavljen, lahko uporabnik, aplikacije in razširitve z ustreznimi dovoljenji preklopijo v celozaslonski način.

      Če je ta pravilnik nastavljen na »false«, uporabnik ter aplikacije in razširitve ne morejo preklopiti v celozaslonski način.

      V vseh okoljih, razen v sistemu <ph name="PRODUCT_OS_NAME" />, način kioska ni na voljo, ko je celozaslonski način onemogočen.</translation>
<translation id="556941986578702361">Nadzira samodejno skrivanje police v sistemu <ph name="PRODUCT_OS_NAME" />.

      Če je ta pravilnik nastavljen na »AlwaysAutoHideShelf«, se bo polica vedno samodejno skrila.

      Če je ta pravilnik nastavljen na »NeverAutoHideShelf«, se polica nikoli ne bo samodejno skrila.

      Če ta pravilnik nastavite, ga uporabniki ne morejo spremeniti ali preglasiti.

      Če tega pravilnika ne nastavite, lahko uporabniki izberejo, ali naj se polica samodejno skrije.</translation>
<translation id="557360560705413259">Če je ta nastavitev omogočena, bo <ph name="PRODUCT_NAME" /> uporabil commonName potrdila strežnika zaradi ujemanja z imenom gostitelja, če potrdilu manjka razširitev subjectAlternativeName in če so potrdila uspešno potrjena ter povezana s potrdili lokalno nameščenega overitelja.

      To ni priporočljivo, saj morda omogoča zaobidenje razširitve nameConstraints, ki omejuje imena gostiteljev, za katera je lahko odobreno določeno potrdilo.

      Če ta pravilnik ni nastavljen ali je onemogočen, potrdila strežnika, ki jim manjka razširitev subjectAlternativeName, ki vsebuje ime DNS-ja ali naslov IP, ne bodo zaupanja vredna.</translation>
<translation id="5581292529942108810">Konfiguriranje pravilnikov o razširitvi za poročanje za Chrome. 

      Ta pravilnik se uporablja samo, ko je omogočena razširitev <ph name="CHROME_REPORTING_EXTENSION_NAME" />, računalnik pa je včlanjen v pravilnik <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="5583806683960333345">Če je ta nastavitev omogočena, lahko uporabniki uporabljajo takojšnjo povezavo računalnika z internetom prek mobilnega telefona, s čimer lahko Googlov telefon deli prenos podatkov v mobilnem omrežju z napravo.

      Če je ta nastavitev onemogočena, uporabniki ne morejo uporabljati takojšnje povezave računalnika z internetom prek mobilnega telefona.

      Če ta pravilnik ni nastavljen, funkcija privzeto ni dovoljena za uporabnike, ki jih upravlja podjetje, in je dovoljena za uporabnike, ki niso upravljani.</translation>
<translation id="5584132346604748282">Nadziranje Googlovih lokacijskih storitev za Android</translation>
<translation id="5586942249556966598">Ne naredi nič</translation>
<translation id="5590494712401018042">Določa odstotek, za katerega se prilagodi zakasnitev zatemnitve zaslona, ko je naprava v predstavitvenem načinu.

          Če je ta pravilnik nastavljen, določa odstotek, za katerega se prilagodi zakasnitev zatemnitve zaslona, ko je naprava v predstavitvenem načinu. Če je zakasnitev zatemnitve zaslona prilagojena, se zakasnitev izklopa zaslona, zakasnitev zaklepanja zaslona in zakasnitev zaradi nedejavnosti prilagodijo tako, da ohranijo enako časovno razdaljo od zakasnitve zatemnitve zaslona, kot je bila sprva konfigurirana.

          Če ta pravilnik ni nastavljen, se uporabi privzeti faktor prilagoditve.

          Ta pravilnik ima vpliv samo, če je onemogočen pravilnik <ph name="POWER_SMART_DIM_ENABLED_POLICY_NAME" />. V nasprotnem primeru je pravilnik prezrt, ker zakasnitev zatemnitve zaslona določa model strojnega učenja.

          Faktor prilagoditve mora biti 100 % ali več. Vrednosti, zaradi katerih bi bila zakasnitev zatemnitve zaslona v predstavitvenem načinu krajša od običajne zakasnitve zatemnitve zaslona, niso dovoljene.</translation>
<translation id="5592242031005200087">
      Če je pravilnik omogočen, se bo vsak naveden izvor s
      seznama, ločenega z vejicami, izvajal v svojem procesu. S tem bodo osamljeni tudi
      izvori, ki jih navedejo poddomene; če na primer navedete https://example.com/,
      bo kot del spletnega mesta https://example.com/ osamljeno tudi spletno
      mesto https://foo.example.com/.
      Če je pravilnik onemogočen, ne pride do eksplicitne osamitve spletnih mest in preizkusi pravilnikov IsolateOriginsAndroid in SitePerProcessAndroid so onemogočeni. Uporabniki bodo še vedno lahko ročno omogočili pravilnik IsolateOrigins z zastavico ukazne vrstice.
      Če pravilnik ni konfiguriran, bo uporabnik to nastavitev lahko spremenil.

      OPOMBA: v Androidu je osamitev spletnih mest poskusna. Podpora se bo sčasoma izboljšala, vendar lahko v tem trenutku pride do težav pri delovanju.

      OPOMBA: ta pravilnik se uporablja samo za Chrome v Androidu v napravah, ki imajo več kot 1 GB RAM-a. Če želite pravilnik uporabljati v okoljih, ki niso Android, uporabite IsolateOrigins.
      </translation>
<translation id="5599461642204007579">Nastavitve upravljanja tega: <ph name="MS_AD_NAME" /></translation>
<translation id="5610104657949692379">Če je pravilnik nastavljen, določa dejanje, ki ga <ph name="PRODUCT_OS_NAME" /> izvede, če uporabnikova nedejavnost doseže trajanje časovnega zamika nedejavnosti, ki ga je mogoče konfigurirati posebej.

          Če pravilnik ni nastavljen, se izvede privzeto dejanje, tj. prekinitev.

          Če se izvede prekinitev, lahko <ph name="PRODUCT_OS_NAME" /> posebej konfigurirate, da pred prekinitvijo zaslon zaklene ali ne.</translation>
<translation id="5618398258385745432">Povezana nastavitev je bila uporabljena pred uvedbo vnovičnega preverjanja pristnosti ob ogledu gesel. Od takrat nastavitev in posledično ta pravilnik nimata nobenega vpliva na način delovanja Chroma. Trenuten način delovanja Chroma je zdaj enak, kot da bi bil pravilnik nastavljen tako, da onemogoča prikaz nešifriranih gesel na strani z nastavitvami upravitelja gesel. To pomeni, da je na strani z nastavitvami samo nadomestni znak in Chrome geslo prikaže šele, ko uporabnik klikne »Pokaži« (in po vnovičnem preverjanju pristnosti, če je treba). Izvirni opis pravilnika je spodaj.

          Določa, ali lahko uporabnik v upravitelju gesel pokaže nešifrirana gesla.

          Če to nastavitev onemogočite, upravitelj gesel ne dovoli prikaza shranjenih gesel v nešifrirani obliki v oknu upravitelja gesel.

          Če ta pravilnik omogočite ali ga ne nastavite, si lahko uporabniki v upravitelju gesel svoja gesla ogledajo v nešifrirani obliki.</translation>
<translation id="5620392548325769024">Omogočanje prikaza pozdravne strani ob prvem zagonu brskalnika po nadgradnji operacijskega sistema</translation>
<translation id="5630352020869108293">Obnovi zadnjo sejo</translation>
<translation id="5643906875497889108">Nadzira, katere vrste aplikacij/razširitev je dovoljeno namestiti, in omejuje dostop med izvajanjem.

          Ta nastavitev na seznam dovoljenih shrani vrste aplikacij/razširitev, ki jih je dovoljeno namestiti v izdelku <ph name="PRODUCT_NAME" /> in jih lahko gostitelji uporabljajo. Vrednost je seznam nizov, od katerih mora biti vsak nekaj od tega: »extension«, »theme«, »user_script«, »hosted_app«, »legacy_packaged_app«, »platform_app«. Več informacij o teh vrstah je v dokumentaciji razširitev za izdelek <ph name="PRODUCT_NAME" />.

          Upoštevajte, da ta pravilnik vpliva tudi na razširitve in aplikacije, ki bodo na silo nameščene prek pravilnika ExtensionInstallForcelist.

          Če je ta nastavitev konfigurirana, razširitve/aplikacije vrste, ki je ni na seznamu, ne bodo nameščene.

          Če te nastavitve ne konfigurirate, ne bodo uveljavljene nobene omejitve sprejemljivih vrst razširitev/aplikacij.

          Uporaba več ID-jev razširitev, ločenih z vejico, do različice 75 ni podprta in bo preskočena. Preostanek pravilnika se uporablja še naprej.</translation>
<translation id="5645779841392247734">Dovoli piškotke na teh mestih</translation>
<translation id="5689430183304951538">Privzeta velikost tiskanih strani</translation>
<translation id="5693469654327063861">Dovoljevanje selitve podatkov</translation>
<translation id="5694594914843889579">Ko je ta pravilnik omogočen, zunanji pomnilnik ne bo na voljo za datotečni brskalnik.

      Ta pravilnik se uporablja za vse vrste nosilcev podatkov, kot so bliskovni pogoni USB, zunanji trdi diski, kartice SD in druge pomnilniške kartice, optični nosilci podatkov ipd. Na notranji pomnilnik to ne vpliva, zato je do datotek, shranjenih v mapi »Prenosi«, še vedno mogoče dostopati. Ta pravilnik prav tako ne vpliva na Google Drive.

      Če je ta nastavitev onemogočena ali ni nastavljena, lahko uporabniki v svoji napravi uporabljajo vse podprte oblike zunanjega pomnilnika.</translation>
<translation id="5697306356229823047">Poročanje o uporabnikih naprave</translation>
<translation id="5699487516670033016">Določa življenjsko dobo predpomnjenja (v urah) podatkov za preverjanje pristnosti. Predpomnilnik se uporablja za pospešitev prijave. Vsebuje splošne podatke (ime delovne skupine ipd.) o povezanih sferah, torej sferah, ki jim zaupa računalniška sfera. Podatki o določenih uporabnikih in podatki o nepovezanih sferah se ne predpomnijo. Z vnovičnim zagonom naprave se predpomnilnik izbriše.

      Če pravilnik ni nastavljen, je mogoče podatke za preverjanje pristnosti znova uporabiti v obdobju do 73 ur.

      Če je pravilnik nastavljen na 0, je predpomnjenje podatkov za preverjanje pristnosti izklopljeno. S tem se lahko bistveno upočasni prijava povezanih uporabnikov, saj je treba ob vsaki prijavi prenesti podatke za posamezno sfero.

      Upoštevajte, da so podatki o sferi predpomnjeni tudi za kratkotrajne uporabnike. Predpomnilnik je treba izklopiti, če je treba preprečiti sledenje kratkotrajnim uporabnikom.</translation>
<translation id="570062449808736508">Če je ta pravilnik nastavljen na niz, ki ni prazen, spletni pogled prebere omejitve za URL-je ponudnika vsebine z danim imenom overitelja.</translation>
<translation id="5701714006401683963">Če je ta pravilnik onemogočen, bo upravljana seja gosta delovala, kot je opisano na https://support.google.com/chrome/a/answer/3017014 – standardna »javna seja«.

      Če je ta pravilnik omogočen ali ni nastavljen, bo upravljana seja gosta prevzela delovanje »upravljane seje«, ki odpravlja številne omejitve, ki veljajo za običajne »javne seje«.

      Če je ta pravilnik nastavljen, ga uporabniki ne morejo spremeniti ali preglasiti.</translation>
<translation id="5708969689202733975">Konfiguriranje dovoljenih načinov hitrega odklepanja</translation>
<translation id="5711016543513883877">
      Če je pravilnik omogočen, se bo vsak naveden izvor s
      seznama, ločenega z vejicami, izvajal v svojem procesu. S tem bodo osamljeni tudi
      izvori, ki jih navedejo poddomene; če na primer navedete https://example.com/, bo
      kot del spletnega mesta https://example.com/ osamljeno tudi spletno mesto
      https://foo.example.com/.
      Če pravilnik ni konfiguriran ali je onemogočen, bo uporabnik lahko spremenil to nastavitev.

      OPOMBA: Ta pravilnik se ne uporablja v sistemu Android. Če želite omogočiti pravilnik IsolateOrigins v Androida, uporabite nastavitev pravilnika IsolateOriginsAndroid.
      </translation>
<translation id="572155275267014074">Nastavitve za Android</translation>
<translation id="5722934961007828462">Ko je omogočena ta nastavitev, <ph name="PRODUCT_NAME" /> vedno izvede preverjanje preklica strežniških potrdil, ki se uspešno potrdijo in so podpisana s potrdili lokalno nameščenega overitelja.

      Če <ph name="PRODUCT_NAME" /> ne more dobiti podatkov o stanju preklica, se taka potrdila obravnavajo kot preklicana (»hard-fail«).

      Če ta pravilnik ni nastavljen ali je nastavljen na »false«, bo <ph name="PRODUCT_NAME" /> uporabil obstoječe nastavitve za preverjanje preklica v spletu.</translation>
<translation id="5728154254076636808">Omogočanje ustvarjanja kopij podatkov profila izdelka <ph name="PRODUCT_NAME" /> za gostovanje</translation>
<translation id="5732972008943405952">Uvoz podatkov za samodejno izpolnjevanje obrazcev iz privzetega brskalnika ob prvem zagonu</translation>
<translation id="5741810844420698449">Če je pravilnik nastavljen, določa dejanje, ki ga <ph name="PRODUCT_OS_NAME" /> izvede, ko uporabnik zapre pokrov naprave.

          Če pravilnik ni nastavljen, se izvede privzeto dejanje, tj. prekinitev.

          Če se izvede prekinitev, lahko <ph name="PRODUCT_OS_NAME" /> posebej konfigurirate, da pred prekinitvijo zaslon zaklene ali ne.</translation>
<translation id="5765780083710877561">Opis:</translation>
<translation id="5770738360657678870">Različica za razvijalce (lahko je nestabilna)</translation>
<translation id="5774856474228476867">Privzeti URL iskalnika za iskanje</translation>
<translation id="5775235485119094648">Napolnite akumulator, dokler je v bližini fiksni priključek.</translation>
<translation id="5776485039795852974">Vprašaj me vsakič, ko želi mesto pokazati namizna obvestila</translation>
<translation id="5781412041848781654">Določa, katera knjižnica GSSAPI bo uporabljena za preverjanje pristnosti HTTP. Nastavite lahko samo ime knjižnice ali celotno pot.

          Če ni določena nobena nastavitev, <ph name="PRODUCT_NAME" /> uporabi privzeto ime knjižnice.</translation>
<translation id="5781806558783210276">Določa trajanje uporabnikove nedejavnosti, po preteku katere se izvede dejanje ob nedejavnosti, če se naprava napaja iz električnega omrežja.

          Če je pravilnik nastavljen, določa, koliko časa mora biti uporabnik nedejaven, preden <ph name="PRODUCT_OS_NAME" /> izvede dejanje ob nedejavnosti, ki ga je mogoče konfigurirati posebej.

          Če pravilnik ni nastavljen, velja privzeto trajanje.

          Vrednost pravilnika naj bo navedena v milisekundah.</translation>
<translation id="5783009211970309878">Tiskanje glav in nog</translation>
<translation id="5809210507920527553">Nadzira nastavitve za vsebnik za Linux (Crostini).</translation>
<translation id="5809728392451418079">Nastavljanje prikaznega imena za lokalne račune za napravo</translation>
<translation id="5814301096961727113">Nastavitev privzetega stanja glasovnih povratnih informacij načina na prijavnem zaslonu</translation>
<translation id="5815129011704381141">Samodejni vnovični zagon po posodobitvi</translation>
<translation id="5815353477778354428">Konfigurira imenik, ki ga bo <ph name="PRODUCT_FRAME_NAME" /> uporabljal za shranjevanje uporabniških podatkov.

      Če ta pravilnik nastavite, bo <ph name="PRODUCT_FRAME_NAME" /> uporabil navedeni imenik.

      Seznam spremenljivk, ki jih je mogoče uporabiti, si lahko ogledate na http://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Če te nastavitve ne določite, bo uporabljen privzeti imenik profila.</translation>
<translation id="5826047473100157858">Določa, ali lahko uporabnik v brskalniku <ph name="PRODUCT_NAME" /> odpre strani v načinu brez beleženja zgodovine.

      Če je izbrano »Omogočeno« ali pravilnik ni nastavljen, je strani mogoče odpirati v načinu brez beleženja zgodovine.

      Če je izbrano »Onemogočeno«, strani ni mogoče odpirati v načinu brez beleženja zgodovine.

      Če je izbrano »Vsiljeno«, je mogoče strani odpirati SAMO v načinu brez beleženja zgodovine.</translation>
<translation id="582857022372205358">Omogočanje obojestranskega tiskanja s kratkim robom</translation>
<translation id="583091600226586337">
      Če je pravilnik omogočen, bo uporabnik pred vsakim prenosom pozvan, da določi, kje naj bo shranjena datoteka.
      Če je pravilnik onemogočen, se bodo prenosi začeli takoj, uporabnik pa ne bo pozvan, da določi, kje naj bo datoteka shranjena.
      Če pravilnik ni konfiguriran, bo uporabnik to nastavitev lahko spremenil.
      </translation>
<translation id="5832274826894536455">Zastareli pravilniki</translation>
<translation id="5835124959204887277">Določa URL-je in domene, za katere ne bo prikazan poziv, ko so iz varnostnih ključev zahtevana potrditvena potrdila. Poleg tega bo varnostnemu ključu poslan signal, da je posamezno potrditev mogoče uporabiti. Brez tega bo v Chromu 65 in novejših različicah uporabnikom prikazan poziv, ko spletna mesta zahtevajo potrditev varnostnih ključev.

      URL-ji (npr. https://example.com/neka/pot) se bodo ujemali samo kot appID-ji U2F. Domene (npr. example.com) se ujemajo samo kot ID-ji za webauthn RP. Če želite, da so za določeno mesto obravnavani tako API-ji za U2F kot za webauthn, je torej treba navesti URL za appID in domeno.</translation>
<translation id="5836064773277134605">Omeji obseg vrat UDP, ki jih uporablja gostitelj oddaljenega dostopa</translation>
<translation id="5861856285460256766">Konfiguriranje kode za starševski dostop</translation>
<translation id="5862253018042179045">Nastavitev privzetega stanja funkcije izgovorjave za ljudi s posebnimi potrebami na prijavnem zaslonu.

          Če ta pravilnik vklopite, bo na prijavnem zaslonu omogočena izgovorjava.

          Če ta pravilnik izklopite, bo na prijavnem zaslonu onemogočena izgovorjava.

          Če ta pravilnik nastavite, ga lahko uporabniki začasno preglasijo tako, da omogočijo ali onemogočijo izgovorjavo, vendar ta nastavitev ni trajna in privzeta nastavitev se obnovi vsakič, ko je ponovno prikazan prijavni zaslon ali kadar je uporabnik eno minuto nedejaven na prijavnem zaslonu.

          Če pravilnika ne nastavite, je izgovorjava onemogočena, ko je prvič prikazan prijavni zaslon. Uporabniki lahko kadar koli omogočijo ali onemogočijo izgovorjavo, pri čemer se njeno stanje na prijavnem zaslonu ohrani med uporabniki.</translation>
<translation id="5868414965372171132">Konfiguracija omrežja na ravni uporabnika</translation>
<translation id="5879014913445067283">Nadzira odkrivanje omrežnih datotečnih sredstev v skupni rabi prek protokola <ph name="NETBIOS_NAME" /></translation>
<translation id="5882345429632338713">Zakasnitev pred zagonom nadomestnega brskalnika (milisekunde)</translation>
<translation id="5883015257301027298">Privzeta nastavitev piškotkov</translation>
<translation id="5887414688706570295">Nastavi predpono »TalkGadget«, ki jo bodo uporabljali gostitelji oddaljenega dostopa, in prepreči uporabnikom njeno spreminjanje.

          Če je ta predpona določena, je dodana pred osnovno ime »TalkGadget«, tako da ustvari polno ime domene za »TalkGadget«. Osnovno ime domene »TalkGadget« je ».talkgadget.google.com«.

          Če je ta nastavitev omogočena, bodo gostitelji pri dostopu do domene »TalkGadget« namesto privzetega imena domene uporabljali prilagojeno ime domene.

          Če je ta nastavitev onemogočena ali ni nastavljena, bo privzeto ime domene za »TalkGadget« (»chromoting-host.talkgadget.google.com«) uporabljeno za vse gostitelje.

          Na odjemalce za oddaljen dostop ta nastavitev pravilnika ne vpliva. Ti bodo za dostop do domene »TalkGadget« vedno uporabljali »chromoting-client.talkgadget.google.com«.</translation>
<translation id="5893553533827140852">Če je ta nastavitev omogočena, bodo zahteve za preverjanje pristnosti »gnubby« posredovane prek povezave z oddaljenim gostiteljem.

          Če je ta nastavitev onemogočena ali ni konfigurirana, zahteve za preverjanje pristnosti »gnubby« ne bodo posredovane.</translation>
<translation id="5897913798715600338">Polnjenje akumulatorja s tehnologijo hitrega polnjenja.</translation>
<translation id="5898486742390981550">Če je prijavljenih več uporabnikov, lahko aplikacije za Android uporablja samo primarni uporabnik.</translation>
<translation id="5901427587865226597">Samo obojestransko tiskanje</translation>
<translation id="5903898512448364160">
      Če je pravilnik nastavljen na »true«, ima v primeru spora s pravilnikom okolja prednost pravilnik oblaka.
      Če je pravilnik nastavljen na »false« ali ni nastavljen, ima v primeru spora s pravilnikom o oblaku prednost pravilnik o okolju.

      Ta pravilnik je na voljo samo kot obvezni pravilnik o okolju naprave in vpliva samo na pravilnike oblaka v obsegu naprave.
      </translation>
<translation id="5905473632148429217">Omogočanje spletnih preverjanj OCSP/CRL</translation>
<translation id="5906199912611534122">Omogoča omogočanje ali onemogočanje omejevanja omrežja.
      Ta pravilnik se uporabi za vse uporabnike in vse vmesnike v napravi. Ko je nastavljen,
      je omejevanje v rabi, dokler se ne onemogoči s spremembo pravilnika.

      Če je pravilnik onemogočen, se omrežje ne omejuje.
      Če je pravilnik omogočen, se sistem omejuje, da doseže navedeni hitrosti nalaganja in prenašanja (v KB/s).</translation>
<translation id="591088232153082363">Prilagodljivo polnjenje akumulatorja na podlagi vzorca uporabe akumulatorja.</translation>
<translation id="5921713479449475707">Dovoli samoposodobitvene prenose prek HTTP</translation>
<translation id="5921888683953999946">Nastavitev privzetega stanja funkcije velikega kazalca za ljudi s posebnimi potrebami na prijavnem zaslonu.

          Če ta pravilnik vklopite, bo na prijavnem zaslonu omogočen prikaz velikega kazalca.

          Če ga izklopite, bo na prijavnem zaslonu onemogočen prikaz velikega kazalca.

          Če pravilnik nastavite, ga lahko uporabniki začasno preglasijo tako, da omogočijo ali onemogočijo velik kazalec, vendar ta nastavitev ni trajna, pri čemer se privzeta nastavitev obnovi vsakič, ko je ponovno prikazan prijavni zaslon ali kadar je uporabnik eno minuto nedejaven na prijavnem zaslonu.

          Če pravilnika ne nastavite, je velik kazalec onemogočen, ko je prvič prikazan prijavni zaslon. Uporabniki lahko kadar koli omogočijo ali onemogočijo velik kazalec, pri čemer se njegovo stanje na prijavnem zaslonu ohrani med uporabniki.</translation>
<translation id="5929855945144989709">V napravah je dovoljeno izvajanje navideznih računalnikov v sistemu OS Chrome</translation>
<translation id="5932767795525445337">Ta pravilnik je prav tako mogoče uporabiti za pripenjanje aplikacij za Android.</translation>
<translation id="5936622343001856595">Uveljavi izvajanje poizvedb v Google Spletnem iskanju z aktiviranim Google Varnim iskanjem in uporabnikom prepreči spreminjanje te nastavitve.

      Če to nastavitev omogočite, je Google Varno iskanje v Iskanju Google vedno aktivno.

      Če to nastavitev onemogočite ali ne nastavite vrednosti, Google Varno iskanje v Iskanju Google ni uveljavljeno.</translation>
<translation id="5946082169633555022">Preskusna različica</translation>
<translation id="5946329690214660966">Nastavitev razporeda po meri za preverjanje, ali so na voljo posodobitve</translation>
<translation id="5950205771952201658">Ker mehko preverjanje preklica ne zagotavlja dodatne varnosti, je v brskalniku <ph name="PRODUCT_NAME" /> različice 19 ali novejšem privzeto onemogočeno. Če ta pravilnik nastavite na »true«, se obnovijo prejšnje nastavitve in se izvajajo spletna preverjanja OCSP/CRL.

      Če pravilnik ni nastavljen ali je nastavljen na »false«, <ph name="PRODUCT_NAME" /> v različici <ph name="PRODUCT_NAME" /> 19 ali novejši ne bo izvajal spletnega pregleda preklica.</translation>
<translation id="5961137303188584693">V napravi vgrajen naslov NIC MAC</translation>
<translation id="5966615072639944554">Razširitve, ki lahko uporabljajo API za oddaljeno potrditev</translation>
<translation id="5983708779415553259">Privzeto delovanje za spletna mesta, ki niso v nobenem paketu vsebine</translation>
<translation id="5997543603646547632">Privzeto uporabi 24-urni čas</translation>
<translation id="5997846976342452720">Določanje, ali naj bo iskalnik vtičnikov onemogočen (zastarelo)</translation>
<translation id="6017568866726630990">Namesto predogleda tiskanja prikaže sistemsko pogovorno okno za tiskanje.

      Če je ta nastavitev omogočena, <ph name="PRODUCT_NAME" /> pri uporabnikovi zahtevi za tiskanje strani namesto vgrajenega predogleda tiskanja odpre sistemsko pogovorno okno za tiskanje.

      Če ta pravilnik ni nastavljen ali je nastavljen na »false«, ukazi za tiskanje sprožijo zaslon za predogled tiskanja.</translation>
<translation id="6022948604095165524">Dejanje ob zagonu</translation>
<translation id="602728333950205286">Privzeti URL iskalnika za dinamično iskanje</translation>
<translation id="603410445099326293">Parametri za URL predloga, ki uporablja POST</translation>
<translation id="6034341625190551415">Nadzira vrste računov za javne seje in kiosk.</translation>
<translation id="6034603289689965535">Strani med razkladanjem dovoli prikazovanje pojavnih oken</translation>
<translation id="6036523166753287175">Omogoči prehod skozi požarni zid iz gostitelja za oddaljeni dostop</translation>
<translation id="605475635122964053">Omejuje način tiskanja s kodo PIN. Če pravilnik ni nastavljen, ni omejitve. Če način ni na voljo, je ta pravilnik prezrt. Upoštevajte, da je funkcija tiskanja s kodo PIN omogočena samo za tiskalnike, ki uporabljajo enega od teh protokolov: IPPS, USB ali IPP prek USB-ja </translation>
<translation id="6070667616071269965">Postavitve tipkovnice na zaslonu za prijavo v napravi</translation>
<translation id="6074963268421707432">Nobenemu spletnemu mestu ne dovoli, da pokaže namizna obvestila</translation>
<translation id="6074964551275531965">Nastavitev časovnega obdobja za obvestila o posodobitvah</translation>
<translation id="6076099373507468537">Določa seznam naprav USB, za katere je dovoljena prekinitev povezave z gonilnikom jedra zaradi uporabe prek API-ja chrome.usb neposredno v spletni aplikaciji. Vnosi so pari, ki so sestavljeni iz identifikatorja proizvajalca za USB in identifikatorja izdelka ter ki omogočajo prepoznavo posamezne strojne opreme.

      Če ta pravilnik ni nastavljen, je seznam naprav USB, katerih povezavo je mogoče prekiniti, prazen.</translation>
<translation id="6083631234867522991">Windows (odjemalci s sistemom Windows):</translation>
<translation id="608788685013546076">Nastavitev praga za funkcijo preklopa na akumulatorsko napajanje ob konicah v odstotkih</translation>
<translation id="6089679180657323464">Nadzira nastavitve diagnostične storitve wilco in kontrolnika telemetrije.</translation>
<translation id="6091233616732024397">Vsiljenje prijave uporabnikom, če želijo uporabljati brskalnik</translation>
<translation id="6093156968240188330">Omogoči oddaljenim uporabnikom uporabo oken s skrbniškimi pravicami v sejah oddaljene pomoči</translation>
<translation id="6095999036251797924">Določi trajanje uporabnikove nedejavnosti, po preteku katere se zaslon zaklene, če se napaja iz električnega omrežja ali akumulatorja.

          Če je trajanje nedejavnosti nastavljeno na vrednost, večjo od nič, izraža ta vrednost čas nedejavnosti uporabnika, preden <ph name="PRODUCT_OS_NAME" /> zaklene zaslon.

          Če je trajanje nedejavnosti nastavljeno na nič, <ph name="PRODUCT_OS_NAME" /> ne zaklene zaslona, ko uporabnik postane nedejaven.

          Če trajanje nedejavnosti ni nastavljeno, se uporabi privzeto trajanje.

          Priporočljivo je, da za zaklep zaslona ob nedejavnosti omogočite zaklepanje ob prekinitvi, da se <ph name="PRODUCT_OS_NAME" /> prekine po preteku zakasnitve zaradi nedejavnosti. Ta pravilnik uporabite samo, če želite, da se zaslon zaklene bistveno prej pred prekinitvijo, ali če ne želite prekinitve ob nedejavnosti.

          Vrednost pravilnika naj bo navedena v milisekundah. Vrednosti morajo biti manjše od zakasnitve zaradi nedejavnosti.</translation>
<translation id="6097601282776163274">Omogočanje zbiranja anonimiziranih podatkov, ki vključujejo URL-je</translation>
<translation id="6099853574908182288">Privzeti barvni način tiskanja</translation>
<translation id="6107642964266628393">Nadzira, kako in kdaj se uporabijo posodobitve OS Chroma.</translation>
<translation id="6111936128861357925">Dovoli skrito igro z dinozavrom</translation>
<translation id="6114416803310251055">zastarelo</translation>
<translation id="6133088669883929098">Vsem spletnim mestom dovoli uporabo ustvarjanja ključev</translation>
<translation id="6136537398661737682">Ta pravilnik nadzira začetno stanje Googlovih lokacijskih storitev.

      Če ta pravilnik ni konfiguriran ali je nastavljen na <ph name="GLS_DISABLED" />, so Googlove lokacijske storitve sprva onemogočene.

      Če je ta pravilnik nastavljen na <ph name="GLS_ENABLED" />, so Googlove lokacijske storitve sprva omogočene.

      Če je ta pravilnik nastavljen na <ph name="GLS_UNDER_USER_CONTROL" />, je uporabnik pozvan, naj izbere, ali želi uporabljati Googlove lokacijske storitve. To bo aplikacijam za Android omogočilo uporabo storitev za poizvedovanje glede lokacije naprave in jim bo prav tako omogočilo pošiljanje anonimnih podatkov o lokaciji Googlu.

      Upoštevajte, da ta pravilnik nadzira stanje Googlovih lokacijskih storitev samo med začetno nastavitvijo. Uporabnik lahko pozneje odpre nastavitve za Android in vklopi/izklopi Googlove lokacijske storitve.

      Upoštevajte, da je ta pravilnik prezrt in Googlove lokacijske storitve so vedno onemogočene, če je pravilnik <ph name="DEFAULT_GEOLOCATION_SETTING_POLICY_NAME" /> nastavljen na <ph name="BLOCK_GEOLOCATION_SETTING" />.</translation>
<translation id="6141402445226505817">Vedno uporabi nenatančno zaznavanje časovnega pasu</translation>
<translation id="6145799962557135888">Omogoča nastavitev seznama vzorcev URL-jev, s katerim so določena mesta, ki smejo izvajati JavaScript.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena splošna privzeta vrednost iz pravilnika »DefaultJavaScriptSetting«, kadar je ta nastavljen, ali iz uporabnikove osebne konfiguracije, kadar pravilnik »DefaultImagesSetting« ni nastavljen.</translation>
<translation id="614662973812186053">Ta pravilnik prav tako nadzira zbiranje podatkov o uporabi sistema Android in diagnostičnih podatkov zanj.</translation>
<translation id="6153048425064249648">Ta pravilnik nadzira poročanje v oblaku brskalnika <ph name="PRODUCT_NAME" />, ki podatke o delovanju brskalnika nalaga v konzolo Google Admin console.

      Če ta pravilnik ni nastavljen ali je onemogočen, se podatki ne zbirajo ali nalagajo.
      Če je ta pravilnik omogočen, se podatki zbirajo in nalagajo v konzolo Google Admin console.
      Če želite nadzirati, kateri podatki se nalagajo, uporabite pravilnike v razširitvi Poročanje za Chrome za skupine.

      Ta pravilnik se uporablja samo, če je računalnik včlanjen v pravilnik <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.

      Ta pravilnik vsili nastavitev razširitve <ph name="CHROME_REPORTING_EXTENSION_NAME" /> za poročanje in preglasi vse pravilnike za razširitve, ki se nanašajo na to razširitev.</translation>
<translation id="6155247658847899816">Ko je nastavljen ta pravilnik, sta ločljivost in faktor povečave za vsak
      zaslon nastavljena na navedene vrednosti. Nastavitve za zunanji zaslon se 
      uporabijo za vse priključene zunanje zaslone.

      Vrednosti za »external_width« in »external_height« morata biti navedeni
      v slikovnih pikah. Vrednosti za »external_scale_percentage« in
      »internal_scale_percentage« morata biti navedeni v odstotkih.

      Če je nastavitev »external_use_native« omogočena«, bo pravilnik prezrl
      vrednosti za »external_height« in »external_width« in ločljivost zunanjih zaslonov 
      nastavil na njihovo izvorno ločljivost.

      Če je nastavitev »external_use_native« onemogočena ali ni navedena in
      ni navedena vrednost za »external_height« ali »external_width«, pravilnik ne
      vpliva na nastavitve zunanjega zaslona. Če kateri od zaslonov ne podpira
      navedene ločljivosti ali faktorja povečave, se pravilnik zanje ne uporabi.

      Če je zastavica »recommended« omogočena, lahko uporabniki
      po prijavi spremenijo ločljivost in faktor povečave poljubnega zaslona na strani z
      nastavitvami, vendar bodo njihove nastavitve ob naslednjem vnovičnem
      zagonu preglašene z vrednostjo pravilnika. Če je zastavica »recommended«
      onemogočena« ali ni nastavljena, uporabniki ne morejo spreminjati nastavitev
      zaslona.</translation>
<translation id="6155936611791017817">Nastavitev privzetega stanja velikega kazalca na prijavnem zaslonu</translation>
<translation id="6157537876488211233">Seznam pravil za obvod proxyja, ločenih z vejico</translation>
<translation id="6158324314836466367">Ime spletne trgovine podjetja (zastarelo)</translation>
<translation id="6158817306788002298">Tukaj lahko določite URL datoteke .pac za proxy.

          Ta pravilnik velja le, če ste v »Izberite, kako določiti nastavitve strežnika proxy« izbrali ročne nastavitve strežnika proxy in če pravilnik <ph name="PROXY_SETTINGS_POLICY_NAME" /> ni bil določen.

          Če ste za nastavitve pravilnikov za strežnik proxy izbrali drug način, tega pravilnika ne nastavljajte.

          Podrobne primere si lahko ogledate tukaj:
          <ph name="PROXY_HELP_URL" />.</translation>
<translation id="6178075938488052838">Ta pravilnik nadzira, kdo lahko začne sejo sistema <ph name="PRODUCT_OS_NAME" />. Uporabnikom ne preprečuje prijave v dodatne račune za Google znotraj Androida. Če želite to preprečiti, konfigurirajte pravilnik za Android <ph name="ACCOUNT_TYPES_WITH_MANAGEMENT_DISABLED_CLOUDDPC_POLICY_NAME" /> kot del pravilnika <ph name="ARC_POLICY_POLICY_NAME" />.</translation>
<translation id="6181608880636987460">Omogoča nastavitev seznama vzorcev URL-jev, ki določa, katerim spletnim mestom je onemogočeno izvajanje vtičnika <ph name="FLASH_PLUGIN_NAME" />.

          Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi globalna privzeta vrednost iz pravilnika »DefaultPluginsSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.</translation>
<translation id="6190022522129724693">Privzeta nastavitev pojavnih oken</translation>
<translation id="6190367314942602985">Sporočanje podatkov, s katerimi je mogoče prepoznati uporabnike</translation>
<translation id="6197453924249895891">Razširitvam odobri dostop do ključev podjetja.

      Ključi so namenjeni rabi v podjetju, če so ustvarjeni z API-jem chrome.platformKeys API v upravljanem računu. Uvoženi ali kako drugače ustvarjeni ključi niso namenjeni za rabo v podjetju.

      Dostop do ključev, namenjenih za rabo v podjetju, nadzira izključno ta pravilnik. Uporabnik razširitvam ne more odobriti dostopa do ključev podjetja ali jim preklicati dostopa do njih.

      Razširitev privzeto ne more uporabljati ključa, namenjenega rabi v podjetju, kar je enakovredno onemogočanju pravilnika allowCorporateKeyUsage za to razširitev.

      Samo če je pravilnik allowCorporateKeyUsage za razširitev omogočen, lahko ta uporablja kateri koli ključ okolja, označen za rabo v podjetju, za podpisovanje poljubnih podatkov. To dovoljenje odobrite samo, če ste prepričani, da razširitev lahko zaščiti dostop do ključa pred napadalci.</translation>
<translation id="6208896993204286313">Sporočanje podatkov pravilnika za <ph name="PRODUCT_NAME" /></translation>
<translation id="6210259502936598222">Sporočanje podatkov o operacijskem sistemu in različici brskalnika <ph name="PRODUCT_NAME" /></translation>
<translation id="6210610748361191729">Če je pravilnik nastavljen na »false«, uporabniški vmesnik za uvoz/izvoz uporabnikom ne bo na voljo, še vedno pa bo mogoče izvoziti in uvoziti slike vsebnikov neposredno v navideznem računalniku z ukazi »lxc«.</translation>
<translation id="6211428344788340116">Poročanje o času dejavnosti v napravi.

      Če nastavitev ni nastavljena ali je nastavljena na »True«, včlanjene naprave poročajo o času, ko je uporabnik aktiven v napravi. Če je nastavitev nastavljena na »False«, se čas dejavnosti v napravi ne beleži in se o njem ne poroča.</translation>
<translation id="6212868225782276239">Prikazani so vsi tiskalniki razen tistih na seznamu prepovedanih.</translation>
<translation id="6219965209794245435">Če je ta pravilnik omogočen, se podatki za samodejno izpolnjevanje obrazcev uvozijo iz prejšnjega privzetega brskalnika. Če je pravilnik omogočen, vpliva tudi na pogovorno okno za uvoz.

      Če je onemogočen, podatki za samodejno izpolnjevanje obrazcev niso uvoženi.

      Če ni nastavljen, bo imel uporabnik morda na voljo možnost izbire uvoza ali pa bo uvoz izveden samodejno.</translation>
<translation id="6221175752766085998">Omogočanje potrdil, ki jih izdajo lokalna sidra zaupanja, brez razširitve subjectAlternativeName</translation>
<translation id="6224304369267200483">URL-ji/domene, ki jim je samodejno dovoljena neposredna potrditev varnostnih ključev</translation>
<translation id="6233173491898450179">Določi imenik za prenos v računalnik</translation>
<translation id="6244210204546589761">URL-ji, ki naj se odprejo ob zagonu</translation>
<translation id="6255387031094435995">Omogoča, da se izbrani pravilniki združijo, če izvirajo iz različnih virov, vendar so enakih obsegov in ravni.

        Če je pravilnik na seznamu, bodo v primeru spora med viroma, če sta enakih obsegov in ravni, vrednosti združene na novem seznamu pravilnikov.

        Če je pravilnik na seznamu, bo v primeru spora med viroma, ki sta tudi različnih obsegov in/ali ravni, uporabljen pravilnik z največjo prednostjo.

        Če pravilnika ni na seznamu, bo v primeru spora med viroma, obsegi in/ali ravnijo uporabljen pravilnik z največjo prednostjo.</translation>
<translation id="6258193603492867656">Določa, ali naj ustvarjen SPN za Kerberos SPN vključuje nestandardna vrata.

         Če to nastavitev omogočite in so vnesena nestandardna vrata (vrata, ki niso 80 ali 443), bodo vključena v ustvarjeni SPN za Kerberos.

          Če to nastavitev onemogočite ali je ne nastavite, ustvarjeni SPN za Kerberos v nobenem primeru ne bo vključeval vrat.</translation>
<translation id="6261643884958898336">Sporočanje podatkov, s katerimi je mogoče prepoznati napravo</translation>
<translation id="6281043242780654992">Konfigurira pravilnike za izvorno pošiljanje sporočil. Gostitelji izvornega pošiljanja sporočil s seznama blokiranih ne bodo dovoljeni, razen če bodo uvrščeni na seznam dovoljenih.</translation>
<translation id="6282799760374509080">Omogočanje ali onemogočanje snemanja zvoka</translation>
<translation id="6284362063448764300">TLS 1.1</translation>
<translation id="6310223829319187614">Omogočanje samodokončanja imena domene med prijavo uporabnika</translation>
<translation id="6315673513957120120">Chrome prikaže opozorilno stran, ko uporabniki prikrmarijo na spletna mesta, na katerih so napake SSL. Uporabnikom je privzeto (ali če je ta pravilnik omogočen) dovoljeno, da s klikom opustijo te strani z opozorilom.
      Če onemogočite ta pravilnik, uporabnikom ni dovoljeno s klikom opustiti katere koli strani z opozorilom.</translation>
<translation id="6319198883324703402">Nastavite čas prvega obvestila uporabniku glede vnovičnega zagona</translation>
<translation id="6352543686437322588">Lokalni račun v napravi za samodejno prijavo po zakasnitvi.

      Če je ta pravilnik nastavljen, bo po preteku določenega časa nedejavnosti uporabnika na zaslonu za prijavo določena seja prijavljena samodejno. Lokalni račun v napravi mora že biti konfiguriran (glejte |DeviceLocalAccounts|).

      Če ta pravilnik ni nastavljen, ni samodejne prijave.</translation>
<translation id="6353901068939575220">Določa parametre, uporabljene pri iskanju URL-ja z metodo POST. Sestavljena je iz parov ime/vrednost, ločenih z vejico. Če je vrednost parameter predloge, kot je v zgornjih primerih {searchTerms}, bo zamenjana s pravimi podatki iskalnih izrazov.

          Ta pravilnik je izbiren. Če ni nastavljen, bo zahteva za iskanje poslana z metodo GET.

          Ta pravilnik se upošteva samo, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="6368011194414932347">Konfiguracija URL-ja domače strani</translation>
<translation id="6368403635025849609">Dovoli JavaScript na teh mestih</translation>
<translation id="6376659517206731212">Lahko je obvezno</translation>
<translation id="6377355597423503887">Ta pravilnik je zastarel, namesto njega lahko uporabite BrowserSignin.

      Dovoljuje uporabniku prijavo v brskalnik <ph name="PRODUCT_NAME" />.

      Če nastavite ta pravilnik, lahko določite, ali je uporabniku dovoljena prijava v brskalnik <ph name="PRODUCT_NAME" />. Če ta pravilnik onemogočite, ne bodo delovale aplikacije in razširitve, ki uporabljajo API chrome.identity, zato morda namesto njega raje uporabite SyncDisabled.</translation>
<translation id="6378076389057087301">Navedite, ali zvočna dejavnost vpliva na upravljanje napajanja</translation>
<translation id="637934607141010488">Poročanje o seznamu nedavno prijavljenih uporabnikov naprave.

      Če je pravilnik nastavljen nastavljen na »False«, se o uporabnikih ne poroča.</translation>
<translation id="6394350458541421998">Ta pravilnik se ne uporablja od uveljavitve različice <ph name="PRODUCT_OS_NAME" /> 29. Namesto njega uporabite pravilnik PresentationScreenDimDelayScale.</translation>
<translation id="6401669939808766804">Odjava uporabnika</translation>
<translation id="6406448383934634215">Če je za dejanje, ki se izvede ob zagonu, izbrano »Odpri seznam URL-jev«, lahko s tem določite seznam URL-jev, ki se odprejo. Če pravilnik ni nastavljen, se ob zagonu ne bo odprl noben URL.

          Ta pravilnik deluje samo, če je pravilnik »RestoreOnStartup« nastavljen na »RestoreOnStartupIsURLs«.

          Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="6417265370957905582">Pomočnik Google</translation>
<translation id="6426205278746959912">Aplikacij za Android ni mogoče prisiliti, da bi uporabljale strežnik proxy. Aplikacije za Android imajo na voljo podnabor nastavitev strežnika proxy, ki jih lahko prostovoljno upoštevajo:

          Če izberete, da se strežnik proxy ne uporablja, so aplikacije za Android obveščene, da strežnik proxy ni konfiguriran.

          Če izberete, da se uporabljajo sistemske nastavitve strežnika proxy ali fiksni način strežnika proxy, se aplikacijam za Android posredujeta naslov http in vrata strežnika proxy.

          Če izberete, da se samodejno zazna strežnik proxy, se aplikacijam za Android posreduje URL skripta »http://wpad/wpad.dat«. Ne uporabi se noben drug del protokola za samodejno zaznavanje strežnika proxy.

          Če izberete, da se uporablja skript .pac za strežnik proxy, se aplikacijam za Android posreduje URL skripta.</translation>
<translation id="6430366557948788869">Razširitev za poročanje za Chrome</translation>
<translation id="6440051664870270040">Spletnim mestom dovoli hkratno krmarjenje in odpiranje pojavnih oken</translation>
<translation id="6447948611083700881">Varnostno kopiranje in obnovitev sta onemogočena</translation>
<translation id="6449476513004303784">Uporabnikom ne dovoli upravljanja potrdil</translation>
<translation id="645425387487868471">Omogoči vsiljeno prijavo za izdelek <ph name="PRODUCT_NAME" /></translation>
<translation id="6464074037294098618">Omogočanje samodejnega izpolnjevanja za naslove</translation>
<translation id="6467613372414922590">Dovoli gostitelje izvornega pošiljanja na uporabniški ravni (nameščene brez dovoljenj skrbnika)</translation>
<translation id="6468980648680553776">Ta pravilnik je zastarel. Uporabite pravilnik RemoteAccessHostClientDomainList.</translation>
<translation id="6473623140202114570">Konfigurirajte seznam domen, v katerih funkcija varnega brskanja ne bo sprožila opozoril.</translation>
<translation id="6488627892044759800">Konfigurira vrsto privzete domače strani v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom preprečuje spreminjanje nastavitve domače strani. Domačo stran lahko nastavite na URL, ki ga določite, ali na nov zavihek s povezavami.

          Če to nastavitev omogočite, bo za domačo stran vedno uporabljen nov zavihek s povezavami, URL domače strani pa se prezre.

          Če jo onemogočite, uporabnikova domača stran nikoli ne bo nov zavihek s povezavami, razen če je njen URL nastavljen na »chrome://newtab«.

          Če to nastavitev omogočite ali onemogočite, uporabniki ne morejo spremeniti vrste domače strani v brskalniku <ph name="PRODUCT_NAME" />.

          Če tega pravilnika ne nastavite, bo lahko uporabnik izbral, ali bo nov zavihek s povezavami njegova domača stran.

          Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="6491139795995924304">Omogočanje Bluetootha v napravi</translation>
<translation id="6491872498385040936">Ta pravilnik je zastarel. Premislite o uporabi pravilnika <ph name="FORCE_YOUTUBE_RESTRICT_POLICY_NAME" />, ki preglasi ta pravilnik in omogoča podrobnejše prilagajanje.

      Vsili Zmerno omejeni način v YouTubu in uporabnikom prepreči, da bi to nastavitev spremenili.

      Če je ta nastavitev omogočena, je v YouTubu vedno uveljavljen vsaj Zmerno omejeni način.

      Če je ta nastavitev onemogočena ali ni nastavljena nobena vrednost, <ph name="PRODUCT_NAME" /> ne vsili Omejenega načina v YouTubu. Zunanji pravilniki, na primer pravilniki za YouTube, lahko še vedno uveljavijo Omejeni način.</translation>
<translation id="6495328383950074966">Konfiguriranje seznama domen, ki jim bo Varno brskanje zaupalo. To pomeni:
      Varno brskanje ne bo preverjalo, ali gre za nevarne vire (npr. lažno predstavljanje, zlonamerna programska oprema ali neželena programska oprema), če se URL-ji ujemajo s temi domenami.
      Storitev zaščite prenosov Varnega brskanja ne bo preverjalo prenosov, ki gostujejo v teh domenah.
      Storitev zaščite gesel Varnega brskanja ne bo preverjalo, ali prihaja do vnovične uporabe gesel, če se URL strani ujema s temi domenami.

      Če je ta nastavitev omogočena, bo Varno brskanje zaupalo tem domenam.
      Če je ta nastavitev onemogočena ali ni nastavljena, se privzeta zaščita Varnega brskanja uporablja za vse vire.
      Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="6515357889978918016">Slika <ph name="PLUGIN_VM_NAME" /></translation>
<translation id="6520802717075138474">Uvoz iskalnikov privzetega brskalnika ob prvem zagonu</translation>
<translation id="6525955212636890608">Če omogočite to nastavitev, se bo izvajala vsa vsebina Flash, vdelana na spletnih mestih, za katere je bilo v nastavitvah vsebine nastavljeno, da se na njih sme izvajati vsebina Flash – ne glede na to, ali je to storil uporabnik ali je bilo to izvedeno s pravilnikom podjetja –, vključno z vsebino drugega izvora ali majhno vsebino.

      Če želite nadzirati, katerim spletnim mestom je dovoljeno izvajati vsebino Flash, si oglejte pravilnika »DefaultPluginsSetting«, »PluginsAllowedForUrls« in »PluginsBlockedForUrls«.

      Če je ta nastavitev onemogočena ali ni nastavljena, bo vsebina Flash drugega izvora ali majhna vsebina blokirana.</translation>
<translation id="6532769014584932288">Omogočanje zaklepanj prebujanja</translation>
<translation id="653608967792832033">Določa trajanje uporabnikove nedejavnosti, po preteku katere se zaslon zaklene, če se napaja iz akumulatorja.

          Če je pravilnik nastavljen na vrednost nad nič, določa trajanje, v katerem mora biti uporabnik nedejaven in po preteku katerega <ph name="PRODUCT_OS_NAME" /> zaklene zaslon.

          Če je pravilnik nastavljen na nič, <ph name="PRODUCT_OS_NAME" /> ne zaklene zaslona, ko je uporabnik nedejaven.

          Če pravilnik ni nastavljen, velja privzeto trajanje.

          Priporočljivo je, da za zaklep zaslona ob nedejavnosti omogočite zaklepanje ob prekinitvi, da se <ph name="PRODUCT_OS_NAME" /> prekine po preteku časovnega zamika nedejavnosti. Pravilnik uporabite samo, če želite, da se zaslon zaklene bistveno pred prekinitvijo, ali če ne želite prekinitve ob nedejavnosti.

          Vrednost pravilnika naj bo navedena v milisekundah. Vrednosti morajo biti manjše od časovnega zamika ob nedejavnosti.</translation>
<translation id="6536600139108165863">Samodejni vnovični zagon ob zaustavitvi naprave</translation>
<translation id="6539246272469751178">Ta pravilnik ne vpliva na aplikacije za Android. Aplikacije za Android vedno uporabljajo privzeti imenik za prenose in ne morejo dostopati do datotek, ki jih sistem <ph name="PRODUCT_OS_NAME" /> prenese v imenik za prenose, ki ni privzet.</translation>
<translation id="654303922206238013">Strategija selitve za ecryptfs</translation>
<translation id="6544897973797372144">Če je ta pravilnik nastavljen na »True« in pravilnik »ChromeOsReleaseChannel« ni določen, lahko uporabniki domene za včlanitev spremenijo distribucijski kanal za nove izdaje naprave. Če je pravilnik nastavljen na »False«, je naprava zaklenjena v kanalu, v katerem je bila nazadnje nastavljena.

      Kanal, ki ga izbere uporabnik, preglasi pravilnik ChromeOsReleaseChannel, vendar če je kanal pravilnika stabilnejši kot pravilnik, nameščen v napravi, se stabilnejši kanal uporabi, ko je številka njegove različice večja od številke različice v napravi.</translation>
<translation id="6553143066970470539">Odstotek svetlosti zaslona</translation>
<translation id="6559057113164934677">Ne dovoli nobenemu spletnemu mestu dostopa do kamere in mikrofona</translation>
<translation id="6561396069801924653">Prikaz možnosti funkcij za ljudi s posebnimi potrebami v meniju sistemske vrstice</translation>
<translation id="6563458316362153786">Omogoči hitri prehod 802.11r</translation>
<translation id="6565312346072273043">Nastavi privzeto stanje funkcij za ljudi posebnimi potrebami zaslonske tipkovnice na zaslonu za prijavo.

          Če je ta pravilnik nastavljen na »true«, je zaslonska tipkovnica omogočena, ko je prikazan zaslon za prijavo.

          Če je ta pravilnik nastavljen na »false«, je zaslonska tipkovnica onemogočena, ko je prikazan zaslon za prijavo.

          Če nastavite ta pravilnik, ga lahko uporabniki začasno preglasijo, tako da omogočijo ali onemogočijo zaslonsko tipkovnico. Uporabnikova izbira ni trajna in privzeta možnost je obnovljena, ko se zaslon za prijavo prikaže na novo ali če uporabnik na zaslonu za prijavo eno minuto ne izvede nobenega dejanja.

          Če ta pravilnik ni nastavljen, je zaslonska tipkovnica onemogočena pri prvem prikazu zaslona za prijavo. Uporabniki lahko zaslonsko tipkovnico kadar koli omogočijo ali onemogočijo in njeno stanje na zaslonu za prijavo velja za vse uporabnike.</translation>
<translation id="6570691255874112762">Ta pravilnik nadzira, ali lahko uporabnik z upraviteljem potrdil uvaža in odstranjuje potrdila.

      Če je ta pravilnik nastavljen na »Uporabnikom dovoli upravljanje vseh potrdil« ali ni nastavljen, bodo lahko uporabniki upravljali potrdila.

      Če je ta pravilnik nastavljen na »Uporabnikom dovoli upravljanje uporabniških potrdil«, bodo lahko uporabniki upravljali uporabniška potrdila, ne pa tudi potrdil za celotno napravo.

      Če je ta pravilnik nastavljen na »Uporabnikom ne dovoli upravljanja potrdil«, uporabniki ne bodo mogli upravljati potrdil, temveč si jih bodo lahko samo ogledali.</translation>
<translation id="6573305661369899995">Nastavitev zunanjega vira omejitev za URL-je</translation>
<translation id="6583851521569686409">Konfigurira seznam tiskalnikov.

      Ta pravilnik skrbnikom omogoča navajanje konfiguracij tiskalnikov
      za uporabnike.

      <ph name="PRINTER_DISPLAY_NAME" /> in <ph name="PRINTER_DESCRIPTION" /> sta poljubno oblikovana niza, ki ju je mogoče prilagoditi za preprostejše izbiranje tiskalnika. <ph name="PRINTER_MANUFACTURER" /> in <ph name="PRINTER_MODEL" /> končnim uporabnikom olajšata prepoznavo tiskalnika, saj predstavljata proizvajalca in model tiskalnika. <ph name="PRINTER_URI" /> mora biti naslov, do katerega je mogoče dostopati iz odjemalskega računalnika, vključno s temi podatki: <ph name="URI_SCHEME" />, <ph name="URI_PORT" /> in <ph name="URI_QUEUE" />. Identifikator <ph name="PRINTER_UUID" /> ni obvezen. Če je naveden, se uporablja za odstranjevanje podvojenih tiskalnikov <ph name="ZEROCONF_DISCOVERY" />.

      <ph name="PRINTER_EFFECTIVE_MODEL" /> mora vsebovati ime tiskalnika ali mora biti <ph name="PRINTER_AUTOCONF" /> omogočen. Tiskalniki z obema lastnostma ali brez lastnosti bodo prezrti.

      Nastavitev tiskalnika je dokončana ob prvi uporabi tiskalnika.  Datoteke PPD se ne prenesejo, dokler se tiskalnik ne uporablja.  Po tem se pogosto uporabljene datoteke PPD predpomnijo.

      Ta pravilnik ne vpliva na to, ali lahko uporabniki konfigurirajo tiskalnike v posameznih napravah.  Namenjen je kot dodatek konfiguracijam tiskalnikov, ki jih opravijo posamezni uporabniki.

      Za naprave, ki jih upravlja Active Directory, ta pravilnik podpira razširitev <ph name="MACHINE_NAME_VARIABLE" /> na ime naprave za Active Directory ali njegov podniz. Če je ime naprave na primer <ph name="MACHINE_NAME_EXAMPLE" />, potem <ph name="MACHINE_NAME_VARIABLE_EXAMPLE" /> zamenjajo 4 znaki po 6. mestu, tj. <ph name="MACHINE_NAME_PART_EXAMPLE" />. Položaj temelji na ničli.
      </translation>
<translation id="6598235178374410284">Slika za avatar uporabnika</translation>
<translation id="6603004149426829878">Vedno pošlji vse razpoložljive signale lokacije v strežnik pri določanju časovnega pasu</translation>
<translation id="6628120204569232711">Poročanje o stanju shrambe</translation>
<translation id="6628646143828354685">Omogoča nastavitev, ali lahko spletna mesta dostopajo do naprav Bluetooth v bližini. Dostop je mogoče v celoti blokirati ali pa je uporabnik vprašan, ko želi spletno mesto dostopati do naprav Bluetooth v bližini.

          Če ta pravilnik ni nastavljen, je uporabljeno »3« in uporabnik lahko to spremeni.</translation>
<translation id="663685822663765995">Omejitev barvnega načina tiskanja</translation>
<translation id="6641981670621198190">Onemogoči podporo za vmesnike API za 3D-grafiko</translation>
<translation id="6646056064606561298">Omogočanje pravilnika za upravljanje porabe energije z zagonom pri napajanju iz električnega omrežja.

          Zagon pri napajanju iz električnega omrežja omogoča priložnost, da se sistem ob priklopu omrežnega napajanja samodejno zažene iz izklopljenega stanja/stanja mirovanja.

          Če je ta pravilnik omogočen, bo zagon pri napajanju iz električnega omrežja vedno omogočen, če ga naprava podpira.

          Če je pravilnik onemogočen, bo zagon pri napajanju iz električnega omrežja vedno onemogočen.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če ta pravilnik ni nastavljen, je zagon pri napajanju iz električnega omrežja onemogočen in ga uporabnik ne more omogočiti.</translation>
<translation id="6647965994887675196">Če je pravilnik vklopljen, je mogoče ustvariti in uporabiti zaščitene uporabnike.

          Če pravilnik ni vklopljen ali ni nastavljen, ustvarjanje in prijava zaščitenih uporabnikov nista mogoča. Vsi obstoječi zaščiteni  uporabniki so skriti.

          OPOMBA: Privzeta nastavitev se razlikuje v napravah za potrošnike in napravah za podjetja: v napravah za potrošnike so zaščiteni uporabniki privzeto omogočeni, v napravah za podjetja pa privzeto onemogočeni.</translation>
<translation id="6649397154027560979">Ta pravilnik je zastarel, Namesto njega uporabite URLBlacklist.

Onemogoči navedene sheme protokola v brskalniku <ph name="PRODUCT_NAME" />.

URL-ji, ki uporabljajo sheme s tega seznama, se ne bodo naložili in dostop do njih ne bo mogoč.

Če ta pravilnik ni nastavljen ali je seznam prazen, bodo v brskalniku <ph name="PRODUCT_NAME" /> dostopne vse sheme.</translation>
<translation id="6652197835259177259">Nastavitve lokalno upravljanih uporabnikov</translation>
<translation id="6658245400435704251">Določa število sekund, do katerega lahko naprava naključno odloži prenos posodobitve od trenutka, ko je bila posodobitev prvič na voljo v strežniku. Naprava lahko del tega časa čaka v smislu dejansko pretečenega časa, preostali del pa v smislu števila preverjanj za posodobitve. Razpršitev je v vsakem primeru omejena navzgor na nespremenljiv čas, tako da se ne more zgoditi, da bi naprava neomejen čas čakala na prenos posodobitve.</translation>
<translation id="6665670272107384733">Nastavi, kako pogosto mora uporabnik vnesti geslo, če želi uporabljati hitro odklepanje</translation>
<translation id="6681229465468164801">Omogoča nastavitev seznama vzorcev URL-jev, ki določa, katerim spletnim mestom je preprečeno pozivanje uporabnikov k odobritvi dostopa do naprave USB.

          Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi globalna privzeta vrednost iz pravilnika »DefaultWebUsbGuardSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.

          Vzorci URL-jev v tem pravilniku ne smejo biti v nasprotju s tistimi, ki so konfigurirani v pravilniku »WebUsbAskForUrls«. Če se URL ujema z obema pravilnikoma, ni določeno, kateri ima prednost.</translation>
<translation id="6689792153960219308">Poročanje o stanju strojne opreme</translation>
<translation id="6698632841807204978">Omogočanje enobarvnega tiskanja</translation>
<translation id="6699880231565102694">Omogočanje preverjanja pristnosti v dveh korakih za gostitelje oddaljenega dostopa</translation>
<translation id="6731757988219967594">Filtriranje vrhnjih spletnih mest (vendar ne vdelanih elementov iframe) zaradi izločanja  vsebine za odrasle</translation>
<translation id="6734521799274931721">Nadzira razpoložljivost omrežnih naprav za skupno rabo datotek v okolju OS Chrome</translation>
<translation id="6735701345096330595">Vsiljeno preverjanje črkovanja jezikov</translation>
<translation id="673699536430961464">Ta nastavitev uporabnikom po prijavi v napravo <ph name="PRODUCT_OS_NAME" /> omogoča preklop med Google Računi na območju z vsebino v oknu brskalnika.

      Če je ta pravilnik nastavljen na »false«, prijava v drug račun na območju z vsebino brskalnika z beleženjem zgodovine ne bo dovoljena.

      Če ta pravilnik ni nastavljen ali je nastavljen na »true«, se uporabi privzeto delovanje: prijava v drug račun na območju z vsebino brskalnika bo dovoljena z izjemo računov za otroke, pri katerih je to blokirano za območje z vsebino brskalnika z beleženjem zgodovine.

      Če prijava v drug račun ne bi smela biti dovoljena v načinu brez beleženja zgodovine, blokirajte ta način s pravilnikom »IncognitoModeAvailability«.

      Upoštevajte, da bodo lahko uporabniki z blokiranjem piškotkov dostopali do Googlovih storitev v stanju brez preverjanja pristnosti.</translation>
<translation id="6757438632136860443">Omogoča nastavitev seznama vzorcev URL-jev, ki določa, katerim spletnim mestom je dovoljeno izvajanje vtičnika <ph name="FLASH_PLUGIN_NAME" />.

          Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi globalna privzeta vrednost iz pravilnika »DefaultPluginsSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.</translation>
<translation id="6757613329154374267">Varnostno kopiranje in obnovitev sta omogočena</translation>
<translation id="6762235610019366960">Omogoča nadziranje predstavitve promocijske in/ali izobraževalne vsebine po celem zavihku v izdelku <ph name="PRODUCT_NAME" />.

      Če nastavitev ni konfigurirana ali omogočena (nastavljena na »true«), lahko <ph name="PRODUCT_NAME" /> zaradi posredovanja podatkov o izdelku uporabnikom prikaže vsebino po celem zavihku.

      Če je nastavitev onemogočena (nastavljena na »false«), <ph name="PRODUCT_NAME" /> zaradi posredovanja podatkov o izdelku uporabnikom ne bo prikazal vsebine po celem zavihku.

      Ta nastavitev nadzira predstavitev pozdravnih strani, ki uporabnikom pomagajo, da se prijavijo v izdelek <ph name="PRODUCT_NAME" />, ga izberejo kot privzeti brskalnik ali jih kakor koli drugače obveščajo o funkcijah izdelka.</translation>
<translation id="6766216162565713893">Dovoli spletnim mestom, da od uporabnika zahtevajo, da omogočijo dostop do naprave Bluetooth v bližini</translation>
<translation id="6770454900105963262">Poročanje podatkov o aktivnih sejah kioska</translation>
<translation id="6786747875388722282">Razširitve</translation>
<translation id="6786967369487349613">Nastavitev imenika za profil za gostovanje</translation>
<translation id="6795485990775913659">Omogočanje tiskanja samo brez kode PIN</translation>
<translation id="6810445994095397827">Blokiraj JavaScript na teh mestih</translation>
<translation id="6813263547126514821">Vklop in zaustavitev</translation>
<translation id="681446116407619279">Podprti načini preverjanja pristnosti</translation>
<translation id="6816212867679667972">Določitev imena gostitelja naprave, uporabljenega v zahtevah DHCP.

      Če je ta pravilnik nastavljen na niz, ki ni prazen, bo ta niz uporabljen kot ime gostitelja naprave v zahtevi DHCP.

      Niz lahko vsebuje spremenljivke ${ASSET_ID}, ${SERIAL_NUM}, ${MAC_ADDR}, ${MACHINE_NAME}, ki jih pred uporabo kot ime gostitelja zamenjajo vrednosti v napravi. Posledična zamenjava mora biti veljavno ime gostitelja (skladno z RFC 1035, razdelek 3.1).

      Če ta pravilnik ni nastavljen ali vrednost po zamenjavi ni veljavno ime gostitelja, v zahtevi DHCP ne bo nastavljeno ime gostitelja. </translation>
<translation id="6833988859168635883">Zagon, domača stran in nov zavihek s povezavami</translation>
<translation id="6835883744948188639">Uporabniku prikaži ponavljajoč se poziv, ki obvešča, da je priporočen vnovičen zagon</translation>
<translation id="6837480141980366278">Določa, ali je v brskalniku <ph name="PRODUCT_NAME" /> uporabljen vgrajeni odjemalec DNS.

      Če je ta pravilnik nastavljen na »true«, bo uporabljen vgrajeni odjemalec DNS, če je na voljo.

      Če je ta pravilnik nastavljen na »false«, vgrajeni odjemalec DNS ne bo uporabljen.

      Če ta pravilnik ni nastavljen, bo vgrajeni odjemalec DNS privzeto omogočen v sistemih macOS, Android (če nista omogočena zasebni strežnik DNS in VPN) in OS Chrome, uporabniki pa bodo lahko spreminjali, ali naj se uporablja vgrajeni odjemalec DNS tako, da bodo uredili stran chrome://flags ali določili zastavico v ukazni vrstici.</translation>
<translation id="6843296367238757293">Ta pravilnik je zastarel. Njegovo uporabo odsvetujemo. Preberite več na https://support.google.com/chrome/a/answer/7643500</translation>
<translation id="684856667300805181">Ta pravilnik je bil odstranjen v izdelku <ph name="PRODUCT_NAME" /> in ga je zamenjal pravilnik <ph name="ARC_GLS_POLICY_NAME" />.</translation>
<translation id="6856743875250214792">Ta pravilnik je zastarel in smo ga v M66 odstranili, ker se je uporabljal samo za interno preskušanje in predstavlja varnostno tveganje.

      Določa zastavice, ki naj se uporabijo za <ph name="PRODUCT_NAME" />, ko se zažene. Izbrane zastavice se uporabijo samo na zaslonu za prijavo. Zastavice, nastavljene s tem pravilnikom, se ne prenesejo v uporabniške seje.</translation>
<translation id="685769593149966548">Uveljavitev Strogo omejenega načina v YouTubu</translation>
<translation id="6857824281777105940">Ta pravilnik nadzira, ali se sporočajo podatki o Varnem brskanju, vključno s številom opozoril Varnega brskanja in številom opuščenih opozoril Varnega brskanja s klikom.

      Če ta pravilnik ni nastavljen ali je omogočen, se podatki o Varnem brskanju zbirajo.
      Če je pravilnik onemogočen, se podatki o Varnem brskanju ne zbirajo.

      Ta pravilnik se uporablja samo, če je omogočena razširitev <ph name="CHROME_REPORTING_EXTENSION_NAME" />, računalnik pa je včlanjen v pravilnik <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="686079137349561371">Microsoft Windows 7 ali novejši</translation>
<translation id="687046793986382807">Ta pravilnik je zastaral in se ne uporablja več od različice 35 brskalnika <ph name="PRODUCT_NAME" />.

      Podatki o pomnilniku se vseeno pošiljajo strani, ne glede na vrednost možnosti, vendar se poslane vrednosti
      kvantizirajo in je hitrost posodobitev iz varnostnih razlogov omejena. Če želite sprotne natančne podatke,
      uporabite orodja, kot je Telemetry.</translation>
<translation id="6894178810167845842">URL novega zavihka s povezavami</translation>
<translation id="6899705656741990703">Samodejno zaznavanje nastavitev proxyja</translation>
<translation id="6903814433019432303">Ta pravilnik je aktiven samo v maloprodajnem načinu.

      Določa URL-je, ki se naložijo v predstavitveni seji. Ta pravilnik preglasi vse druge mehanizme za nastavitev začetnega URL-ja in se lahko uporabi samo za sejo, ki ni povezana z določenim uporabnikom.</translation>
<translation id="6908640907898649429">Nastavi privzeti iskalnik. Določite lahko privzeti iskalnik, ki ga bo uporabil uporabnik, ali onemogočite privzeti iskalnik.</translation>
<translation id="6913068954484253496">Izdelku <ph name="PRODUCT_NAME" /> dovoli povezovanje z napravami za predvajanje na vseh naslovih IP</translation>
<translation id="6915442654606973733">Omogočanje funkcije za izgovorjavo za ljudi s posebnimi potrebami.

          Če je ta pravilnik vklopljen, bo izgovorjava vedno omogočena.

          Če je ta pravilnik izklopljen, bo izgovorjava vedno onemogočena.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če ga ne nastavite, je izgovorjava prvotno onemogočena, vendar jo lahko uporabnik kadar koli omogoči.</translation>
<translation id="6916507170737609563">
      Oglejte si nastavitev pravilnika IsolateOriginsAndroid, če želite izkoristiti prednosti obeh funkcij, osamitve in omejenega vpliva za uporabnike, tako, da uporabite pravilnik IsolateOriginsAndroid s seznamom spletnih mest, ki jih želite osamiti. Ta nastavitev, SitePerProcessAndroid, osami vsa spletna mesta.
      Če je pravilnik omogočen, se vsako spletno mesto izvaja v svojem procesu.
      Če je pravilnik onemogočen, ne pride do eksplicitne osamitve spletnih mest in preizkusi pravilnikov IsolateOriginsAndroid in SitePerProcessAndroid so onemogočeni. Uporabniki bodo lahko še vedno ročno omogočili pravilnik SitePerProcess.
      Če pravilnik ni konfiguriran, bo lahko uporabnik to nastavitev spremenil.

      OPOMBA: v Androidu je osamitev spletnih mest poskusna. Podpora se bo sčasoma izboljšala, vendar lahko v tem trenutku pride do težav pri delovanju.

      OPOMBA: ta pravilnik se uporablja samo za Chrome v Androidu v napravah, ki imajo več kot 1 GB RAM-a. Če želite pravilnik uporabljati v okoljih, ki niso Android, uporabite SitePerProcess.
      </translation>
<translation id="6922884955650325312">Blokiraj vtičnik <ph name="FLASH_PLUGIN_NAME" /></translation>
<translation id="6923366716660828830">Določa ime privzetega ponudnika iskanja. Če pravilnik ostane prazen ali če ni nastavljen, bo uporabljeno ime gostitelja, določeno z URL-jem iskanja.

          Ta pravilnik velja le, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="6924223708804692571">Vsili onemogočanje jezikov za preverjanje črkovanja. Neprepoznani jeziki na tem seznamu so prezrti.

      Če omogočite ta pravilnik, je preverjanje črkovanja onemogočeno za navedene jezike. Uporabnik lahko še vedno omogoči ali onemogoči preverjanje črkovanja za jezike, ki niso na seznamu.

      Če ne nastavite tega pravilnika ali ga onemogočite, ni sprememb uporabnikovih nastavitev preverjanja črkovanja.

      Če je pravilnik <ph name="SPELLCHECK_ENABLED_POLICY_NAME" /> onemogočen, ta pravilnik nima učinka.

      Če je jezik vključen v ta pravilnik in pravilnik <ph name="SPELLCHECK_LANGUAGE_POLICY_NAME" />, ima slednji pravilnik prednost in jezik za preverjanje črkovanja je omogočen.

      Za zdaj so podprti jeziki: 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="6926703471186170050">Omogočanje obojestranskega tiskanja z dolgim robom</translation>
<translation id="6931242315485576290">Onemogoči sinhroniziranje podatkov z Googlom</translation>
<translation id="6936894225179401731">Določa največje število hkratnih povezav v strežnik proxy.

      Nekateri strežniki proxy ne morejo obravnavati velikega števila hkratnih povezav na odjemalca, kar je mogoče razrešiti z nastavitvijo tega pravilnika na nižjo vrednost.

      Vrednost tega pravilnika mora biti nižja od 100 in višja od 6, privzeta vrednost je 32.

      Nekatere spletne aplikacije zavzamejo veliko povezav, ki se prenehajo odzivati, zato lahko znižanje vrednosti pod 32 povzroči neodzivnost povezav brskalnika z omrežjem, če je odprtih preveč takšnih aplikacij. Vrednost znižate pod privzeto na svojo odgovornost.

      Če ta pravilnik ni nastavljen, bo uporabljena privzeta vrednost, ki je 32.</translation>
<translation id="6943577887654905793">Ime nastavitve za Mac/Linux:</translation>
<translation id="6944167205014013774">Podatki o uporabi aplikacij za Linux se pošljejo nazaj v
      strežnik.

      Če je pravilnik onemogočen ali ni nastavljen, se podatki o uporabi ne
      poročajo. Če je omogočen, se podatki o uporabi poročajo.

      Ta pravilnik se uporabi samo, če je podpora za aplikacije za Linux omogočena.</translation>
<translation id="69525503251220566">Parameter, ki omogoča funkcijo iskanja po sliki za privzetega ponudnika iskanja</translation>
<translation id="6953102253399571439">Omogočanje, da je privzeto tiskanje s kodo PIN</translation>
<translation id="6956272732789158625">Spletnim mestom ne dovoli uporabe ustvarjanja ključev</translation>
<translation id="6965859329738616662">Določa, ali je pametnemu modelu zatemnitve dovoljeno podaljšati čas do zatemnitve zaslona.

      Preden se zaslon zatemni, pametni model zatemnitve oceni, ali je treba zatemnitev zaslona odložiti. Če pametni model zatemnitve odloži zatemnitev zaslona, dejansko podaljša čas do zatemnitve zaslona. V tem primeru se časovna zamika izklopa zaslona in zaklepanja zaslona ter časovni zamik ob nedejavnosti prilagodijo, da ohranijo enako časovno razdaljo od prvotno konfigurirane zakasnitve zatemnitve zaslona.
      Če je pravilnik omogočen ali ni nastavljen, je pametni model zatemnitve omogočen in sme podaljšati čas do zatemnitve zaslona. Če je pravilnik onemogočen, pametni model zatemnitve na zatemnitev zaslona ne vpliva.</translation>
<translation id="6967394885063085697">Omogočanje pravilnika za upravljanje porabe energije z naprednim načinom polnjenja akumulatorja.

          Napredni način polnjenja akumulatorja uporabniku omogoča doseganje največje zmogljivosti akumulatorja. V naprednem načinu polnjenja sistem med urami, ko ne poteka delo, uporablja standardni algoritem polnjenja in druge tehnike, da zagotovi največjo zmogljivost akumulatorja. Med urami, ko poteka delo, se uporablja hitro polnjenje. Hitro polnjenje omogoča hitrejše polnjenje akumulatorja, tako da je akumulator v celoti napolnjen prej. Za vsak dan je obdobje, v katerem bo sistem najbolj obremenjen, določeno z začetnim časom in trajanjem.

          Če je ta pravilnik omogočen in je nastavljen pravilnik DeviceAdvancedBatteryChargeModeDayConfig, bo napredni način polnjenja akumulatorja vedno omogočen, če ga naprava podpira.

          Če je ta pravilnik onemogočen, bo napredni način polnjenja akumulatorja vedno onemogočen.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če ta pravilnik ni nastavljen, je napredni način polnjenja akumulatorja onemogočen in ga uporabnik ne more omogočiti.</translation>
<translation id="6972540544240464302">Izbira konfiguracije sistema za razporejanje opravil</translation>
<translation id="6979158407327259162">Google Drive</translation>
<translation id="6994082778848658360">Določa, kako lahko vgrajena strojna oprema za varnostni element zagotovi dvojno preverjanje pristnosti, če je združljiva s to funkcijo. Gumb za vklop na računalniku zazna fizično prisotnost uporabnika.

      Če je izbrana možnost »Onemogočeno«, dvojno preverjanje ni zagotovljeno.

      Če je izbrana možnost »U2F«, se integrirano dvojno preverjanje uporablja v skladu z določitvijo FIDO U2F.

      Če je izbrana možnost »U2F_EXTENDED«, integrirano dvojno preverjanje zagotovi funkcije U2F in nekatere razširitve za posamezno potrditev.</translation>
<translation id="7003334574344702284">Če je pravilnik omogočen, se shranjena gesla uvozijo iz prejšnjega privzetega brskalnika. Če je pravilnik omogočen, vpliva tudi na pogovorno okno za uvoz.

      Če je onemogočen, se shranjena gesla ne uvozijo.

      Če ni nastavljen, bo uporabnik morda vprašan, ali naj jih uvozi, ali pa bo uvoz izveden samodejno.</translation>
<translation id="7003746348783715221">Nastavitve za <ph name="PRODUCT_NAME" /></translation>
<translation id="7007671350884342624">Konfigurira imenik, ki ga bo <ph name="PRODUCT_NAME" /> uporabljal za shranjevanje uporabniških podatkov.

      Če ta pravilnik nastavite, bo <ph name="PRODUCT_NAME" /> uporabljal navedeni imenik ne glede na to, ali je uporabnik določil zastavico »--user-data-dir«. Če se želite izogniti izgubi podatkov ali drugim nepričakovanim napakam, tega pravilnika ne nastavite na korenski imenik pogona ali imenik, ki ga uporabljate za druge namene, ker <ph name="PRODUCT_NAME" /> upravlja njegovo vsebino.

      Seznam spremenljivk, ki jih je mogoče uporabiti, si lahko ogledate na https://www.chromium.org/administrators/policy-list-3/user-data-directory-variables.

      Če tega pravilnika ne nastavite, bo uporabljena privzeta pot profila in uporabnik jo bo lahko preglasil z zastavico »--user-data-dir« v ukazni vrstici.</translation>
<translation id="7027785306666625591">Konfigurira upravljanje porabe za <ph name="PRODUCT_OS_NAME" />.

      S temi pravilniki lahko nastavite, kaj naj <ph name="PRODUCT_OS_NAME" /> izvede, ko je uporabnik nedejaven nekaj časa.</translation>
<translation id="7040229947030068419">Vzorčna vrednost:</translation>
<translation id="7044883996351280650">Nadziranje Androidovih storitev varnostnega kopiranja in obnovitve</translation>
<translation id="7049373494483449255">Omogoča programu <ph name="PRODUCT_NAME" /> pošiljanje dokumentov v storitev <ph name="CLOUD_PRINT_NAME" /> za tiskanje. OPOMBA: To vpliva le na podporo storitve <ph name="CLOUD_PRINT_NAME" /> v programu <ph name="PRODUCT_NAME" />. Uporabnikom ne preprečuje pošiljanja tiskalniških poslov na spletna mesta.

      Če je ta nastavitev omogočena ali ni konfigurirana, lahko uporabniki tiskajo v storitvi <ph name="CLOUD_PRINT_NAME" /> iz pogovornega okna za tiskanje v programu <ph name="PRODUCT_NAME" />.

      Če je ta nastavitev onemogočena, uporabniki ne morejo tiskati v storitvi <ph name="CLOUD_PRINT_NAME" /> iz pogovornega okna za tiskanje v programu <ph name="PRODUCT_NAME" /></translation>
<translation id="7053678646221257043">Če je ta pravilnik omogočen, se zaznamki uvozijo iz trenutnega privzetega brskalnika. Če je omogočen, ta pravilnik vpliva tudi na pogovorno okno za uvoz.

       Če je onemogočen, se zaznamki ne uvozijo.

      Če ni nastavljen, bo uporabnik morda vprašan, ali naj zaznamke uvozi, ali pa bo uvoz izveden samodejno.</translation>
<translation id="7063895219334505671">Dovoli pojavna okna na teh mestih</translation>
<translation id="706568410943497889">
      Če je pravilnik omogočen, je izdelku <ph name="PRODUCT_NAME" /> dovoljeno zbiranje dnevnikov dogodkov tehnologije WebRTC iz Googlovih storitev (npr. iz Googla Meet) ter nalaganje teh dnevnikov v Google.

      Če je pravilnik onemogočen ali ni nastavljen, <ph name="PRODUCT_NAME" /> tovrstnih dnevnikov ne sme zbirati ne nalagati.

      Ti dnevniki vsebujejo diagnostične podatke, ki so koristni pri odpravljanju težav z zvočnimi klici ali videoklici v Chromu, na primer čas in velikost poslanih ter prejetih paketov RTP, povratne informacije o preobremenjenosti omrežja ter metapodatki o času in kakovosti zvočnih ter slikovnih okvirov. Ti dnevniki ne vsebujejo zvočne ali slikovne vsebine klica.

      To zbiranje podatkov v Chromu lahko sprožijo samo Googlove spletne storitve, na primer Google Hangouts ali Google Meet.

      Google lahko te dnevnike prek ID-ja seje poveže z drugimi dnevniki, ki jih zbira sama Googlova storitev, in sicer zaradi lažjega odpravljanja napak.
      </translation>
<translation id="706669471845501145">Mestom dovoli prikazovanje namiznih obvestil</translation>
<translation id="7068108874199666656">Omogoča pošiljanje omrežne konfiguracije, ki se uporablja za vse uporabnike, v napravo z operacijskim sistemom <ph name="PRODUCT_OS_NAME" />. Omrežna konfiguracija je niz v obliki zapisa JSON, kot je določeno z obliko konfiguracije odprtega omrežja.</translation>
<translation id="7070525176564511548">Vnos gesla je obvezen vsak teden (168 ur)</translation>
<translation id="7072208053150563108">Hitrost spreminjanja gesla naprave</translation>
<translation id="7079519252486108041">Blokiraj pojavna okna na teh mestih</translation>
<translation id="7085803328069945025">Omogoča nastavitev seznama vzorcev URL-jev, ki določa, katerim spletnim mestom je dovoljeno pozvati uporabnike k odobritvi dostopa do naprave USB.

          Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi globalna privzeta vrednost iz pravilnika »DefaultWebUsbGuardSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.

          Vzorci URL-jev v tem pravilniku ne smejo biti v nasprotju s tistimi, ki so konfigurirani v pravilniku »WebUsbBlockedForUrls«. Če se URL ujema z obema pravilnikoma, ni določeno, kateri ima prednost.</translation>
<translation id="7086677522575756117">Določa odstotek, za katerega se prilagodi zakasnitev zatemnitve zaslona, kadar se zazna dejavnost uporabnika, medtem ko je zaslon v zatemnjenem načinu ali kmalu potem ko je bil izklopljen.

          Če je nastavljen ta pravilnik, določa odstotek prilagoditve zakasnitve zatemnitve zaslona, kadar se zazna dejavnost uporabnika, medtem ko je zaslon v zatemnjenem načinu ali kmalu potem ko je bil izklopljen. Če je zakasnitev zatemnitve prilagojena, se zakasnitev izklopa zaslona, zakasnitev zaklepanja zaslona in zakasnitev zaradi nedejavnosti prilagodijo tako, da ohranijo enako časovno razdaljo od zakasnitve zatemnitve zaslona, kot je bila sprva konfigurirana.

          Če ta pravilnik ni nastavljen, se uporabi privzeti faktor prilagoditve.

          Ta pravilnik ima vpliv samo, če je onemogočen pravilnik: <ph name="POWER_SMART_DIM_ENABLED_POLICY_NAME" />. V nasprotnem primeru je pravilnik prezrt, ker zakasnitev zatemnitve zaslona določa model strojnega učenja.

          Faktor prilagoditve mora biti 100 % ali več.</translation>
<translation id="710003290625031750">Razširjeni opis sheme:</translation>
<translation id="7106631983877564505">Omogoča zaklepanje, ko so naprave s sistemom <ph name="PRODUCT_OS_NAME" /> nedejavne ali preidejo v stanje pripravljenosti.

      Če to nastavitev omogočite, bodo uporabniki za odklepanje naprave iz stanja pripravljenosti potrebovali geslo.

      Če to nastavitev onemogočite, uporabniki za odklepanje naprave iz stanja pripravljenosti ne bodo potrebovali gesla.

      Če to nastavitev omogočite ali onemogočite, je uporabniki ne bodo mogli spremeniti ali preglasiti.

      Če ta pravilnik ni nastavljen, lahko uporabnik izbere, ali bo za odklepanje naprave moral vnesti geslo ali ne.</translation>
<translation id="7107148737865880402">Omogočanje pravilnika za upravljanje porabe energije pri skupni rabi energije prek povezave USB.

          Nekatere naprave imajo posamezna vrata USB, označena z ikono strele ali akumulatorja, ki omogočajo polnjenje naprav, kot so mobilni telefoni, z energijo iz akumulatorja sistema. Ta pravilnik vpliva na delovanje polnjenja prek teh vrat, ko je sistem v stanju pripravljenosti in ko je izklopljen. Ta pravilnik ne vpliva na druga vrata USB in delovanje polnjenja, ko je sistem vklopljen.

          Ko je vklopljen, vrata USB vedno zagotavljajo energijo.

          Če je sistem v stanju pripravljenosti in je ta pravilnik omogočen, bodo vrata USB oskrbovana z energijo, če je naprava priključena v stenski polnilnik ali če raven napolnjenosti akumulatorja presega 50 %. Sicer vrata ne bodo oskrbovana z energijo.

          Če je sistem izklopljen in je ta pravilnik omogočen, bodo vrata USB oskrbovana z energijo, če je naprava priključena v stenski polnilnik. Sicer vrata ne bodo oskrbovana z energijo.

          Če ta pravilnik ni nastavljen, je pravilnik omogočen in ga uporabnik ne more onemogočiti.</translation>
<translation id="7115494316187648452">Določa, ali se začne proces v brskalniku <ph name="PRODUCT_NAME" /> izvajati ob prijavi v operacijski sistem in se izvaja tudi po zaprtju zadnjega okna brskalnika, pri čemer so aplikacije v ozadju in trenutna seja brskanja, vključno z morebitnimi piškotki seje, še vedno aktivni.

      Če je ta pravilnik omogočen, je način izvajanja v ozadju omogočen in ga uporabnik ne more upravljati v nastavitvah brskalnika.

      Če je ta pravilnik onemogočen, je način izvajanja v ozadju onemogočen in ga uporabnik ne more upravljati v nastavitvah brskalnika.

      Če ta pravilnik ni nastavljen, je način izvajanja v ozadju na začetku onemogočen in ga uporabnik lahko upravlja v nastavitvah brskalnika.</translation>
<translation id="7123160381479171745">Določa seznam uporabnikov, ki se lahko prijavijo v napravo. Vnosi so v obliki <ph name="USER_WHITELIST_ENTRY_FORMAT" />, na primer <ph name="USER_WHITELIST_ENTRY_EXAMPLE" />. Če želite omogočiti poljubne uporabnike v domeni, naj bodo vnosi v obliki <ph name="USER_WHITELIST_ENTRY_WILDCARD" />.

      Če pravilnik ni nastavljen, se lahko prijavijo vsi uporabniki. Če ustvarite nove uporabnike, morate ustrezno nastaviti pravilnik <ph name="DEVICE_ALLOW_NEW_USERS_POLICY_NAME" />.</translation>
<translation id="7123266440503901785"><ph name="PRODUCT_NAME" /> zagotavlja varno posodabljanje in nameščanje razširitev. Kljub temu lahko vsebino nekaterih razširitev, ki gostujejo zunaj Spletne trgovine Chrome, ščitijo samo algoritmi za podpisovanje ali zgoščevanje, ki niso varni, na primer SHA1. Če je ta pravilnik onemogočen, Chrome ne bo dovolil sveže namestitve takšnih razširitev in njihovih posodobitev (dokler razvijalci razširitve ne predelajo z močnejšimi algoritmi). Če je ta pravilnik omogočen, bodo namestitev in posodobitve takšnih razširitev dovoljene.

          Če pravilnik ni nastavljen, je privzeto omogočeno delovanje.
          Od brskalnika <ph name="PRODUCT_NAME" /> različice 75 bo privzeto omogočeno delovanje, če pravilnik ne bo nastavljen.

          Od brskalnika <ph name="PRODUCT_NAME" /> različice 77 bo ta pravilnik prezrt in obravnavan kot onemogočen.</translation>
<translation id="7126716959063786004">Omogoči končevanje procesov v upravitelju opravil</translation>
<translation id="7127892035367404455">Povrnitev na ciljno različico</translation>
<translation id="7128918109610518786">Prikaže identifikatorje aplikacij, ki jih <ph name="PRODUCT_OS_NAME" /> pokaže kot pripete aplikacije v vrstici zaganjalnika.

      Če je pravilnik nastavljen, je seznam aplikacij fiksen in ga uporabnik ne more spreminjati.

      Če pravilnik ni nastavljen, lahko uporabnik spremeni seznam pripetih aplikacij v zaganjalniku.</translation>
<translation id="713121532817834879">Ta pravilnik je URL, ki kaže na datoteko XML v isti obliki, kakršen je pravilnik <ph name="IEEM_SITELIST_POLICY" /> za Internet Explorer. Pravila nalaga iz datoteke XML, ne da bi ta pravila delil z Internet Explorerjem.

      Pravila v tej datoteki XML se uporabljajo enako kot pravilnik <ph name="GREYLIST_POLICY_NAME" />. Ta pravila torej izdelku <ph name="PRODUCT_NAME" /> preprečujejo odpiranje v nadomestnem brskalniku in prav tako preprečujejo nadomestnemu brskalniku odpiranje v izdelku <ph name="PRODUCT_NAME" />.

      Če ta pravilnik ni nastavljen ali ni nastavljen na veljaven URL, ga izdelek <ph name="PRODUCT_NAME" /> ne uporablja kot vir pravil, ki ne sprožijo preklopa brskalnika.

      Če je ta pravilnik nastavljen na veljaven URL, <ph name="PRODUCT_NAME" /> prenese seznam spletnih mest s tega URL-ja in uporabi pravila, kot bi bila konfigurirana s pravilnikom <ph name="SITELIST_POLICY_NAME" />.

      Več informacij o pravilniku <ph name="IEEM_SITELIST_POLICY" /> za Internet Explorer je na voljo tukaj: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="7132877481099023201">URL-ji, ki jim bo brez poziva dovoljen dostop do naprav za zajem videa</translation>
<translation id="7138678301420049075">Drugo</translation>
<translation id="7140629953254369759">Operacijskemu sistemu <ph name="PRODUCT_OS_NAME" /> sporoči, naj uporabi konfiguracijo sistema za razporejanje opravil, ki jo določa navedeno ime.

      Ta pravilnik je mogoče nastaviti na možnost »konservativno« ali »učinkovito delovanje«, ki izbere konfiguracije sistema za razporejanje opravil, ki so prilagojene za stabilnost ali najzmogljivejše delovanje.

      Če pravilnik ni nastavljen, se lahko uporabnik odloča sam.</translation>
<translation id="7145335384492396213">Privzeti način tiskanja s kodo PIN</translation>
<translation id="7158064522994309072">Ta pravilnik nadzira, kateri ukaz se uporablja za odpiranje URL-jev v nadomestnem brskalniku.

      Če ta pravilnik ni nastavljen, se uporabi privzeti brskalnik okolja: Internet Explorer v sistemu Windows ali Safari v sistemu macOS. V sistemu Linux zagon nadomestnega brskalnika ne uspe, če ta pravilnik ni nastavljen.

      Če je ta pravilnik nastavljen na ${ie}, ${firefox}, ${safari} ali
      ${opera}, se zažene ta brskalnik, če je nameščen. ${ie} je na voljo
      samo v sistemu Windows, ${safari} pa samo v sistemih Windows in
      macOS.

      Če je ta pravilnik nastavljen na pot datoteke, se ta datoteka uporablja kot izvršljiva
      datoteka.</translation>
<translation id="7167436895080860385">Dovoli uporabnikom, da pokažejo gesla v upravitelju gesel (zastarelo).</translation>
<translation id="7173856672248996428">Kratkotrajni profil</translation>
<translation id="717630378807352957">Dovoli vse tiskalnike iz datoteke s konfiguracijo.</translation>
<translation id="7176721759719212761">Določa, ali so omogočena zaklepanja prebujanja zaslona. Zaklepanja prebujanja zaslona lahko zahtevajo razširitve prek API-ja razširitve za upravljanje energije in aplikacije ARC.

          Če je ta pravilnik omogočen ali ni nastavljen, bodo za upravljanje energije uporabljena zaklepanja prebujanja, razen če je pravilnik »AllowWakeLocks« onemogočen.

          Če je ta pravilnik onemogočen, bodo zahteve za zaklepanje prebujanja zaslona znižane na zahteve za zaklepanje prebujanja sistema.</translation>
<translation id="7177857088692019405">Hitro odklepanje</translation>
<translation id="7185078796915954712">TLS 1.3</translation>
<translation id="718956142899066210">Dovoljene vrste povezav za posodobitve</translation>
<translation id="7194407337890404814">Privzeto ime iskalnika</translation>
<translation id="7199304109870655950">Konfigurirajte možnosti oddaljenega dostopa v gostitelju za Oddaljeno namizje za Chrome.

      Gostitelj za oddaljeno namizje za Chrome je izvorna storitev, ki se izvaja v ciljnem računalniku, s katero se lahko uporabnik poveže z uporabo aplikacije Oddaljeno namizje za Chrome. Izvorna storitev je zapakirana in se izvaja ločeno od brskalnika <ph name="PRODUCT_NAME" />.

      Ti pravilniki so prezrti, če ni nameščen
      gostitelj za Oddaljeno namizje za Chrome.</translation>
<translation id="7202925763179776247">Omogoči omejitve prenosov</translation>
<translation id="7207095846245296855">Uveljavi Google Varno iskanje</translation>
<translation id="7211368186050418507">Časovnega pasu nikoli ne zaznaj samodejno</translation>
<translation id="7216442368414164495">Uporabnikom dovoli prijavo za razširjeno poročanje za Varno brskanje</translation>
<translation id="7221822638060296742">Omogoča nastavitev spletnih mest, ki jim je dovoljeno samodejno izvajanje vtičnika <ph name="FLASH_PLUGIN_NAME" />. Samodejno izvajanje vtičnika <ph name="FLASH_PLUGIN_NAME" /> je lahko dovoljeno za vsa spletna mesta ali prepovedano za vsa spletna mesta.

          Možnost »Klikni za predvajanje« dovoli izvajanje vtičnika <ph name="FLASH_PLUGIN_NAME" />, vendar mora uporabnik najprej klikniti označbo mesta.

          Samodejno predvajanje je dovoljeno samo za domene, ki so izrecno navedene v pravilniku <ph name="PLUGINS_ALLOWED_FOR_URLS_POLICY_NAME" />. Če želite samodejno predvajanje omogočiti za vsa spletna mesta, razmislite o tem, da bi na ta seznam dodali http://* in https://*.

          Če ta pravilnik ni nastavljen, bo lahko uporabnik to nastavitev spremenil ročno.</translation>
<translation id="7222749588229362483">Omogoča, da se izbrani pravilniki združijo, če izvirajo iz različnih virov, vendar so enakih obsegov in ravni.

        Do združevanja pride tako, da se združijo slovarski ključi prve ravni iz vsakega vira. V primeru spora med ključi je uporabljen ključ, ki prihaja iz vira z največjo prednostjo.

        Če je pravilnik na seznamu, bodo v primeru spora med viroma, če sta enakih obsegov in ravni, vrednosti združene v novem slovarju pravilnikov.

        Če je pravilnik na seznamu, bo v primeru spora med viroma, ki sta tudi različnih obsegov in/ali ravni, uporabljen pravilnik z največjo prednostjo.

        Če pravilnika ni na seznamu, bo v primeru spora med viroma, obsegi in/ali ravnijo uporabljen pravilnik z največjo prednostjo.</translation>
<translation id="7229975860249300121">Vsebuje regularni izraz, ki se uporablja za ugotavljanje, katere Google Račune je mogoče nastaviti kot primarne račune brskalnika v brskalniku <ph name="PRODUCT_NAME" /> (tj. račun, ki je izbran med potekom omogočanja sinhronizacije).

      Če uporabnik poskusi nastaviti primarni račun brskalnika z uporabniškim imenom, ki se ne ujema s tem vzorcem, se prikaže ustrezna napaka.

      Če ta pravilnik ni nastavljen oziroma je prazen, lahko uporabnik nastavi kateri koli Google Račun kot primarni račun brskalnika v brskalniku <ph name="PRODUCT_NAME" />.</translation>
<translation id="723103540848640830">Nastavi najmanjšo dolžino kode PIN za zaklenjen zaslon</translation>
<translation id="7232816984286843471">Če je pravilnik onemogočen, nepovezanim uporabnikom ne bo dovoljeno uporabljati Crostinija.

      Če pravilnik ni nastavljen ali je omogočen, je uporaba Crostinija omogočena za vse uporabnike, če to omogočajo tudi druge nastavitve.
      Vsi trije pravilniki – VirtualMachinesAllowed, CrostiniAllowed in DeviceUnaffiliatedCrostiniAllowed – morajo biti omogočeni, ko se prijavijo za omogočanje izvajanja Crostinija.
      Če je ta pravilnik spremenjen na onemogočeno stanje, se uporablja za zagon novih vsebnikov Crostinija, vendar ne ustavi vsebnikov, ki se že izvajajo.</translation>
<translation id="7234280155140786597">Imena prepovedanih gostiteljev izvornega pošiljanja sporočil (ali * za vse)</translation>
<translation id="7236775576470542603">Nastavitev privzete vrste lupe, omogočene na prijavnem zaslonu.

          Če je ta pravilnik omogočen, določa vrsto lupe, omogočeno, ko je prikazan prijavni zaslon. Če ga nastavite na »Brez«, bo lupa izklopljena.

          Če pravilnik omogočite, ga lahko uporabniki začasno preglasijo tako, da omogočijo ali onemogočijo lupo, vendar ta nastavitev ni trajna in privzeta nastavitev se obnovi vsakič, ko je ponovno prikazan prijavni zaslon ali kadar je uporabnik eno minuto nedejaven na prijavnem zaslonu.

          Če pravilnik ni vklopljen, je lupa onemogočena, ko je prvič prikazan prijavni zaslon. Uporabniki lahko kadar koli omogočijo ali onemogočijo lupo, pri čemer se njegovo stanje na prijavnem zaslonu ohrani med uporabniki.</translation>
<translation id="7249828445670652637">Omogočanje uporabe potrdil sistema <ph name="PRODUCT_OS_NAME" /> aplikacijam ARC</translation>
<translation id="7252681704926980614">Pošiljanje uporabniškega imena in imena datoteke strežniku izvornih tiskalnikov z vsakim tiskalnim opravilom. Privzeta nastavitev je, da se ne pošiljata.

      Če ta pravilnik nastavite na »true«, onemogočite tudi tiskalnike, ki uporabljajo druge protokole kot IPPS, USB ali IPP-over-USB, ker uporabniškega imena in imena datoteke ni dovoljeno odkrito pošiljati prek omrežja.</translation>
<translation id="7258823566580374486">Omogočanje zakrivanja gostiteljev za oddaljeni dostop</translation>
<translation id="7260204423892780600">Nadzira nastavitve za Pomočnika Google.</translation>
<translation id="7260277299188117560">Samodejno posodabljanje prek p2p omogočeno</translation>
<translation id="7261252191178797385">Slika za ozadje naprave</translation>
<translation id="7264704483008663819">Ta pravilnik je zastarel v M68. Namesto tega uporabite pravilnik DeveloperToolsAvailability.

      Onemogoči orodja za razvijalce in konzolo JavaScript.

      Če to nastavitev omogočite, dostop do orodij za razvijalce ne bo mogoč in elementov na spletnih mestih ne bo več mogoče pregledovati. Vse bližnjične tipke in vnosi v meniju ali kontekstnem meniju za odpiranje orodij za razvijalce in konzole JavaScript bodo onemogočeni.

      Če to možnost onemogočite ali je ne nastavite, lahko uporabnik uporablja orodja za razvijalce in konzolo JavaScript.

      Če je nastavljen pravilnik DeveloperToolsAvailability, je vrednost pravilnika DeveloperToolsDisabled prezrta.</translation>
<translation id="7266471712301230894">Ta funkcija je z brskalnikom <ph name="PRODUCT_NAME" /> različice 64 odstranjena.

      Samodejno iskanje in samodejna namestitev manjkajočih vtičnikov nista več podprta.</translation>
<translation id="7267809745244694722">Predstavnostne tipke privzeto delujejo kot funkcije tipke</translation>
<translation id="7271085005502526897">Uvoz domače strani privzetega brskalnika ob prvem zagonu</translation>
<translation id="7273823081800296768">Če je ta nastavitev omogočena ali ni nastavljena, lahko uporabniki izberejo seznanjanje odjemalcev in gostiteljev ob vzpostavljanju povezave, tako da ni treba vsakič vnesti kode PIN.

          Če je ta nastavitev onemogočena, ta funkcija ne bo na voljo.</translation>
<translation id="7274077256421167535">Omogočanje souporabe energije prek USB-ja</translation>
<translation id="7275334191706090484">Upravljani zaznamki</translation>
<translation id="7291084543582732020">Če to nastavitev omogočite, lahko uporabniki uporabljajo funkcijo Smart Lock, če so izpolnjene zahteve za funkcijo.

      Če onemogočite to nastavitev, uporabniki ne smejo uporabljati funkcije Smart Lock.

      Če ta pravilnik ni nastavljen, funkcija privzeto ni dovoljena za uporabnike, ki jih upravlja podjetje, in je dovoljena za uporabnike, ki niso upravljani.</translation>
<translation id="7295019613773647480">Omogoči zaščitene uporabnike</translation>
<translation id="7301543427086558500">Določa seznam nadomestnih URL-jev, ki jih je mogoče uporabiti za pridobivanje iskalnih izrazov iz iskalnika. URL-ji morajo vsebovati niz <ph name="SEARCH_TERM_MARKER" />, ki bo uporabljen za pridobivanje iskalnih izrazov.

          Ta pravilnik je izbiren. Če ni nastavljen, za pridobivanje iskalnih izrazov ne bodo uporabljeni nadomestni URL-ji.

          Ta pravilnik velja le, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="7302043767260300182">Časovni zamik zaklepa zaslona, če se napaja iz električnega omrežja</translation>
<translation id="7311458740754205918">Če je ta pravilnik omogočen ali ni nastavljen, bodo na novem zavihku s povezavami morda prikazani predlogi vsebine na podlagi uporabnikove zgodovine brskanja, zanimanj ali lokacije.

      Če je ta pravilni onemogočen, samodejno ustvarjeni predlogi vsebine na novem zavihku s povezavami ne bodo prikazani.</translation>
<translation id="7313793931637495417">Ta pravilnik nadzira, ali se sporočajo podatki o različici, kot so različica operacijskega sistema, okolje operacijskega sistema, arhitektura operacijskega sistema, različica izdelka <ph name="PRODUCT_NAME" /> in kanal izdelka <ph name="PRODUCT_NAME" />.

      Če ta pravilnik ni nastavljen ali je omogočen, se zbirajo podatki o različici.
      Če je ta pravilnik onemogočen, se podatki o različici ne zbirajo.

      Ta pravilnik se uporablja samo, če je omogočena razširitev <ph name="CHROME_REPORTING_EXTENSION_NAME" />, računalnik pa je včlanjen v pravilnik <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="7323896582714668701">Dodatni parametri ukazne vrstice za <ph name="PRODUCT_NAME" /></translation>
<translation id="7326394567531622570">Podobno Wipe (vrednost 2), vendar poskuša ohraniti žetone za prijavo, da se uporabniku ni treba prijaviti znova.</translation>
<translation id="7329842439428490522">Določa trajanje uporabnikove nedejavnosti, po preteku katere se zaslon izklopi, če se napaja iz akumulatorja.

          Če je pravilnik nastavljen na vrednost nad nič, določa, koliko časa mora biti uporabnik nedejaven, preden <ph name="PRODUCT_OS_NAME" /> izklopi zaslon.

          Če je pravilnik nastavljen na vrednost nič, <ph name="PRODUCT_OS_NAME" /> ne izklopi zaslona, ko uporabnik postane nedejaven.

          Če pravilnik ni nastavljen, se uporabi privzeto trajanje.

          Vrednost pravilnika naj bo navedena v milisekundah. Vrednosti morajo biti manjše ali enake kot časovni zamik nedejavnosti.</translation>
<translation id="7329968046053403405">Določa vrsto računov, ki jih ponuja aplikacija za preverjanje pristnosti za Android, ki podpira preverjanje pristnosti z razširitvijo <ph name="HTTP_NEGOTIATE" /> (npr. preverjanje pristnosti Kerberos). Ti podatki bi morali biti na voljo od ponudnika aplikacije za preverjanje pristnosti. Več informacij je na voljo na https://goo.gl/hajyfN.

          Če ni določena nobena nastavitev, je v Androidu onemogočeno preverjanje pristnosti z razširitvijo <ph name="HTTP_NEGOTIATE" />.</translation>
<translation id="7331962793961469250">Ko je pravilnik nastavljen na »True«, se promocije za aplikacije iz Spletne trgovine Chrome ne bodo prikazale na novem zavihku s povezavami.

      Če to možnost nastavite na »False« ali je ne nastavite, se bodo promocije za aplikacije iz Spletne trgovine Chrome prikazovale na novem zavihku s povezavami.</translation>
<translation id="7332963785317884918">Ta pravilnik je zastarel. Sistem <ph name="PRODUCT_OS_NAME" /> bo vedno uporabljal strategijo čiščenja »RemoveLRU«.

      Nadzira delovanje samodejnega čiščenja v napravah s sistemom <ph name="PRODUCT_OS_NAME" />. Samodejno čiščenje sprosti prostor na disku in se sproži, ko količina nezasedenega prostora na disku doseže kritično raven.

      Če je ta pravilnik nastavljen na »RemoveLRU«, bo samodejno čiščenje odstranjevalo uporabnike iz naprave. Uporabniki bodo odstranjeni glede na čas, ki je pretekel od njihove zadnje prijave, pri čemer bodo najprej odstranjeni uporabniki z najdaljšim časom od zadnje prijave. Odstranjevanje se bo končalo takoj, ko bo na voljo dovolj prostora.

      Če je ta pravilnik nastavljen na »RemoveLRUIfDormant«, bo samodejno čiščenje odstranjevalo uporabnike, ki se niso prijavili vsaj tri mesece. Nato bodo odstranjeni uporabniki z naslednjim najdaljšim časom od zadnje prijave. Odstranjevanje se bo končalo takoj, ko bo na voljo dovolj prostora.

      Če ta pravilnik ni nastavljen, samodejno čiščenje uporablja privzeto vgrajeno strategijo. Trenutno je to strategija »RemoveLRUIfDormant«.</translation>
<translation id="7336785017449297672">Nadzira nastavitve ure in časovnega pasu.</translation>
<translation id="7336878834592315572">Ohrani piškotke za obdobje trajanja seje</translation>
<translation id="7339315111520512972">Vsili izvajanje omrežne kode v procesu brskalnika</translation>
<translation id="7340034977315324840">Pošiljanje podatkov o času dejavnosti v napravi</translation>
<translation id="7343497214039883642">Datoteka s konfiguracijami tiskalnikov v podjetjih za naprave</translation>
<translation id="735902178936442460">Ta pravilnik nadzira, ali se sporočajo podatki, s katerimi je mogoče prepoznati naprave, na primer ime naprave in omrežni naslovi.

      Če ta pravilnik ni nastavljen ali je omogočen, se zbirajo podatki, s katerimi je mogoče prepoznati naprave.
      Če je ta pravilnik onemogočen, se podatki, s katerimi je mogoče prepoznati naprave, ne zbirajo.

      Ta pravilnik se uporablja samo, če je omogočena razširitev <ph name="CHROME_REPORTING_EXTENSION_NAME" />, računalnik pa je včlanjen v pravilnik <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="737655323154569539">Omeji velikost tiskanih strani. Če pravilnik ni nastavljen ali je nabor prazen, ni omejitve.</translation>
<translation id="7389872682701720082">Če omogočite to nastavitev, se vtičniki, ki niso zastareli, vedno izvedejo.

      Če je ta nastavitev onemogočena ali ni nastavljena, bodo uporabniki morali dati dovoljenje za izvajanje vtičnikov, ki terjajo pooblastitev. To so vtičniki, ki lahko ogrozijo varnost.</translation>
<translation id="7417972229667085380">Odstotek prilagoditve časovnega zamika nedejavnosti v načinu predstavitve (zastarelo)</translation>
<translation id="7421483919690710988">Nastavi velikost predpomnilnika medija v bajtih</translation>
<translation id="7424751532654212117">Seznam izjem za seznam onemogočenih vtičnikov</translation>
<translation id="7426112309807051726">Določa, ali je onemogočena optimizacija funkcije <ph name="TLS_FALSE_START" />. Ta pravilnik se iz zgodovinskih razlogov imenuje DisableSSLRecordSplitting.

      Če ta pravilnik ni nastavljen ali je onemogočen, je funkcija <ph name="TLS_FALSE_START" /> omogočena. Če je omogočen, je funkcija <ph name="TLS_FALSE_START" /> onemogočena.</translation>
<translation id="7433714841194914373">Omogoči Dinamično iskanje</translation>
<translation id="7434202861148928348">Konfiguriranje imen domene, potrebnih za odjemalce za oddaljeni dostop</translation>
<translation id="7443616896860707393">Ukazni pozivi HTTP Basic Auth iz več izvorov</translation>
<translation id="7454519673779830548">Doda vnaprej izpolnjene račune za Kerberos. Če se poverilnice za Kerberos ujemajo s poverilnicami za prijavo, je mogoče konfigurirati račun, da znova uporabi poverilnice za prijavo. To storite tako, da za glavno ime in geslo navedete »${{LOGIN_EMAIL}}« in »${{PASSWORD}}«, da je mogoče pridobiti vstopnico za Kerberos samodejno, če ni konfigurirano preverjanje pristnosti v dveh korakih. Uporabniki ne morejo spreminjati računov, dodanih prek tega pravilnika.

          Če je ta pravilnik omogočen, je seznam računov, ki jih določa pravilnik, dodan v nastavitve računov za Kerberos.

          Če je ta pravilnik onemogočen ali ni nastavljen, ni v nastavitve računov za Kerberos dodan noben račun in vsi prej dodani računi s tem pravilnikom so odstranjeni. Uporabniki lahko še vedno ročno dodajo račune, če je omogočen pravilnik »Uporabniki lahko dodajo račune za Kerberos«.</translation>
<translation id="7458437477941640506">Brez povrnitve na ciljno različico, če je različica operacijskega sistema novejša kot ciljna. Onemogočene so tudi posodobitve.</translation>
<translation id="7464991223784276288">Omejitev piškotkov z ujemajočih se URL-jev na trenutno sejo</translation>
<translation id="7469554574977894907">Omogoči predloge za iskanje</translation>
<translation id="7485481791539008776">Pravila za izbiro privzetega tiskalnika</translation>
<translation id="7485730741952775732">Če je ta pravilnik nastavljen, bo gostitelj za oddaljeni dostop na tem URL-ju preverjal žetone za preverjanje pristnosti odjemalcev za oddaljeni dostop, da lahko sprejme povezave. Uporabljati ga je treba v povezavi s pravilnikom RemoteAccessHostTokenUrl.

          Ta funkcija je trenutno onemogočena na strani strežnika.</translation>
<translation id="749556411189861380">Poročanje o različici operacijskega sistema in vdelane programske opreme včlanjenih naprav.

      Če nastavitev ni nastavljena ali je nastavljena na »True«, včlanjene naprave redno poročajo o različici operacijskega sistema in vdelane programske opreme. Če je nastavitev nastavljena na »False«, se podatki o različici ne poročajo.</translation>
<translation id="7498946151094347510">Določa tiskalnike, ki jih uporabnik ne more uporabljati.

      Ta pravilnik se uporablja samo, če je za pravilnik <ph name="PRINTERS_BLACKLIST" /> izbrana možnost <ph name="DEVICE_PRINTERS_ACCESS_MODE" />.

      Če se uporablja ta pravilnik, so uporabniku na voljo vsi tiskalniki z izjemo ID-jev, navedenih v tem pravilniku. ID-ji morajo ustrezati polju »id« ali »guid« v datoteki, določeni v pravilniku <ph name="DEVICE_PRINTERS_POLICY" />.
      </translation>
<translation id="7506269062143646163">Omogoča podporo za podpisano izmenjavo HTTP (SXG).

          Če ta pravilnik ni nastavljen ali je omogočen, bo Google Chrome sprejemal spletno vsebino, prikazano kot podpisane izmenjave HTTP.

          Če je ta pravilnik onemogočen, podpisanih izmenjav HTTP ni mogoče naložiti.</translation>
<translation id="7511361072385293666">Če je ta pravilnik omogočen ali ni nastavljen, je uporaba protokola QUIC v brskalniku <ph name="PRODUCT_NAME" /> dovoljena.
      Če je ta pravilnik onemogočen, uporaba protokola QUIC ni dovoljena.</translation>
<translation id="7517845714620372896">Določa odstotek svetlosti zaslona.
          Če je ta pravilnik nastavljen, je prvotna svetlost zaslona prilagojena na vrednost v pravilniku, uporabnik pa jo lahko pozneje spremeni. Funkcije samodejnega prilagajanja svetlosti so onemogočene.
          Če ta pravilnik ni nastavljen, ne vpliva na uporabniške kontrolnike za nastavitev zaslona in funkcije samodejnega prilagajanja svetlosti.
          Vrednosti pravilnika morajo biti navedene v odstotkih, in sicer v obsegu od 0 do 100.</translation>
<translation id="7517846421386644905">Skrbniku omogoča nadziranje, ali naj diagnostična storitev wilco in kontrolnik telemetrije (DTC) zbirata, obdelujeta in sporočata telemetrijo in diagnostične podatke.

      Če je pravilnik onemogočen ali ni nastavljen, je orodje DTC izklopljeno in so zbiranje, obdelava ter sporočanje telemetrije in diagnostičnih podatkov naprave onemogočeni.
      Če je orodje wilco DTC v dani napravi na voljo in je pravilnik omogočen, so zbiranje, obdelava in poročanje telemetrije ter diagnostičnih podatkov vklopljeni.</translation>
<translation id="7519251620064708155">Dovoli ustvarjanje ključev na teh spletnih mestih</translation>
<translation id="7529100000224450960">Omogoča nastavitev seznama vzorcev URL-jev, s katerim so določena spletna mesta, ki lahko odpirajo pojavna okna.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta uporabljena splošna privzeta vrednost iz pravilnika »DefaultPopupsSetting«, kadar je ta nastavljen, ali iz uporabnikove osebne konfiguracije, kadar pravilnik »DefaultImagesSetting« ni nastavljen.</translation>
<translation id="7529144158022474049">Faktor razpršitve samodejnega posodabljanja</translation>
<translation id="7534199150025803530">Ta pravilnik ne vpliva na aplikacijo Google Drive za Android. Če želite preprečiti uporabo Googla Drive prek povezav v mobilnih omrežij, onemogočite namestitev aplikacije Google Drive za Android.</translation>
<translation id="7540622499178214923">Omogoča diagnostično storitev wilco in kontrolnik telemetrije</translation>
<translation id="7547549430720182663">Združi</translation>
<translation id="7553535237300701827">Če je ta pravilnik nastavljen, je glede na vrednost nastavitve preverjanje pristnosti pri prijavi takšno:

      Če je nastavljen na GAIA, je prijava izvedena prek običajnega preverjanja pristnosti GAIA.

      Če je nastavljen na SAML_INTERSTITIAL, je pri prijavi prikazan vmesni zaslon, na katerem se lahko uporabnik odloči, ali bo nadaljeval preverjanje pristnosti prek SAML IdP domene za včlanitev naprave ali se bo vrnil na običajno prijavo GAIA.</translation>
<translation id="755951849901630953">Omogoča posodobitve komponent za vse komponente v izdelku <ph name="PRODUCT_NAME" />, če pravilnik ni nastavljen ali je nastavljen na »True«.

      Če je pravilnik nastavljena na »False«, so posodobitve komponent onemogočene. Vendar pa so nekatere komponente izvzete iz tega pravilnika: onemogočene niso posodobitve komponent, ki ne vsebujejo izvedljive kode, bistveno ne spreminjajo delovanja brskalnika ali so pomembne za varnost brskalnika.
      Primeri takih komponent so na primer seznami ukinjenih potrdil in podatki Varnega brskanja.
      Več informacij o Varnem brskanju je na voljo na https://developers.google.com/safe-browsing.</translation>
<translation id="7566878661979235378">Vrsta preverjanja pristnosti pri prijavi SAML</translation>
<translation id="757395965347379751">Če je ta nastavitev omogočena, <ph name="PRODUCT_NAME" /> dovoli potrdila, podpisana z algoritmom SHA-1, če se uspešno potrdijo in so v verigi s potrdili lokalno nameščenega overitelja.

      Upoštevajte, da je ta pravilnik odvisen od tega, ali sklad za potrjevanje potrdil operacijskega sistema dovoli podpise z algoritmom SHA-1. Če posodobitev operacijskega sistema spremeni obravnavo potrdil, podpisanih z algoritmom SHA-1, ta pravilnik ne učinkuje več. Namen tega pravilnika je delovati kot začasna rešitev, ki daje podjetjem na voljo več časa, da prenehajo uporabljati algoritem SHA-1. Ta pravilnik bo odstranjen okoli 1. januarja 2019 oziroma na ta datum.

      Če ta pravilnik ni nastavljen ali je onemogočen, <ph name="PRODUCT_NAME" /> upošteva javno najavljen razpored za zastaranje algoritma SHA-1.</translation>
<translation id="7578049687634719313">Ta pravilnik nadzira čakalno dobo pred zagonom nadomestnega brskalnika v milisekundah.

      Če ta pravilnik ni nastavljen ali je nastavljen na 0, se ob krmarjenju na določeni URL ta takoj odpre v nadomestnem brskalniku.

      Če je ta pravilnik nastavljen na številko, Chrome toliko milisekund prikazuje sporočilo, nato odpre nadomestni brskalnik.</translation>
<translation id="7593523670408385997">Nastavi velikost predpomnilnika, ki ga bo izdelek <ph name="PRODUCT_NAME" /> uporabljal za shranjevanje predpomnjenih datotek na disku.

      Če nastavite ta pravilnik, bo <ph name="PRODUCT_NAME" /> uporabil navedeno velikost predpomnilnika, ne glede na to, ali je uporabnik nastavil zastavico »--disk-cache-size«. Vrednost, navedena v tem pravilniku, ni fiksna omejitev, temveč predlog predpomnilniškemu sistemu. Vrednosti pod nekaj megabajti so premajhne in bodo zaokrožene na razumno minimalno vrednost.

      Če je vrednost tega pravilnika nastavljena na 0, bo uporabljena privzeta velikost predpomnilnika, vendar je uporabnik ne bo mogel spremeniti.

      Če ta pravilnik ni nastavljen, bo uporabljena privzeta vrednost in jo bo uporabnik lahko preglasil z zastavico »--disk-cache-size«.</translation>
<translation id="759389052790680884">Nastavitev prilagojene točke ustavitve polnjenja akumulatorja v odstotkih.

          Akumulator se neha polniti, ko doseže prilagojeno vrednost za ustavitev polnjenja akumulatorja.

          DeviceBatteryChargeCustomStartCharging mora biti manj kot DeviceBatteryChargeCustomStopCharging.

          Ta pravilnik se uporablja samo, če je DeviceBatteryChargeMode nastavljeno na »custom« (prilagojeno).

          Če ta pravilnik ni konfiguriran ali nastavljen, se uporabi običajen način polnjenja akumulatorja.</translation>
<translation id="759957074386651883">Nastavitve funkcije varnega brskanja</translation>
<translation id="7604169113182304895">Aplikacije za Android se lahko prostovoljno odločijo, da bodo upoštevale ta seznam. V to jih ni mogoče prisiliti.</translation>
<translation id="7612157962821894603">Sistemske zastavice, ki naj se uporabijo ob zagonu programa <ph name="PRODUCT_NAME" /></translation>
<translation id="7614663184588396421">Seznam onemogočenih protokolnih shem</translation>
<translation id="7617319494457709698">Ta pravilnik določa dovoljene razširitve, ki lahko uporabljajo metodo <ph name="CHALLENGE_USER_KEY_FUNCTION" /> API-ja <ph name="ENTERPRISE_PLATFORM_KEYS_API" /> za potrjevanje na daljavo. Razširitve, ki lahko uporabljajo API, morate dodati na ta seznam.

          Če razširitve ni na seznamu ali seznam ni nastavljen, poziv API-ju ne bo uspel in bo vrnjena koda napake.</translation>
<translation id="7620869951155758729">Ta pravilnik določa konfiguracijo, ki se uporablja za ustvarjanje in preverjanje kode za starševski dostop.

      |current_config| se vedno uporablja za ustvarjanje kode za dostop in se uporablja za preverjanje kode za dostop samo, ko je ni mogoče preveriti s |future_config|.
      |future_config| je primarna konfiguracija, ki se uporablja za preverjanje kode za dostop.
      |old_configs| se uporablja za preverjanje kode za dostop samo, če je ni mogoče preveriti s |future_config| in |current_config|.

      Pričakovani način uporabe tega pravilnika je postopna menjava konfiguracije kode za dostop. Nova konfiguracija je vedno dana v |future_config| in istočasno je
      obstoječa vrednost premaknjena v |current_config|. Prejšnje vrednosti |current_config| so premaknjene v |old_configs| in so odstranjene po koncu cikla menjave.

      Ta pravilnik se uporablja samo za otroka.
      Če je ta pravilnik nastavljen, je kodo za starševski dostop mogoče preveriti v napravi otroka.
      Če ta pravilnik ni nastavljen, kode za starševski dostop ni mogoče preveriti v napravi otroka.</translation>
<translation id="7625444193696794922">Določa kanal za izdajo, na katerega naj bo zaklenjena ta naprava.</translation>
<translation id="7632724434767231364">Ime knjižnice GSSAPI</translation>
<translation id="7635471475589566552">Določa območne nastavitve programa  <ph name="PRODUCT_NAME" /> in prepreči uporabnikom, da jih spreminjajo.

      Če to nastavitev omogočite, <ph name="PRODUCT_NAME" /> uporabi nastavljene območne nastavitve. Če nastavljene območne nastavitve niso podprte, bo uporabljena nastavitev »en-US«.

     Če to nastavitev onemogočite ali je ne nastavite, <ph name="PRODUCT_NAME" /> uporabi prednostne območne nastavitve, ki jih izbere uporabnik (če so nastavljene), sistemske območne nastavitve ali rezervne območne nastavitve (»en-US«).</translation>
<translation id="7641363659597330616">Konfigurira vrste prenosov, ki jih bo izdelek <ph name="PRODUCT_NAME" /> popolnoma blokiral, ne da bi uporabniki imeli možnost preglasiti varnostno odločitev.

      Če nastavite ta pravilnik, bo izdelek <ph name="PRODUCT_NAME" /> preprečil določene vrste prenosov in uporabnikom ne bo dovolil, da obidejo varnostna opozorila.

      Če je izbrana možnost »Blokiraj nevarne prenose«, so dovoljeni vsi prenosi, razen tistih z opozorili Varnega brskanja.

      Če je izbrana možnost »Blokiraj morebitne nevarne prenose«, so dovoljeni vsi prenosi, razen tistih z opozorili Varnega brskanja o morebitnih nevarnih prenosih.

      Če je izbrana možnost »Blokiraj vse prenose«, so blokirani vsi prenosi.

      Če ta pravilnik ni nastavljen (ali je izbrana možnost »Ni posebnih omejitev«), se za prenose uporabijo običajne varnostne omejitve na podlagi rezultatov analiziranja Varnega brskanja.

      Upoštevajte, da te omejitve veljajo samo za prenose, sprožene iz vsebine spletne strani, in za možnost priročnega menija »povezava za prenos ...«. Te omejitve ne veljajo niti za shranjevanje/prenos trenutno prikazane strani niti za shranjevanje v obliki PDF iz možnosti tiskanja.

      Več informacij o Varnem brskanju je na voljo na strani https://developers.google.com/safe-browsing.</translation>
<translation id="7643883929273267746">Omejitev računov, ki so vidni v storitvi <ph name="PRODUCT_NAME" /></translation>
<translation id="7644825865811580663">Če je ta pravilnik omogočen, <ph name="PRODUCT_NAME" /> brezpogojno poveča prvo okno, prikazano pri prvem izvajanju.
      Če je ta pravilnik onemogočen ali ni konfiguriran, hevristični postopek glede na velikost zaslona določi, ali se prvo prikazano okno poveča.</translation>
<translation id="7651739109954974365">Določa, ali je podatkovno gostovanje za napravo omogočeno. Če je pravilnik omogočen, je podatkovno gostovanje omogočeno. Če ni nastavljen ali je onemogočen, podatkovno gostovanje ni na voljo.</translation>
<translation id="7657261947024629645">Optimizacija za učinkovito delovanje.</translation>
<translation id="7673194325208122247">Časovno obdobje (milisekunde)</translation>
<translation id="7676708657861783864">Piškotki, ki jih nastavijo strani, ki se ujemajo s temi vzorci URL, so omejeni na trenutno sejo – izbrisani so ob zaprtju brskalnika.

          Za URL-je, ki niso zajeti v vzorce, določene tukaj, ali za URL-je, če ta pravilnik ni nastavljen, se uporabi globalna privzeta vrednost iz pravilnika »DefaultCookiesSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.

          Če se <ph name="PRODUCT_NAME" /> izvaja v ozadju, seje ni mogoče zapreti, ko je zaprto zadnje okno brskalnika, ampak je aktivna do zaprtja brskalnika. Več informacij o konfiguriranju tega delovanja je na voljo v pravilniku »BackgroundModeEnabled«.

          Glejte tudi pravilnika »CookiesAllowedForUrls« in »CookiesBlockedForUrls«. V teh treh pravilnikih ne sme biti vzorcev URL v sporu – ni določeno, kateri pravilnik ima prednost.

          Če je pravilnik »RestoreOnStartup« nastavljen za obnovitev URL-jev iz prejšnje seje, ta pravilnik ne bo upoštevan in piškotki za ta spletna mesta bodo trajno shranjeni.</translation>
<translation id="7683777542468165012">Dinamična osvežitev pravilnika</translation>
<translation id="7687943045976362719">Če je ta pravilnik nastavljen, določene vrste vsebine upravlja <ph name="PRODUCT_FRAME_NAME" />.

         Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi privzeti upodabljalnik. (Za konfiguriranje privzetega upodabljalnika se morda uporabi pravilnik <ph name="CHROME_FRAME_RENDERER_SETTINGS_POLICY_NAME" />.)</translation>
<translation id="7694245791806617022">Nadzira, ali je v pogovornem oknu preverjanja pristnosti Kerberos omogočena funkcija »Zapomni si geslo«. Gesla so shranjena šifrirana na disku, do njih pa lahko dostopa samo strežniška storitev sistema Kerberos, in sicer med uporabniško sejo.

          Če je ta pravilnik omogočen ali ni nastavljen, se lahko uporabniki odločijo, ali naj se gesla za Kerberos zapomnijo, da jih ni treba znova vnašati. Vstopnice za Kerberos so pridobljene samodejno, razen če je potrebno dodatno preverjanje pristnosti (preverjanje pristnosti v dveh korakih).

          Če je ta pravilnik onemogočen, se gesla nikoli ne zapomnijo in vsa prej shranjena gesla so odstranjena. Uporabniki morajo vnesti geslo, vsakič ko želijo opraviti preverjanje pristnosti s sistemom Kerberos. Glede na nastavitve strežnika se to običajno zgodi v obdobju med 8 urami in več meseci.</translation>
<translation id="7694807474048279351">Načrtovanje samodejnega vnovičnega zagona po namestitvi posodobitve za <ph name="PRODUCT_OS_NAME" />.

      Če je ta pravilnik vklopljen, se načrtuje samodejni vnovični zagon, kadar je potreben za dokončanje postopka posodobitve za <ph name="PRODUCT_OS_NAME" />. Samodejni vnovični zagon se v napravi načrtuje za določeno uro, vendar se lahko odloži do 24 ur, če nekdo trenutno uporablja napravo.

      Če je ta pravilnik izklopljen, se po namestitvi posodobitve za <ph name="PRODUCT_OS_NAME" /> ne načrtuje vnovični zagon. Postopek posodobitve se dokonča, ko uporabnik naslednjič znova zažene napravo.

      Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

      Opomba: Samodejni vnovični zagoni so trenutno omogočeni samo, ko je prikazan prijavni zaslon ali poteka seja aplikacije za kiosk. To se bo v prihodnosti spremenilo in bo pravilnik vedno veljal ne glede na to, ali poteka seja katere koli vrste.</translation>
<translation id="7701341006446125684">Nastavitev velikosti predpomnilnika za aplikacije in razširitve (v bajtih)</translation>
<translation id="7709537117200051035">Slovar, v katerem so imena gostiteljev preslikana na logično zastavico, ki določa, ali naj bo dostop do gostitelja dovoljen (True) ali blokiran (False).

          Ta pravilnik je namenjen za notranjo uporabo v programu <ph name="PRODUCT_NAME" />.</translation>
<translation id="7712109699186360774">Vprašaj vsakič, ko želi spletno mesto dostop do kamere in/ali mikrofona</translation>
<translation id="7713608076604149344">Omejitve prenosov</translation>
<translation id="7715711044277116530">Odstotek prilagoditve časovnega zamika zatemnitve zaslona v načinu predstavitve</translation>
<translation id="7716781462866245042">Nastavitev dnevne konfiguracije naprednega načina polnjenja akumulatorja.

          Ta pravilnik se uporablja samo, če je omogočen pravilnik DeviceAdvancedBatteryChargeModeEnabled.

          Če ta pravilnik ni konfiguriran ali ni nastavljen, bo napredni način polnjenja akumulatorja vedno onemogočen.

          Opomba: <ph name="CHARGE_START_TIME_FIELD_NAME" /> mora biti manj kot <ph name="CHARGE_END_TIME_FIELD_NAME" />.

          Opomba: dovoljene vrednosti za polje <ph name="MINUTE_FIELD_NAME" /> v poljih<ph name="CHARGE_START_TIME_FIELD_NAME" /> in <ph name="CHARGE_END_TIME_FIELD_NAME" /> so 0, 15, 30, 45.</translation>
<translation id="7717938661004793600">Konfiguriranje funkcij za ljudi s posebnimi potrebami za <ph name="PRODUCT_OS_NAME" />.</translation>
<translation id="7724994675283793633">Ta pravilnik omogoča protokol HTTP/0.9 za vrata, ki niso 80 (HTTP) ali 443 (HTTPS).

      Ta pravilnik je privzeto onemogočen. Če je omogočen, so uporabniki izpostavljeni tej varnostni težavi: https://crbug.com/600352.

      Namen tega pravilnika je omogočiti podjetjem, da v obstoječih strežnikih prenehajo uporabljati protokol HTTP/0.9. Pravilnik bo v prihodnosti odstranjen.

      Če ta pravilnik ni nastavljen, bo protokol HTTP/0.9 za vrata, ki niso privzeta, onemogočen.</translation>
<translation id="7726421241038987229">
      To nastavitev, SitePerProcess, je mogoče uporabljati, da se uporabnikom ne dovoli onemogočanja privzetega delovanja osamitve vseh spletnih mest. Upoštevajte, da je lahko pravilnik IsolateOrigins uporaben tudi za osamitev dodatnih, podrobnejših izvorov.
      Če je pravilnik omogočen, uporabniki ne bodo mogli onemogočiti privzetega delovanja, pri katerem se vsako spletno mesto izvaja v svojem procesu.
      Če pravilnik ni konfiguriran ali je onemogočen, bo uporabnik lahko onemogočil osamitev spletnih mest
      (lahko bo na primer uporabil vnos »Disable site isolation« (onemogoči osamitev spletnih mest) v chrome://flags).  Če nastavite, da je pravilnik onemogočen, in/ali ga ne konfigurirate, osamitve spletnih mest ne izklopite.
      V sistemu <ph name="PRODUCT_OS_NAME" /> je priporočljivo, da tudi pravilnik za naprave <ph name="DEVICE_LOGIN_SCREEN_SITE_PER_PROCESS_POLICY_NAME" /> nastavite na enako vrednost. Če se vrednosti, navedene v teh dveh pravilnikih, ne ujemajo, lahko pri vstopu v uporabniško sejo pride do zakasnitve, medtem ko se uveljavlja vrednost, ki jo določa uporabniški pravilnik.

      OPOMBA: Ta pravilnik se ne uporablja v sistemu Android. Če želite omogočiti pravilnik SitePerProcess v Androidu, uporabite nastavitev pravilnika SitePerProcessAndroid.
      </translation>
<translation id="7747447585227954402">Omogočanje napravam, da uporabljajo vtičnik <ph name="PLUGIN_VM_NAME" /> v sistemu <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="7749402620209366169">Za gostitelje oddaljenega dostopa omogoča preverjanje pristnosti v dveh korakih namesto z uporabniško določenim PIN-om.

          Če je ta nastavitev omogočena, mora uporabnik pri dostopu do gostitelja navesti veljavno kodo v dveh korakih.

          Če je ta nastavitev onemogočena ali ni nastavljena, koda v dveh korakih ne bo omogočena in uporabljeno bo privzeto vedenje z uporabo uporabniško določenega PIN-a.</translation>
<translation id="7750991880413385988">Odpri nov zavihek s povezavami</translation>
<translation id="7754704193130578113">Pred prenosom vprašaj, kam želim shraniti vsako datoteko</translation>
<translation id="7761446981238915769">Konfiguriranje seznama nameščenih aplikacij na zaslonu za prijavo</translation>
<translation id="7763479091692861127"> Vrste povezav, ki so dovoljene za uporabo za posodobitve operacijskega sistema. Posodobitve operacijskega sistema lahko zaradi svoje velikosti zelo obremenijo povezavo in lahko prinesejo dodatne stroške. Zato trenutno niso omogočene za vrste povezave, ki štejejo za drage; trenutno so to WiMax, Bluetooth in prenos podatkov v mobilnem omrežju.

      Prepoznani identifikatorji vrste povezav so »ethernet«, »wifi«, »wimax«, »bluetooth« in »cellular«.</translation>
<translation id="7763614521440615342">Prikaz predlogov vsebine na novem zavihku s povezavami</translation>
<translation id="7765879851993224640">Omogočanje uporabe prijave s funkcijo Smart Lock.</translation>
<translation id="7772346342637974431">Določa trajanje uporabnikove nedejavnosti, po preteku katere je prikazano opozorilno pogovorno okno, če se naprava napaja iz akumulatorja.

          Če je ta pravilnik nastavljen, določa trajanje, med katerim mora biti uporabnik nedejaven, preden sistem <ph name="PRODUCT_OS_NAME" /> prikaže opozorilno pogovorno okno, ki uporabnika obvesti, da se bo izvedlo dejanje ob nedejavnosti.

          Če ta pravilnik ni nastavljen, ni prikazano opozorilno pogovorno okno.

          Vrednost pravilnika mora biti navedena v milisekundah. Vrednosti morajo biti manjše ali enake kot časovni zamik nedejavnosti.

          Opozorilno sporočilo je prikazano samo, če je dejanje ob nedejavnosti odjava ali izklop.</translation>
<translation id="7774768074957326919">Uporaba sistemskih nastavitev proxyja</translation>
<translation id="7777535871204167559">Zunanje naprave za shranjevanje naj bodo samo za branje</translation>
<translation id="7788511847830146438">Za profil</translation>
<translation id="780603170519840350">Onemogoči uveljavljanje zahtev za preglednost potrdil za seznam zgoščevalnih vrednosti subjectPublicKeyInfo.

      S tem pravilnikom lahko onemogočite zahteve za razkritje za preglednost potrdil za verige potrdil, ki vsebujejo potrdila z eno od navedenih zgoščevalnih vrednosti subjectPublicKeyInfo. To omogoča, da potrdila, ki sicer ne bi bila zaupanja vredna, ker niso bila pravilno javno razkrita, še naprej uporabljate za gostitelje v poslovnih okoljih.

      Če želite, da je uveljavljanje preglednosti potrdil onemogočeno, ko je nastavljen ta pravilnik, mora biti izpolnjen eden od teh pogojev:
      1. Zgoščevalna vrednost je za subjectPublicKeyInfo strežnikovega potrdila.
      2. Zgoščevalna vrednost je za subjectPublicKeyInfo, ki se pojavlja v potrdilu overitelja potrdil v verigi potrdil, potrdilo overitelja potrdil je omejeno prek razširitve X.509v3 nameConstraints, ena ali več omejitev directoryName nameConstraints je prisotna v permittedSubtrees in directoryName vsebuje atribut organizationName.
      3. Zgoščevalna vrednost je za subjectPublicKeyInfo, ki se pojavlja v potrdilu overitelja potrdil v verigi potrdil, potrdilo overitelja potrdil ima enega ali več atributov organizationName v zadevi potrdila in strežnikovo potrdilo ima enako število atributov organizationName, ki so v istem zaporedju in imajo vrednosti, ki so do bajta identične.

      Zgoščevalna vrednost subjectPublicKeyInfo je določena s sestavljanjem imena zgoščevalnega algoritma, znaka »/« in kodiranja Base64 zgoščevalnega algoritma, uporabljenega za subjectPublicKeyInfo navedenega potrdila, ki je kodiran s pravili DER. To kodiranje Base64 ima enako obliko zapisa kot prstni odtis za SPKI, kot je opredeljeno v razdelku 2.4 dokumenta RFC 7469. Neprepoznani zgoščevalni algoritmi se prezrejo. Trenutno je edini podprt zgoščevalni algoritem »sha256«.

      Če ta pravilnik ni nastavljen, bo vsako potrdilo, ki ga je treba razkriti prek preglednosti potrdil, obravnavano kot tako, ki ni zaupanja vredno, če ni razkrito skladno s pravilnikom o preglednosti potrdil.</translation>
<translation id="7818131573217430250">Nastavitev privzetega stanja visokokontrastnega načina na prijavnem zaslonu</translation>
<translation id="7822837118545582721">Če je ta pravilnik omogočen, uporabniki ne morejo pisati na zunanje naprave za shranjevanje.

      Če je ta nastavitev onemogočena ali ni nastavljena, lahko uporabniki ustvarjajo in spreminjajo datoteke v zunanjih napravah za shranjevanje, ki podpirajo pisanje nanje.

      Pravilnik ExternalStorageDisabled ima prednost pred tem pravilnikom – če je pravilnik ExternalStorageDisabled omogočen, je dostop do zunanjih naprav za shranjevanje onemogočen in ta pravilnik je prezrt.

      Dinamično osveževanje tega pravilnika je podprto v različici M56 in novejših.</translation>
<translation id="7831595031698917016">Določa največjo zakasnitev v milisekundah med prejemom zavrnitve veljavnosti pravilnika in prenosom novega pravilnika iz storitve za upravljanje naprav

      Z nastavitvijo tega pravilnika se preglasi privzeta vrednost 5000 ms. Veljavne vrednosti za ta pravilnik so med 1000 (1 sekunda) do 300.000 (5 minut). Vrednosti, ki niso v tem obsegu, bodo spremenjene na ustrezno mejo obsega.
      Če tega pravilnika ne nastavite, bo <ph name="PRODUCT_NAME" /> uporabil privzeto vrednost 5000 ms.</translation>
<translation id="7841880500990419427">Najnižja različica TLS-ja za rezervno uporabo</translation>
<translation id="7858404742201086014">Če to nastavitev omogočite, se zastareli vtičniki uporabljajo kot običajni.

      Če jo onemogočite, zastareli vtičniki ne bodo uporabljeni in uporabniki ne bodo vprašani za dovoljenje, da se jih izvede.

      Če ta možnost ni nastavljena, bodo uporabniki vprašani za dovoljenje za izvajanje zastarelih vtičnikov.</translation>
<translation id="787125417158068494">Če je pravilnik nastavljen na »SyncDisabled« ali ni konfiguriran, potrdila sistema <ph name="PRODUCT_OS_NAME" /> niso na voljo za aplikacije ARC.

      Če je pravilnik nastavljen na »CopyCaCerts«, so vsa potrdila overitelja potrdil, nameščena s pravilnikom ONC in za katera velja <ph name="WEB_TRUSTED_BIT" />, na voljo za aplikacije ARC.</translation>
<translation id="7882585827992171421">Ta pravilnik je aktiven samo v maloprodajnem načinu.

      Določa ID razširitve, ki se uporabi kot ohranjevalnik zaslona na zaslonu za prijavo. Razširitev mora biti del paketa AppPack, ki je za to domeno nastavljen s pravilnikom »DeviceAppPack«.</translation>
<translation id="7882857838942884046">Če onemogočite storitev Google Sync, Androidovi storitvi varnostnega kopiranja in obnovitve ne bosta pravilno delovali.</translation>
<translation id="7882890448959833986">Onemogočanje opozorila glede nepodprtega operacijskega sistema</translation>
<translation id="7889788745439330797">Nadzira, ali smejo uporabniki dodajati račune za Kerberos.

          Če je ta pravilnik omogočen ali ni nastavljen, uporabniki smejo dodati račune za Kerberos prek nastavitev računov za Kerberos na strani nastavitev za osebe. Uporabniki imajo popoln nadzor nad računi, ki jih dodajo, in jih lahko spreminjajo ali odstranijo.

          Če je ta pravilnik onemogočen, uporabniki ne smejo dodati računov za Kerberos. Račune je mogoče dodati samo prek pravilnika »Konfiguriranje računov za Kerberos«. To je učinkovit način za zaklepanje računov.</translation>
<translation id="7895553628261067384">Oddaljeni dostop</translation>
<translation id="7902255855035461275">Vzorci na tem seznamu se bodo primerjali z varnostnim
      izvorom zahtevajočega URL-ja. Če je najdeno ujemanje, bo dostop do naprav
      za zajem videa dovoljen brez poziva.

      OPOMBA: ta pravilnik je bil do različice 45 podprt samo v načinu kioska.</translation>
<translation id="7912255076272890813">Konfiguracija dovoljenih vrst aplikacij/razširitev</translation>
<translation id="7922358664346625612">Ohrani zadnji zavihek odprt v Chromu.</translation>
<translation id="793134539373873765">Določa, ali se za prenos posodobitvenih paketov operacijskega sistema uporablja p2p. Če je nastavljeno na »True«, naprave dajo posodobitvene pakete v skupno rabo v krajevnem omrežju in jih poskušajo uporabiti ter s tem morebiti zmanjšati uporabo internetne pasovne širine in zamašitve. Če posodobitveni paket ni na voljo v krajevnem omrežju, ga naprava poskuša prenesti iz posodobitvenegea strežnika. Če je nastavljeno na »False« ali ni nastavljeno, se uporabi p2p.</translation>
<translation id="7933141401888114454">Omogoči ustvarjanje zaščitenih uporabnikov</translation>
<translation id="793473937901685727">Nastavitev razpoložljivosti potrdil aplikacijam ARC</translation>
<translation id="7937491150792971922">Združevanje pravilnikov o seznamu namestitev razširitev iz več virov</translation>
<translation id="7937766917976512374">Omogočanje ali onemogočanje snemanje videoposnetka</translation>
<translation id="7941975817681987555">Ne predvidevaj omrežnih dejanj v nobeni omrežni povezavi</translation>
<translation id="7952007677054834789">Konfigurira strani, ki se zaženejo ob zagonu, privzeto domačo stran in privzeti nov zavihek s povezavami v izdelku <ph name="PRODUCT_NAME" /> ter uporabnikom prepreči, da bi jih spreminjali.

      Nastavitve domače strani uporabnika so popolnoma zaklenjene, če izberete, da je domača stran nov zavihek s povezavami, oziroma če za domačo stran nastavite URL in navedete URL domače strani. Če ne navedete URL-ja domače strani, lahko uporabnik z ukazom »chrome://newtab« še vedno nastavi, da je domača stran nov zavihek s povezavami.

      Pravilnik »URL-ji, ki naj se odprejo ob zagonu« je prezrt, razen če v možnosti »Dejanje ob zagonu« izberete »Odpri seznam URL-jev«.</translation>
<translation id="7952958573604504839">Ta pravilnik je zastarel in nadomeščen s pravilnikom <ph name="NETWORK_PREDICTION_OPTIONS_POLICY_NAME" /> v različici M48. Odstranjen je v različici M54.

      Omogoča omrežno predvidevanje v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom preprečuje spreminjanje te nastavitve.

      Ta pravilnik ne nadzira le vnaprejšnjega prenosa podatkov DNS, ampak tudi vnaprejšnje povezovanje TCP in SSL ter vnaprejšnje upodabljanje spletnih strani. Ime pravilnika se nanaša na vnaprejšnji prenos podatkov DNS zaradi zgodovinskih razlogov.

      Če to nastavitev omogočite ali onemogočite, je uporabniki v brskalniku <ph name="PRODUCT_NAME" /> ne morejo spremeniti ali preglasiti.

      Če ta pravilnik ni nastavljen, bo to omogočeno, vendar bo lahko uporabnik to spremenil.</translation>
<translation id="7953256619080733119">Gostitelji ročnih izjem za upravljanega uporabnika</translation>
<translation id="7958537754689366707">Vnos gesla je obvezen vsakih 12 ur</translation>
<translation id="7961779417826583251">Onemogoči uveljavljanje preglednosti potrdila za seznam starejših overiteljev potrdil</translation>
<translation id="7974114691960514888">Ta pravilnik ni več podprt.
          Omogoča uporabo strežnikov STUN in posredovalnih strežnikov pri povezovanju z oddaljenim odjemalcem.

          Če je ta nastavitev omogočena, lahko ta računalnik odkrije oddaljene gostiteljske računalnike in se poveže z njimi, tudi če jih ločuje požarni zid.

          Če je ta nastavitev onemogočena in izhodne povezave UDP filtrira požarni zid, se bo lahko ta računalnik povezal samo z gostiteljskimi računalniki znotraj lokalnega omrežja.</translation>
<translation id="7976157349247117979">Ime cilja za napravo <ph name="PRODUCT_NAME" /></translation>
<translation id="7980227303582973781">Ni posebnih omejitev</translation>
<translation id="7985242821674907985"><ph name="PRODUCT_NAME" /></translation>
<translation id="798856998567564266">Če omogočite to nastavitev, je zaznamke mogoče dodati, odstraniti ali spremeniti. To je privzeto tudi, če ta pravilnik ni nastavljen.

      Če onemogočite to nastavitev, zaznamkov ni mogoče dodati, odstraniti ali spremeniti. Obstoječi zaznamki so še vedno na voljo.</translation>
<translation id="7992136759457836904">Omogoči nadziranje, ali je v sistemu OS Chrome dovoljeno izvajanje navideznih računalnikov.

      Če je pravilnik omogočen, je v napravi dovoljeno izvajanje navideznih računalnikov.
      Če je pravilnik onemogočen, v napravi ni dovoljeno izvajanje navideznih računalnikov. 
      Vsi trije pravilniki – VirtualMachinesAllowed, CrostiniAllowed in DeviceUnaffiliatedCrostiniAllowed – morajo biti omogočeni, ko se prijavijo za omogočanje izvajanja Crostinija.
      Če je nastavitev tega pravilnika spremenjena na onemogočeno, se uporabi pri zagonu novih navideznih računalnikov, navideznih računalnikov, ki se že izvajajo, pa ne zaustavi.
      Če ta pravilnik ni nastavljen v upravljani napravi, v napravi ni dovoljeno izvajanje navideznih računalnikov.
      V napravah, ki niso upravljane, je dovoljeno izvajanje navideznih računalnikov.</translation>
<translation id="8001701200415781021">Omejuje, katere Google Račune je dovoljeno nastaviti kot primarne račune brskalnika v brskalniku <ph name="PRODUCT_NAME" /></translation>
<translation id="8009554972280451023">Če omogočite to nastavitev, se nastavitve, shranjene v profilih izdelka <ph name="PRODUCT_NAME" />, kot so zaznamki, podatki za samodejno izpolnjevanje, gesla in ipd. prav tako zapišejo v datoteko, shranjeno v mapo uporabniškega profila za gostovanje, ali na lokacijo, ki jo določi skrbnik s pravilnikom <ph name="ROAMING_PROFILE_LOCATION_POLICY_NAME" />. Če omogočite ta pravilnik, onemogočite sinhronizacijo z oblakom.

      Če je ta pravilnik onemogočen ali ni nastavljen, se uporabijo samo redni lokalni profili.

      Pravilnik <ph name="SYNC_DISABLED_POLICY_NAME" /> onemogoči vso sinhronizacijo podatkov in preglasi pravilnik <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" />.</translation>
<translation id="802147957407376460">Sukanje zaslona za 0 stopinj</translation>
<translation id="8033913082323846868">Ta pravilnik je zastarel v različici M70; namesto tega uporabite pravilnika AutofillAddressEnabled in AutofillCreditCardEnabled.

      Omogoči funkcijo samodejnega izpolnjevanja v brskalniku <ph name="PRODUCT_NAME" /> in uporabnikom omogoča samodejno izpolnjevanje spletnih obrazcev s shranjenimi podatki, kot so naslov in podatki o kreditni kartici.

      Če to nastavitev onemogočite, uporabniki ne bodo imeli dostopa do samodejnega izpolnjevanja.

      Če to nastavitev omogočite ali ne nastavite vrednosti, bo samodejno izpolnjevanje ostalo pod nadzorom uporabnika. Tako bo uporabnik lahko konfiguriral profile samodejnega izpolnjevanja in samodejno izpolnjevanje poljubno vklapljal in izklapljal.</translation>
<translation id="8044493735196713914">Pošiljanje podatkov o načinu zagona naprave</translation>
<translation id="8050080920415773384">Izvorno tiskanje</translation>
<translation id="8053580360728293758">Preglasi privzeti barvni način tiskanja. Če način ni na voljo, je ta pravilnik prezrt.</translation>
<translation id="8059164285174960932">URL, na katerem morajo odjemalci za oddaljeni dostop pridobiti žeton za preverjanje pristnosti</translation>
<translation id="806523868782250975">Konfigurira seznam upravljanih zaznamkov.

      Pravilnik sestavlja seznam zaznamkov, pri čemer je vsak zaznamek slovar s ključema »<ph name="NAME" />« in »<ph name="URL_LABEL" />«, v katerih sta shranjena ime in cilj zaznamka. Mogoče je konfigurirati podmapo tako, da definirate zaznamek brez ključa »<ph name="URL_LABEL" />«, vendar z dodatnim ključem »<ph name="CHILDREN" />«, ki vsebuje seznam zaznamkov, kot so opredeljeni zgoraj (nekateri so prav tako lahko mape). Brskalnik <ph name="PRODUCT_NAME" /> dopolni nepopolne URL-je, kot bi bili poslani prek iskalne vrstice. »<ph name="GOOGLE_COM" />« na primer postane »<ph name="HTTPS_GOOGLE_COM" />«.

      Ti zaznamki so dani v mapo, ki je uporabnik ne more spreminjati, lahko pa izbere, da je na vrstici z zaznamki skrita. Privzeto ime mape je »Managed bookmarks«, vendar ga je mogoče prilagoditi tako, da se na seznam zaznamkov doda slovar s ključem »<ph name="TOPLEVEL_NAME" />« z želenim imenom mape kot vrednostjo.

      Upravljani zaznamki se ne sinhronizirajo z uporabniškim računom in jih razširitve ne morejo spreminjati.</translation>
<translation id="8078366200175825572">Omogoča nastavitev seznama vzorcev URL-jev, ki določa, katerim spletnim mestom je onemogočeno nastavljanje piškotkov.

          Če ta pravilnik ni nastavljen, se za vsa spletna mesta uporabi globalna privzeta vrednost iz pravilnika »DefaultCookiesSetting«, kadar je ta pravilnik nastavljen, sicer pa iz osebnih nastavitev uporabnika.

          Glejte tudi pravilnika »CookiesAllowedForUrls« in »CookiesSessionOnlyForUrls«. V teh treh pravilnikih ne sme biti vzorcev URL v sporu – ni določeno, kateri pravilnik ima prednost.</translation>
<translation id="8099880303030573137">Časovni zamik ob napajanju iz akumulatorja</translation>
<translation id="8102913158860568230">Privzeta nastavitev »mediastream«</translation>
<translation id="8104186956182795918">Omogoča, da nastavite, ali je spletnim mestom dovoljeno prikazovanje slik. Prikaz slik lahko dovolite za vsa mesta ali preprečite za vsa mesta.

          Če pravilnik ni nastavljen, bo uporabljen pravilnik »AllowImages« in uporabnik ga bo lahko spremenil.

          Ta pravilnik je bil prej zmotno omogočen v Androidu, vendar ta funkcija ni bila nikoli v celoti podprta v Androidu.</translation>
<translation id="8104962233214241919">Samodejno izberi potrdila odjemalcev za ta spletna mesta</translation>
<translation id="8112122435099806139">Določa obliko zapisa časa, ki jo uporablja naprava.

      Ta pravilnik nastavi obliko zapisa časa, ki se uporablja na prijavnem zaslonu in kot privzeta za uporabniške seje. Uporabniki lahko še vedno preglasijo obliko zapisa za svoj račun.

       Če ta pravilnik ni nastavljen na »true«, naprava uporabi 24-urno obliko zapisa časa. Če je pravilnik nastavljen na »false«, naprava uporabi 12-urno obliko zapisa časa.

      Če pravilnik ni nastavljen, naprava privzeto uporabi 24-urno obliko zapisa časa.</translation>
<translation id="8113421140338762630">Omogoča, da nastavite časovno obdobje (v milisekundah) med prvim obvestilom, da je treba znova zagnati napravo z operacijskim sistemom <ph name="PRODUCT_OS_NAME" /> zaradi uveljavitve posodobitve na čakanju, in koncem časovnega obdobja, ki ga določa pravilnik <ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" />.

      Če pravilnik ni nastavljen, se za naprave z operacijskim sistemom <ph name="PRODUCT_OS_NAME" /> uporablja privzeto obdobje 86400000 milisekund (en dan).</translation>
<translation id="8114382167597081590">Ne uveljavi Omejenega načina v YouTubu</translation>
<translation id="8118665053362250806">Nastavi velikost predpomnilnika predstavnostnega diska</translation>
<translation id="8124468781472887384">Pravilnik o dostopu do konfiguracij tiskalnikov za naprave.</translation>
<translation id="8135937294926049787">Določa trajanje uporabnike nedejavnosti, po preteku katere se zaslon izklopi, če se napaja iz električnega omrežja.

          Če je pravilnik nastavljen na vrednost nad nič, določa, koliko časa mora biti uporabnik nedejaven, preden <ph name="PRODUCT_OS_NAME" /> izklopi zaslon.

          Če je pravilnik nastavljen na vrednost nič, <ph name="PRODUCT_OS_NAME" /> ne izklopi zaslona, ko uporabnik postane nedejaven.

          Če pravilnik ni nastavljen, se uporabi privzeto trajanje.

          Vrednost pravilnika naj bo navedena v milisekundah. Vrednosti morajo biti manjše ali enake kot časovni zamik nedejavnosti.</translation>
<translation id="8138009212169037227">Ta pravilnik nadzira, ali se sporočajo podatki o pravilniku in času prenosa pravilnika.

      Če ta pravilnik ni nastavljen ali je omogočen, se zbirajo podatki o pravilniku in času prenosa pravilnika.
      Če je ta pravilnik onemogočen, se podatki o pravilniku in času prenosa pravilnika ne zbirajo.

      Ta pravilnik se uporablja samo, če je omogočena razširitev <ph name="CHROME_REPORTING_EXTENSION_NAME" />, računalnik pa je včlanjen v pravilnik <ph name="MACHINE_LEVEL_USER_CLOUD_POLICY_ENROLLMENT_TOKEN_POLICY_NAME" />.</translation>
<translation id="8140204717286305802">Poročanje strežniku o seznamu omrežnih vmesnikov z vrstami in naslovi strojne opreme.

      Če je pravilnik nastavljen na »False«, se o seznamu vmesnikov ne poroča.</translation>
<translation id="8141795997560411818">Ta pravilnik uporabniku ne preprečuje aplikacije Google Drive za Android. Če želite preprečiti dostop do Googla Drive, prav tako onemogočite namestitev aplikacije Google Drive za Android.</translation>
<translation id="8142894094385450823">Nastavitev priporočenih jezikov za upravljano sejo</translation>
<translation id="8146727383888924340">Uporabnikom dovoli unovčenje ponudb prek registracije sistema Chrome OS.</translation>
<translation id="8148785525797916822">Onemogoči opozorilo, ki se pojavi, ko se <ph name="PRODUCT_NAME" /> izvaja v računalniku ali operacijskem sistemu, ki ni več podprt.</translation>
<translation id="8148901634826284024">Omogoči visokokontrastni način funkcij za ljudi s posebnimi potrebami.

          Če je ta pravilnik vklopljen, bo vedno omogočen visokokontrastni način.

          Če je izklopljen, bo visokokontrastni način vedno onemogočen.

          Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

          Če pravilnika ne nastavite, je visokokontrastni način prvotno onemogočen, vendar ga lahko uporabnik kadar koli omogoči.</translation>
<translation id="815061180603915310">Če je ta pravilnik omogočen, vsili preklop profila v kratkotrajni način. Če je ta pravilnik naveden kot pravilnik operacijskega sistema (npr. predmet pravilnika skupine v sistemu Windows), velja za vsak profil v sistemu. Če je pravilnik nastavljen kot pravilnik za oblak, velja samo za profil, ki je prijavljen z upravljanim računom.

      Podatki profila ostanejo v tem načinu na disku samo toliko časa, dokler traja seja uporabnika. Funkcije, kot so zgodovina brskalnika, razširitve in njihovi podatki ter spletni podatki (piškotki in spletne zbirke podatkov), se po zaprtju brskalnika ne ohranijo. Vendar to uporabniku ne prepreči ročnega prenašanja podatkov na disk in shranjevanja ali tiskanja strani.

       Če je uporabnik omogočil sinhronizacijo, se vsi ti podatki ohranijo v profilu za sinhronizacijo, enako kot to velja za navadne profile. Če pravilnik tega izrecno ne onemogoča, je na voljo tudi način brez beleženja zgodovine.

      Če je ta pravilnik onemogočen ali ni nastavljen, se pri prijavi uporabijo navadni profili.</translation>
<translation id="8158758865057576716">Omogočanje ustvarjanja kopij podatkov profila izdelka <ph name="PRODUCT_NAME" /> za gostovanje.</translation>
<translation id="8172676363520748127">Če je ta pravilnik omogočen, z bližnjičnimi tipkami ali API-ji razširitev ni mogoče ustvarjati posnetkov zaslona.

      Če je onemogočen ali ni določen, je ustvarjanje posnetkov zaslona dovoljeno.</translation>
<translation id="817455428376641507">Omogoča dostop do navedenih URL-jev kot izjem za seznam blokiranih URL-jev.

      Glede oblike vnosov za ta seznam glejte opis pravilnika za blokirane URL-je.

      Ta pravilnik je mogoče uporabiti za odpiranje izjem za omejevalne sezname. Tako je lahko na primer »*« dodan na omejevalni seznam za blokiranje vseh zahtev in ta pravilnik je mogoče uporabiti za dovoljevanje dostopa do omejevalnega seznama URL-jev. Uporabiti ga je mogoče za odpiranje izjem za določene sheme, poddomene ali druge domene, vrata ali določene poti.

      Najpodrobnejši filter določa, ali je URL blokiran ali dovoljen. Seznam dovoljenih ima prednost pred seznamom blokiranih.

      Ta pravilnik je omejen na 1000 vnosov; nadaljnji vnosi bodo prezrti.

      Če tega pravilnika ne nastavite, v pravilniku ne bo izjem za seznam blokiranih v pravilniku »URLBlacklist«.</translation>
<translation id="8176035528522326671">Dovoli poslovnemu uporabniku, da je samo primarni uporabnik z več profili (privzeti način delovanja za uporabnike, ki jih upravlja podjetje)</translation>
<translation id="8183108371184777472">Onemogočanje odpiranja okna brskalnika</translation>
<translation id="8214600119442850823">Konfigurira upravitelja gesel.</translation>
<translation id="8217516105848565518">Ta pravilnik je zastarel. Uporabite pravilnik RemoteAccessHostDomainList.</translation>
<translation id="8244171102276095471">Omogočanje šifrirnih zbirk RC4 v protokolu TLS</translation>
<translation id="8244525275280476362">Največja zakasnitev za prenos po zavrnitvi preverjanja pravilnika</translation>
<translation id="8256688113167012935">Nadzira prikaz imena računa na zaslonu za prijavo v sistemu <ph name="PRODUCT_OS_NAME" /> za ustrezen lokalni račun za napravo.

      Če je ta pravilnik nastavljen, bo zaslon za prijavo uporabil določen niz v slikovnem prijavnem izbirniku za ustrezen lokalni račun za napravo.

      Če ta pravilnik ni nastavljen, bo <ph name="PRODUCT_OS_NAME" /> za prikazno ime na zaslonu za prijavo uporabil ID e-poštnega računa lokalnega računa za prijavo.

      Ta pravilnik ne velja za običajne uporabniške račune.</translation>
<translation id="8259375588339409826">Chromium in Google Chrome podpirata isto skupino pravilnikov. Upoštevajte, da so lahko v tem dokumentu neobjavljeni pravilniki (vnos »Podprto na datum« se nanaša na še neobjavljeno različico brskalnika <ph name="PRODUCT_NAME" />), ki jih lahko spremenimo ali odstranimo brez predhodnega obvestila in za katere ne zagotavljamo nobenega jamstva, kakor tudi ne jamčimo za njihove lastnosti z vidika varnosti in zasebnosti.

Ti pravilniki so namenjeni izključno uporabi za konfiguriranje primerkov brskalnika <ph name="PRODUCT_NAME" /> znotraj vaše organizacije. Uporaba teh pravilnikov zunaj organizacije (na primer v programu, ki se javno distribuira) se obravnava kot zlonamerna programska oprema ter jo bodo Google in ponudniki protivirusnih programov najverjetneje označili kot tako.

Teh nastavitev ni treba konfigurirati ročno. Za sisteme Windows, macOS in Linux so na voljo predloge, ki jih je mogoče preprosto uporabljati in jih lahko prenesete tukaj: <ph name="POLICY_TEMPLATE_DOWNLOAD_URL" />.

Čeprav priporočamo, da v sistemu Windows pravilnik konfigurirate prek pravilnika skupine, je za primerke sistema Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, še vedno podprta priprava pravilnikov za uporabo prek registra.</translation>
<translation id="8259592978873597235">Če je pravilnik nastavljen na »True« ali če pravilnik ni nastavljen, uporabnik ne velja za nedejavnega, če se predvaja videoposnetek. S tem se prepreči doseganje časovnega zamika ob nedejavnosti ter časovnega zamika zatemnitve, izklopa zaslona in zaklepa zaslona, s tem pa se preprečijo tudi ustrezna dejanja.

          Če je pravilnik nastavljen na »False«, uporabnik kljub videodejavnosti velja za nedejavnega.</translation>
<translation id="8274603902181597201">Brisanje uporabnikovega domačega imenika, šifriranega s šifriranjem ecryptfs, in začetek z novim domačim imenikom, šifriranim s šifriranjem ext4.</translation>
<translation id="8285435910062771358">Vklop lupe celozaslonskega načina</translation>
<translation id="8288199156259560552">Omogoči Googlovo lokacijsko storitev za Android</translation>
<translation id="8292322992383748446">Poročanje statističnih podatkov o strojni opremi za komponente SoC.

      Če je ta pravilnik onemogočen, statistični podatki ne bodo poslani.
      Če je ta pravilnik omogočen ali ni nastavljen, bodo statistični podatki poslani.</translation>
<translation id="8294750666104911727">Običajno bodo strani, ki imajo možnost »X-UA-Compatible« nastavljeno na »chrome=1«, upodobljene v izdelku <ph name="PRODUCT_FRAME_NAME" />, ne glede na pravilnik »ChromeFrameRendererSettings«.

          Če to nastavitev omogočite, se na straneh ne bodo iskale metaoznake.

          Če to nastavitev onemogočite, se bodo na straneh iskale metaoznake.

          Če tega pravilnika ne nastavite, se bodo na straneh iskale metaoznake.</translation>
<translation id="8300455783946254851">Če je ta možnost nastavljena na »True«, onemogoči sinhroniziranje Googla Drive v aplikaciji Datoteke za <ph name="PRODUCT_OS_NAME" /> pri uporabi mobilnega omrežja. V tem primeru se podatki sinhronizirajo z Googlom Drive, samo če je na voljo povezava Wi-Fi ali ethernetna povezava.

          Če ta možnost ni nastavljena ali je nastavljena na »False«, bodo uporabniki lahko prenesli datoteke v Google Drive prek mobilnega omrežja.</translation>
<translation id="8300992833374611099">Nadzor nad tem, kje so lahko uporabljena orodja za razvijalce</translation>
<translation id="8306117673860983372">Nastavitve za prijavo</translation>
<translation id="8312129124898414409">Omogoča nastavitev, ali lahko spletna mesta uporabljajo ustvarjanje ključev. Uporabo ustvarjanja ključev je mogoče dovoliti ali zavrniti za vsa spletna mesta.

          Če ta pravilnik ni nastavljen, bo omogočen pravilnik »BlockKeygen«, uporabnik pa ga bo lahko spremenil.</translation>
<translation id="8320149248919453401">Način polnjenja akumulatorja</translation>
<translation id="8329984337216493753">Ta pravilnik je aktiven samo v maloprodajnem načinu.

      Če je določen pravilnik DeviceIdleLogoutTimeout, ta pravilnik določa trajanje opozorila z odštevanjem, ki je pred odjavo prikazano uporabniku.

      Vrednost pravilnika mora biti v milisekundah.</translation>
<translation id="8331479227794770304">Omogočanje zaklepanja tipk.</translation>
<translation id="8339420913453596618">Dvojno preverjanje je onemogočeno</translation>
<translation id="8344454543174932833">Uvoz zaznamkov privzetega brskalnika ob prvem zagonu</translation>
<translation id="8357681633047935212">Omejitev dolžine uporabniške seje</translation>
<translation id="8359734107661430198">Omogočanje API-ja ExampleDeprecatedFeature API do vključno 2. 9. 2008</translation>
<translation id="8367209241899435947">Omogočeno Chromovo čiščenje v sistemu Windows</translation>
<translation id="8369602308428138533">Časovni zamik izklopa zaslona, če se napaja iz električnega omrežja</translation>
<translation id="8371178326720637170">Omogoča upravljane razširitve za uporabo API-ja za okolja za strojno opremo za podjetja</translation>
<translation id="8374747520743832795">Poročanje statističnih podatkov o strojni opremi in identifikatorjev, povezanih z napajanjem.

      Če je ta pravilnik onemogočen, statistični podatki ne bodo poslani.
      Če je ta pravilnik omogočen ali ni nastavljen, bodo statistični podatki poslani.</translation>
<translation id="8380490658357556620">Omogoča uporabo posredovalnih strežnikov, ko oddaljeni odjemalci poskušajo vzpostaviti povezavo s tem računalnikom.

          Če je ta nastavitev omogočena, lahko oddaljeni odjemalci uporabijo posredovalne strežnike za povezovanje s tem računalnikom, tudi ko neposredna povezava ni na voljo (na primer zaradi omejitve s požarnim zidom).

          Če je pravilnik <ph name="REMOTE_ACCESS_HOST_FIREWALL_TRAVERSAL_POLICY_NAME" /> onemogočen, bo ta pravilnik prezrt.

          Če ta pravilnik ni nastavljen, bo nastavitev omogočena.</translation>
<translation id="8382184662529825177">Omogoči uporabo oddaljenega potrjevanja za zaščito vsebine za napravo</translation>
<translation id="838870586332499308">Omogoči podatkovno gostovanje</translation>
<translation id="8390049129576938611">V brskalniku <ph name="PRODUCT_NAME" /> onemogoči notranji pregledovalnik PDF-jev. Namesto tega datoteke PDF obravnava kot prenose in uporabniku omogoča njihovo odpiranje s privzeto aplikacijo.

      Če ta pravilnik ni nastavljen ali je onemogočen, se bo za odpiranje datotek PDF uporabljal vtičnik za PDF-je, razen če ga uporabnik onemogoči.</translation>
<translation id="8395749934754392549">Nadzira nastavitve za vsebnik za Android (ARC) in aplikacije za Android.</translation>
<translation id="8396145449084377015">Ta pravilnik nadzira, ali naj se nalagajo pravila iz pravilnika za sezname spletnih mest za Internet Explorer.

      Če ta pravilnik ni nastavljen ali je onemogočen, <ph name="PRODUCT_NAME" /> ne uporablja pravilnika <ph name="IEEM_SITELIST_POLICY" /> za Internet Explorer kot vira pravil za preklop brskalnika.

      Če je ta pravilnik omogočen, <ph name="PRODUCT_NAME" /> prebere pravilnik <ph name="IEEM_SITELIST_POLICY" /> za Internet Explorer zaradi pridobivanja URL-ja seznama spletnih mest. <ph name="PRODUCT_NAME" /> nato prenese seznam spletnih mest s tega URL-ja in uporabi pravila, kot da so bila konfigurirana s pravilnikom <ph name="SITELIST_POLICY_NAME" />.

      Več informacij o pravilniku <ph name="IEEM_SITELIST_POLICY" /> za Internet Explorer je na voljo tukaj: https://docs.microsoft.com/internet-explorer/ie11-deploy-guide/what-is-enterprise-mode</translation>
<translation id="8402079500086185021">Vedno odpri datoteke PDF v zunanjem pregledovalniku</translation>
<translation id="8417305981081876834">Nastavi največjo dolžino kode PIN za zaklenjen zaslon</translation>
<translation id="841977920223099909">Sprožilec opozorila zaščite z geslom</translation>
<translation id="8424255554404582727">Nastavitev privzetega sukanja zaslona, ki se znova uveljavi pri vsakem vnovičnem zagonu</translation>
<translation id="8426231401662877819">Sukanje zaslona v smeri urnega kazalca za 90 stopinj</translation>
<translation id="8433186206711564395">Omrežne nastavitve</translation>
<translation id="8433423491036718210">Konfigurirajte seznam URL-jev prijave za poslovna okolja, pri katerih naj zaščitna storitev zajame prstni odtis gesla.</translation>
<translation id="8451988835943702790">Uporabi nov zavihek s povezavami kot domačo stran</translation>
<translation id="8459216513698220096">Določa, ali in kako je obdelan uporabniški pravilnik iz predmeta pravilnika skupine računalnika.

      Če je pravilnik nastavljen na »Default« ali ni nastavljen, je uporabniški pravilnik prebran samo iz predmetov pravilnika skupine uporabnika (predmeti pravilnika skupine računalnika so prezrti).

      Če je pravilnik nastavljen na »Merge«, je uporabniški pravilnik v predmetih pravilnika skupine uporabnika združen z uporabniškim pravilnikom v predmetih pravilnika skupine računalnika (predmeti pravilnika skupine računalnika imajo prednost).

      Če je pravilnik nastavljen na »Replace«, je uporabniški pravilnik v predmetih pravilnika skupine uporabnika nadomeščen z uporabniškim pravilnikom v predmetih pravilnika skupine računalnika (predmeti pravilnika skupine uporabnika so prezrti).</translation>
<translation id="8465065632133292531">Parametri za takojšnji URL, ki uporablja POST</translation>
<translation id="8465746466645315861">Če ta pravilnik ni nastavljen, uporabnik lahko omogoči ali onemogoči preverjanje črkovanja v jezikovnih nastavitvah.

      Če je ta pravilnik omogočen, je preverjanje črkovanja omogočeno in uporabnik ga ne more onemogočiti. V operacijskih sistemih <ph name="MS_WIN_NAME" />, <ph name="PRODUCT_OS_NAME" /> in <ph name="LINUX_OS_NAME" /> je mogoče vklopiti ali izklopiti posamezne jezike za preverjanje črkovanja, tako da lahko uporabnik pravzaprav še vedno onemogoči preverjanje črkovanja tako, da izklopi vse jezike za preverjanje črkovanja. Če se želite temu izogniti, lahko uporabite pravilnik <ph name="SPELLCHECK_LANGUAGE_POLICY_NAME" />, s katerim vsilite, da so določeni jeziki za preverjanje črkovanja omogočeni.

      Če je ta pravilnik onemogočen, je preverjanje črkovanja onemogočeno in ga uporabnik ne more omogočiti. Pravilnika <ph name="SPELLCHECK_LANGUAGE_POLICY_NAME" /> in <ph name="SPELLCHECK_LANGUAGE_BLACKLIST_POLICY_NAME" /> nimata učinka, če je ta pravilnik onemogočen.
      </translation>
<translation id="847472800012384958">Nobenemu mestu ne dovoli prikaza pojavnih oken</translation>
<translation id="8477885780684655676">TLS 1.0</translation>
<translation id="8483004350080020634">Iz URL-jev s protokolom https:// odstrani občutljive dele glede zasebnosti in varnosti, preden jih posreduje skriptom PAC (samodejno konfiguriranje strežnika proxy), ki jih med razreševanjem strežnika proxy uporablja <ph name="PRODUCT_NAME" />.

      Če je pravilnik omogočen, je varnostna funkcija omogočena, iz URL-jev s protokolom https://
      pa se odstranijo deli, preden se pošljejo v skript PAC. Na ta način skriptu PAC
      niso vidni podatki, ki so običajno zaščiteni s
      šifriranim kanalom (kot sta pot in poizvedba URL-ja).

      Če je pravilnik onemogočen, je varnostna funkcija onemogočena, skriptom PAC pa je
      izrecno omogočen ogled vseh komponent URL-ja s protokolom https://.
      To se uporabi za vse skripte PAC ne glede na izvor (vključno s tistimi,
      ki so pridobljeni s prenosom, ki ni varen, ali odkriti z mehanizmom
      WPAD na način, ki ni varen).

      Pravilnik je privzeto omogočen (varnostna funkcija je omogočena).

      Priporočamo, da pravilnik omogočite. Edini razlog za onemogočanje je,
      če pravilnik povzroča težavo z združljivostjo z obstoječimi skripti PAC.

      Pravilnik bo odstranjen v različici M75.</translation>
<translation id="8484458986062090479">Prilagodi seznam vzorcev URL-jev, ki naj jih vedno upodobi gostiteljski brskalnik.

          Če ta pravilnik ni nastavljen, bo za vsa spletna mesta, določena s pravilnikom »ChromeFrameRendererSettings«, uporabljen privzeti upodabljalnik.

          Primere vzorcev si lahko ogledate na https://www.chromium.org/developers/how-tos/chrome-frame-getting-started.</translation>
<translation id="8489964335640955763">PluginVm</translation>
<translation id="8493645415242333585">Onemogoči shranjevanje zgodovine brskalnika</translation>
<translation id="8499172469244085141">Privzete nastavitve (uporabniki jih lahko preglasijo)</translation>
<translation id="8507835864888987300">Določi ciljno različico za samodejne posodobitve.

      Določa predpono ciljne različice, na katero naj se posodobi sistem <ph name="PRODUCT_OS_NAME" />. Če se v napravi izvaja različica, ki je starejša od navedene predpone, se posodobi na najnovejšo različico z dano predpono. Če je v napravi že novejša različica, je učinek odvisen od vrednosti pravilnika <ph name="DEVICE_ROLLBACK_TO_TARGET_VERSION_POLICY_NAME" />. Oblika zapisa predpone temelji na komponenti, kot je prikazano v tem primeru:

      »« (ali ni nastavljeno)): posodobitev na najnovejšo razpoložljivo različico.
      »1412.«: posodobitev na katero koli podrazličico različice 1412 (npr. 1412.24.34 ali 1412.60.2)
      »1412.2.«: posodobitev na katero koli podrazličico različice 1412.2 (npr. 1412.2.34 ali 1412.2.2)
      »1412.24.34«: posodobitev samo na to različico

      Opozorilo: priporočamo, da ne konfigurirate omejitev različic, ker lahko s tem preprečite, da bi uporabniki prejeli posodobitve programske opreme in nujne varnostne popravke. Če posodobitve omejite na predpono določene različice, so lahko uporabniki izpostavljeni tveganju.</translation>
<translation id="8519264904050090490">URL-ji ročnih izjem za upravljanega uporabnika</translation>
<translation id="8525526490824335042">Vsebnik za Linux</translation>
<translation id="8538235451413605457">Konfigurira zahtevo za najmanjšo dovoljeno različico za <ph name="PRODUCT_NAME" />. Različice, starejše od najmanjše dovoljene različice, se obravnavajo kot zastarele, in naprava uporabniku ne dovoli prijave, preden se operacijski sistem ne posodobi.
      Če trenutna različica postane zastarela med uporabniško sejo, je uporabnik na silo odjavljen.

      Če ta pravilnik ni nastavljen, se ne uporabljajo omejitve in uporabnik se lahko prijavi ne glede na različico brskalnika <ph name="PRODUCT_NAME" />.

      »Različica« pomeni točno različico, na primer »61.0.3163.120«, ali predpono različice, na primer »61.0«.  </translation>
<translation id="8544375438507658205">Privzeti upodabljalnik HTML-ja za <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8544465954173828789">Dovolitev sinhroniziranja sporočil SMS med telefonom in Chromebookom.</translation>
<translation id="8548832052135586762">Nastavi tiskanje na samo barvno, samo enobarvno ali brez omejitve barv. Če pravilnik ni nastavljen, ni omejitve.</translation>
<translation id="8549772397068118889">Opozori pri odpiranju spletnih mest zunaj paketov vsebine</translation>
<translation id="8566729013138025202">Določa nabor pravilnikov, ki bodo posredovani izvajalniku ARC. Vrednost mora biti veljavna datoteka JSON.

      S tem pravilnikom je mogoče konfigurirati, katere aplikacije za Android so samodejno nameščene v napravi.

      Če želite pripeti aplikacije v zaganjalnik, si oglejte pravilnik PinnedLauncherApps.</translation>
<translation id="8566842294717252664">Skrivanje spletne trgovine na novem zavihku s povezavami in v zaganjalniku aplikacij</translation>
<translation id="8569734380847633643">
          Če je pravilnik onemogočen, bo operacijski sistem <ph name="PRODUCT_OS_NAME" /> onemogočil povezavo Wi-Fi in uporabniki je ne bodo mogli omogočiti.
          Če je pravilnik omogočen ali ni nastavljen, bodo uporabniki lahko po želji omogočili ali onemogočili povezavo Wi-Fi.</translation>
<translation id="857369585509260201">Ta pravilnik je zastarel, namesto njega lahko uporabite BrowserSignin.

      Če je ta pravilnik omogočen, se mora uporabnik s svojim profilom prijaviti v brskalnik <ph name="PRODUCT_NAME" />, preden ga lahko uporablja. Privzeta vrednost za pravilnik BrowserGuestModeEnabled bo nastavljena na onemogočeno. Po omogočanju tega pravilnika bodo obstoječi neprijavljeni profili zaklenjeni in nedostopni. Če želite več informacij, preberite članek centra za pomoč.

      Če je ta pravilnik onemogočen ali ni konfiguriran, lahko uporabnik uporablja brskalnik brez prijave v brskalnik <ph name="PRODUCT_NAME" />.</translation>
<translation id="8586528890725660268">Določa tiskalnike, ki jih uporabnik ne more uporabljati.

      Ta pravilnik se uporablja samo, če je za pravilnik <ph name="BULK_PRINTERS_ACCESS_MODE" /> izbrana možnost <ph name="PRINTERS_BLACKLIST" />.

      Če se uporablja ta pravilnik, so uporabniku na voljo vsi tiskalniki z izjemo ID-jev, navedenih v tem pravilniku. ID-ji morajo ustrezati polju »id« ali »guid« v datoteki, določeni v pravilniku <ph name="BULK_PRINTERS_POLICY" />.
      </translation>
<translation id="8587229956764455752">Omogoči ustvarjanje novih uporabniških računov</translation>
<translation id="8598350264853261122">Če je pravilnik onemogočen, nepovezanim uporabnikom ne bo dovoljeno uporabljati ARC-ja.

      Če pravilnik ni nastavljen ali je omogočen, je vsem uporabnikom dovoljena uporaba ARC-ja (razen če je ARC kako drugače onemogočen).

      Spremembe pravilnika bodo uveljavljene samo, ko se ARC ne izvaja, na primer ko se zaganja sistem OS Chrome.</translation>
<translation id="8615400197788843468">Omogoči funkcijo omejene prijave za brskalnik <ph name="PRODUCT_NAME" /> v storitvi G Suite in uporabnikom prepreči spreminjanje te nastavitve.

      Če določite to nastavitev, bo lahko uporabnik do storitve Google
      dostopal samo z računi iz navedenih domen (to ne deluje za račune
      gmail.com/googlemail.com; na seznam domen morate dodati
      »consumer accounts« (brez navednic)).

      Ta nastavitev bo uporabniku preprečila prijavo in dodajanje sekundarnega
      računa v upravljani napravi, za katero je potrebno Googlovo preverjanje pristnosti,
      če tega računa ni na prej omenjenem seznamu dovoljenih domen.

      Če to nastavitev pustite prazno/nenastavljeno, bo lahko uporabnik
      dostopal do storitve G Suite iz poljubnega računa.

      Ta pravilnik povzroči, da je glava X-GoogApps-Allowed-Domains dodana
      vsem zahtevam HTTP in HTTPS za vse domene google.com, kot je opisano na strani
      https://support.google.com/a/answer/1668854.

      Uporabniki te nastavitve ne morejo spremeniti ali preglasiti.</translation>
<translation id="8631434304112909927">do različice <ph name="UNTIL_VERSION" /></translation>
<translation id="8649763579836720255">Naprave Chrome OS lahko uporabljajo oddaljeno potrjevanje (potrjen dostop) za pridobitev potrdil, ki ga izda overitelj sistema Chrome OS, ki potrjuje, da je naprava primerna za predvajanje zaščitene vsebine. Pri tem postopku se overitelju sistema Chrome OS pošljejo potrditveni podatki strojne opreme, ki enolično določajo napravo.

          Če je ta možnost nastavljena na »false«, naprava za zaščito vsebine ne bo uporabljala oddaljenega potrjevanja in naprava morda ne bo mogla predvajati zaščitene vsebine.

          Če je ta možnost nastavljena na »true«, se lahko za zaščito vsebine uporablja oddaljeno preverjanje.</translation>
<translation id="8650974590712548439">Lokacija registra sistema Windows za odjemalce s sistemom Windows:</translation>
<translation id="8654286232573430130">Določa, kateri strežniki naj bodo dodani na seznam dovoljenih za vgrajeno preverjanje pristnosti. Vgrajeno preverjanje pristnosti je omogočeno samo, kadar <ph name="PRODUCT_NAME" /> prejme poziv za preverjanje pristnosti iz strežnika proxy ali strežnika, ki je na tem seznamu dovoljenih.

          Imena strežnikov ločite z vejicami. Nadomestni znaki (*) so dovoljeni.

          Če tega pravilnika ne nastavite, <ph name="PRODUCT_NAME" /> poskuša zaznati, ali je strežnik v intranetu, in se šele potem odzove na zahteve IWA. Če je strežnik zaznan kot internet, <ph name="PRODUCT_NAME" /> prezre zahteve IWA, poslane iz tega strežnika.</translation>
<translation id="8661297125441579970">Prepoved selitve podatkov in ARC-ja.</translation>
<translation id="8672321184841719703">Ciljna različica za samodejne posodobitve</translation>
<translation id="867410340948518937">U2F (Universal Second Factor)</translation>
<translation id="8685024486845674965">Opozorilo zaščite z geslom sproži vnovična uporaba gesla</translation>
<translation id="8693243869659262736">Uporaba vgrajenega odjemalca DNS</translation>
<translation id="8698286761337647563">Koliko dni vnaprej naj se opozori uporabnike prijave SAML glede skorajšnjega poteka njihovega gesla</translation>
<translation id="8703488928438047864">Poročanje o stanju plošče</translation>
<translation id="8703872185032220081">Nastavitev dnevne konfiguracije funkcije preklopa na akumulatorsko napajanje ob konicah.

          Ta pravilnik se uporablja samo, če je omogočen pravilnik DevicePowerPeakShiftEnabled.

          Če ta pravilnik ni konfiguriran ali nastavljen, je funkcija preklopa na akumulatorsko napajanje ob konicah vedno onemogočena.

          Opomba: dovoljene vrednosti za polje <ph name="MINUTE_FIELD_NAME" /> v poljih <ph name="START_TIME_FIELD_NAME" />, <ph name="END_TIME_FIELD_NAME" /> in <ph name="CHARGE_START_TIME_FIELD_NAME" /> so 0, 15, 30, 45.</translation>
<translation id="8704831857353097849">Seznam onemogočenih vtičnikov</translation>
<translation id="8711086062295757690">Določa ključno besedo, ki kot bližnjica v naslovni vrstici sproži iskanje za tega ponudnika.

          Ta pravilnik je izbiren. Če ni nastavljen, ključna beseda ne bo aktivirala ponudnika iskanja.

          Ta pravilnik velja le, če je omogočen pravilnik »DefaultSearchProviderEnabled«.</translation>
<translation id="8733448613597049197">Omogoča razširjeno poročanje za Varno brskanje za brskalnik <ph name="PRODUCT_NAME" /> in uporabnikom prepreči spreminjanje te nastavitve.

      Razširjeno poročanje pošilja nekatere informacije o sistemu in vsebino strani v Googlove strežnike zaradi zaznavanja nevarnih aplikacij in spletnih mest.

      Če je nastavitev nastavljena na »true«, bodo poročila ustvarjena in poslana, ko je to potrebno (ko je na primer prikazan vmesni varnostni zaslon).

      Če je nastavitev nastavljena na »false«, poročila ne bodo poslana.

      Če je ta pravilnik nastavljen na »true« ali »false«, uporabnik ne more spremeniti nastavitve.

      Če ta pravilnik ni nastavljen, uporabnik lahko spremeni nastavitev in se odloči, ali se poročila pošljejo.

      Več informacij o Varnem brskanju je na voljo na https://developers.google.com/safe-browsing.</translation>
<translation id="8736538322216687231">Vsili najmanjši mogoč Omejeni način v YouTubu</translation>
<translation id="8749370016497832113">Omogoči brisanje zgodovine brskalnika in zgodovine prenosov v izdelku <ph name="PRODUCT_NAME" /> in uporabnikom preprečuje spreminjanje te nastavitve.

      Tudi če je pravilnik onemogočen, zgodovina brskanja in zgodovina prenosov morda ne bosta ohranjeni: uporabniki lahko neposredno urejajo ali brišejo podatkovne zbirke zgodovine, brskalnik pa lahko poteče ali kadar koli arhivira katere koli elemente zgodovine.

      Če ta nastavitev ni omogočena ali nastavljena, je zgodovino brskanja in zgodovino prenosov mogoče izbrisati

      Če je ta nastavitev onemogočena, zgodovine brskanja in zgodovine prenosov ni mogoče izbrisati.</translation>
<translation id="8757552286070680084">Konfiguracija orodja wilco DTC</translation>
<translation id="8758831693895931466">Omogočanje obvezne včlanitve v upravljanje v oblaku</translation>
<translation id="8759829385824155666">Dovoljene vrste šifriranja Kerberos</translation>
<translation id="8764119899999036911">Določa, ali ustvarjeni SPN za Kerberos temelji na kanoničnem imenu DNS ali na vnesenem izvirnem imenu.

          Če to nastavitev omogočite, bo iskanje CNAME preskočeno in uporabljeno bo vneseno ime strežnika.

          Če to nastavitev onemogočite ali jo ne nastavite, bo kanonično ime strežnika določeno z iskanjem CNAME.</translation>
<translation id="8764477907716150749">Ta pravilnik je namenjen za notranjo uporabo v samem brskalniku <ph name="PRODUCT_NAME" />.</translation>
<translation id="8765776988041674792">Konfiguriranje URL-ja za spreminjanje gesla (samo sheme HTTP in HTTPS). Storitev za zaščito gesla po prikazu opozorila v brskalniku pošlje uporabnike na ta URL, da spremenijo geslo.
      Če želite, da <ph name="PRODUCT_NAME" /> pravilno zajame prstni odtis novega gesla na tej strani za spreminjanje gesla, poskrbite, da je stran za spremembo gesla skladna s smernicami na naslovu https://www.chromium.org/developers/design-documents/create-amazing-password-forms.

      Če je ta nastavitev omogočena, storitev za zaščito gesel po prikazu opozorila v brskalniku pošlje uporabnike na ta URL, da spremenijo geslo.
      Če je ta nastavitev onemogočena ali ni nastavljena, storitev za zaščito gesel pošlje uporabnike na naslov https://myaccounts.google.com, da spremenijo geslo.
      Ta pravilnik je na voljo samo v primerkih s sistemom Windows, ki so pridruženi v domeno <ph name="MS_AD_NAME" />, ali primerkih s sistemom Windows 10 Pro ali Enterprise, ki so včlanjeni v upravljanje naprav.</translation>
<translation id="8798099450830957504">Privzeto</translation>
<translation id="8800453707696044281">Nastavitev prilagojene točke ustavitve polnjenja akumulatorja v odstotkih</translation>
<translation id="8801680448782904838">Obveščanje uporabnika, da je priporočen ali obvezen vnovičen zagon brskalnika ali naprave</translation>
<translation id="8818173863808665831">Prijava zemljepisne lokacije naprave.

      Če pravilnik ni nastavljen ali je nastavljen na »False«, lokacija ne bo prijavljena.</translation>
<translation id="8818768076343557335">Predvidevanje omrežnih dejanj v katerem koli omrežju, ki ni mobilno.
          (Zastarelo v različici 50, odstranjeno v različici 52. Če je vrednost 1 nastavljena, bo po različici 52 obravnavana kot 0 – predvidevanje omrežnih dejanj v poljubni omrežni povezavi.)</translation>
<translation id="8825782996899863372">Opozorilo zaščite z geslom sproži vnovična uporaba gesla na spletnem mestu z lažnim predstavljanjem</translation>
<translation id="8833109046074170275">Preverjanje pristnosti prek običajne prijave GAIA</translation>
<translation id="8838303810937202360"><ph name="PRODUCT_OS_NAME" /> predpomni aplikacije in razširitve za namestitev za več uporabnikov posamezne naprave, tako jih ni treba prenašati znova za posameznega uporabnika.
      Če ta pravilnik ni nastavljen ali je vrednost nižja od 1 MB, bo sistem <ph name="PRODUCT_OS_NAME" /> uporabil privzeto velikost predpomnilnika.</translation>
<translation id="8851325571441692315">Omogoča izbiro strežnika proxy, ki naj ga uporablja <ph name="PRODUCT_NAME" />, in uporabnikom prepreči spreminjanje nastavitev strežnika proxy.

          Ta pravilnik ima vpliv samo, če pravilnik <ph name="PROXY_SETTINGS_POLICY_NAME" /> ni določen.

          Če izberete, da se strežnik proxy nikoli ne uporablja in se vedno vzpostavi neposredna povezava, so vse druge možnosti prezrte.

          Če izberete sistemske nastavitve strežnika proxy, so vse druge možnosti prezrte.

          Če izberete samodejno zaznavanje strežnika proxy, so vse druge možnosti prezrte.

          Če izberete fiksni način strežnika proxy, lahko v možnostih »Naslov ali URL strežnika proxy« in »Seznam pravil za obvod strežnika proxy, ločenih z vejicami« izberete dodatne nastavitve. Za aplikacije ARC je na voljo samo strežnik proxy HTTP z največjo prednostjo.

          Če za strežnik proxy izberete uporabo skripta .pac, morate v možnosti »URL datoteke .pac za strežnik proxy« navesti URL skripta.

          Podrobne primere si lahko ogledate tukaj:
          <ph name="PROXY_HELP_URL" />.

          Če omogočite to nastavitev, <ph name="PRODUCT_NAME" /> in aplikacije ARC prezrejo vse možnosti, povezane s strežnikom proxy, navedene v ukazni vrstici.

          Če ta pravilnik ni nastavljen, lahko uporabniki sami izberejo nastavitve strežnika proxy.</translation>
<translation id="8858642179038618439">Vsiljenje varnega načina v YouTubu</translation>
<translation id="8860342862142842017">Onemogoči uveljavljanje preglednosti potrdila za seznam zgoščevalnih vrednosti subjectPublicKeyInfo</translation>
<translation id="8864975621965365890">Ne prikaže poziva za preklop, ki se prikaže, ko se spletno mesto upodablja z <ph name="PRODUCT_FRAME_NAME" />.</translation>
<translation id="8867464911288727016">Omogoči storitev Google Prevajalnik, vgrajeno v <ph name="PRODUCT_NAME" />.

      Če omogočite to nastavitev, bo <ph name="PRODUCT_NAME" /> uporabniku ponudil možnost prevajanja, tako da bo prikazal vgrajeno orodno vrstico (ko je primerno) in možnost prevajanja v kontekstnem meniju, če ga kliknete z desno miškino tipko.

      Če onemogočite to nastavitev, bodo vse vgrajene funkcije onemogočene.

      Če omogočite ali onemogočite to nastavitev, uporabniki ne morejo spremeniti ali preglasiti te nastavitve v brskalniku <ph name="PRODUCT_NAME" />.

      Če te nastavitve ne določite, se lahko uporabnik odloči, ali bo uporabljal to funkcijo.</translation>
<translation id="8871974300055371298">Nastavitve vsebine</translation>
<translation id="8876188741456358123">Preglasi privzeti način obojestranskega tiskanja. Če način ni na voljo, je ta pravilnik prezrt.</translation>
<translation id="8882006618241293596">Blokiraj vtičnik <ph name="FLASH_PLUGIN_NAME" /> na teh spletnih mestih</translation>
<translation id="8906768759089290519">Omogoči način gosta</translation>
<translation id="8908294717014659003">Omogoča nastavitev, ali je spletnim mestom dovoljen dostop do naprav za snemanje predstavnosti. Dostop do naprav za snemanje predstavnosti je lahko privzeto dovoljen ali pa uporabnik dobi poziv, kadar koli spletno mesto želi dostop do naprav za snemanje predstavnosti.

           Če ta pravilnik ni nastavljen, bo uporabljena nastavitev »PromptOnAccess« in uporabnik jo bo lahko spremenil.</translation>
<translation id="8909280293285028130">Določa trajanje uporabnikove nedejavnosti, po preteku katere se zaslon zaklene, če se napaja iz električnega omrežja.

          Če je pravilnik nastavljen na vrednost nad nič, določa, koliko časa mora biti uporabnik nedejaven, preden <ph name="PRODUCT_OS_NAME" /> zaklene zaslon.

          Če je pravilnik nastavljen na vrednost nič, <ph name="PRODUCT_OS_NAME" /> ne zaklene zaslona, ko uporabnik postane nedejaven.

          Če pravilnik ni nastavljen, se uporabi privzeto trajanje.

          Priporočljivo je, da za zaklep zaslona ob nedejavnosti omogočite zaklepanje ob prekinitvi, da se <ph name="PRODUCT_OS_NAME" /> prekine po preteku časovnega zamika nedejavnosti. Ta pravilnik uporabite samo, če želite, da se zaslon zaklene bistveno pred prekinitvijo, ali če ne želite prekinitve ob nedejavnosti.

          Vrednost pravilnika naj bo navedena v milisekundah. Vrednosti morajo biti manjše od časovnega zamika nedejavnosti.</translation>
<translation id="891435090623616439">kodirano kot niz JSON; več informacij je na voljo na <ph name="COMPLEX_POLICIES_URL" /></translation>
<translation id="8934944553121392674">Nadzira, kateri tiskalniki iz pravilnika <ph name="DEVICE_PRINTERS_POLICY" /> so na voljo uporabnikom.

      Določa, kateri pravilnik o dostopu se uporablja za konfiguracijo tiskalnikov v velikem obsegu. Če je izbrana možnost <ph name="PRINTERS_ALLOW_ALL" />, so prikazani vsi tiskalniki. Če je izbrana možnost <ph name="PRINTERS_BLACKLIST" />, se omeji dostop do določenih tiskalnikov s pravilnikom <ph name="DEVICE_PRINTERS_BLACKLIST" />. Če je izbrana možnost <ph name="PRINTERS_WHITELIST" />, pravilnik <ph name="DEVICE_PRINTERS_WHITELIST" /> določa samo tiste tiskalnike, ki jih je mogoče izbrati.

      Če ta pravilnik ni nastavljen, se predvideva uporaba pravilnika <ph name="PRINTERS_ALLOW_ALL" />.
      </translation>
<translation id="8938932171964587769">Zastarel v različici M69. Namesto tega uporabite pravilnik
      OverrideSecurityRestrictionsOnInsecureOrigin.

      Pravilnik določa seznam izvorov (URL-jev) ali vzorcev imen gostitelja (na primer
      »*.example.com«), za katere se varnostne omejitve v izvorih, ki niso varni,
      ne uporabljajo.

      Namen tega je omogočiti organizacijam nastavitev izvorov, uvrščenih na seznam dovoljenih, za starejše
      aplikacije, ki ne morejo uvesti šifriranja TLS, ali nastavitev preizkusnega produkcijskega strežnika
      za notranje spletno razvijanje, tako da lahko razvijalci preizkušajo funkcije,
      ki zahtevajo varne kontekste, ne da bi bilo treba uvesti TLS v preizkusnem produkcijskem
      strežniku. Ta pravilnik prav tako prepreči, da bi imel izvor v naslovni vrstici
      oznako »Ni varno«.

      Nastavitev seznama URL-jev v tem pravilniku ima enak učinek kot nastavitev
      zastavice ukazne vrstice »--unsafely-treat-insecure-origin-as-secure« na seznamu,
      ločenemu z vejicami, istih URL-jev. Če je pravilnik nastavljen,
      preglasi zastavico ukazne vrstice.

      Ta pravilnik je zastarel v različici M69 in je bil nadomeščen s pravilnikom
      OverrideSecurityRestrictionsOnInsecureOrigin. Če sta na voljo oba,
      pravilnik OverrideSecurityRestrictionsOnInsecureOrigin preglasi ta
      pravilnik.

      Več informacij o varnih kontekstih je na voljo na
      https://www.w3.org/TR/secure-contexts/
      </translation>
<translation id="8942616385591203339">Ta pravilnik nadzira, ali je soglasje za sinhronizacijo lahko prikazano uporabniku med prvo prijavo. Če soglasja za sinhronizacijo ne potrebujete za uporabnika, mora biti pravilnik onemogočen.
      Če je onemogočen, soglasje za sinhronizacijo ne bo prikazano.
      Če je omogočen ali ni nastavljen, je soglasje za sinhronizacijo mogoče prikazati.</translation>
<translation id="894510252300143386">Konfigurira nastavitve upravljanja razširitev za brskalnik <ph name="PRODUCT_NAME" />.

          Ta pravilnik nadzira več nastavitev, vključno z nastavitvami, ki jih nadzirajo kateri koli obstoječi pravilniki, povezani z razširitvami. Ta pravilnik preglasi vse morebitne starejše pravilnike, če so nastavljeni oboji.

          Ta pravilnik preslika ID razširitve ali URL za posodobitev v svojo konfiguracijo. Konfiguracija z ID-jem razširitve bo uporabljena samo za določeno razširitev. Za posebni ID <ph name="DEFAULT_SCOPE" /> je mogoče nastaviti privzeto konfiguracijo, ki se bo uporabila za vse razširitve, ki v tem pravilniku nimajo nastavljene konfiguracije po meri. Konfiguracija z URL-jem za posodobitev bo uporabljena za vse razširitve s točno določenim URL-jem za posodobitev, navedenim v manifestu te razširitve, kot je opisano na <ph name="LINK_TO_EXTENSION_DOC1" />.

          Za primerke sistema Windows, ki niso pridruženi v domeno <ph name="MS_AD_NAME" />, je vsiljeno nameščanje omejeno na aplikacije in razširitve, navedene v Spletni trgovini Chrome.
          </translation>
<translation id="8947415621777543415">Prijava lokacije naprave</translation>
<translation id="8951350807133946005">Nastavi imenik predpomnilnika diska</translation>
<translation id="8952317565138994125">Onemogoča sinhronizacijo podatkov v izdelku <ph name="PRODUCT_NAME" /> s storitvami sinhronizacije, ki jih gosti Google, in uporabnikom prepreči spreminjanje te nastavitve.

      Če to nastavitev omogočite, je uporabniki v izdelku <ph name="PRODUCT_NAME" /> ne morejo spremeniti ali preglasiti.

      Če ta pravilnik ni nastavljen, bo lahko uporabnik izbral, ali se Google Sync uporablja ali ne.

      Če želite storitev Google Sync povsem onemogočiti, priporočamo, da onemogočite storitev Google Sync v konzoli Google Admin console.

      Ta pravilnik ne sme biti omogočen, ko je omogočen pravilnik <ph name="ROAMING_PROFILE_SUPPORT_ENABLED_POLICY_NAME" />, saj ta funkcija uporablja enako funkcijo pri odjemalcu. Sinhronizacija, ki jo gosti Google, je v tem primeru povsem onemogočena.</translation>
<translation id="8955719471735800169">Nazaj na vrh</translation>
<translation id="8959992920425111821">Privzeta konfiguracija</translation>
<translation id="8960850473856121830">Vzorci na tem seznamu se bodo primerjali z varnostnim
      izvorom zahtevajočega URL-ja. Če je najdeno ujemanje, bo dostop do naprav
      za zajem zvoka dovoljen brez poziva.

      OPOMBA: ta pravilnik je bil do različice 45 podprt samo v načinu kioska.</translation>
<translation id="8970205333161758602">Ne prikaže poziva za preklop za <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="8976248126101463034">Dovoli preverjanje pristnosti »gnubby« za gostitelje za oddaljeni dostop</translation>
<translation id="8976531594979650914">Uporaba sistemsko privzetega tiskalnika kot privzeti tiskalnik</translation>
<translation id="8992176907758534924">Nobenemu spletnemu mestu ne dovoli prikaza slik</translation>
<translation id="9013875414788074110"><ph name="PRODUCT_OS_NAME" /> lahko pri prijavi preverja pristnost v strežniku (če je na voljo internetna povezava) ali z uporabo predpomnjenega gesla (brez internetne povezave).

      Če je ta pravilnik nastavljen na vrednost –1, lahko uporabnik neomejeno potrjuje svojo pristnost brez internetne povezave. Če je pravilnik nastavljen na katero koli drugo vrednost, ta določa časovno obdobje po zadnjem preverjanju pristnosti prek interneta, po katerem se bo moral uporabnik znova prijaviti s preverjanjem pristnosti prek interneta.

      Če tega pravilnika ne nastavite, bo <ph name="PRODUCT_OS_NAME" /> uporabil privzeto časovno omejitev 14 dni, po kateri se bo moral uporabnik ponovno prijaviti s preverjanjem pristnosti prek interneta.

      Ta pravilnik vpliva samo na uporabnike, katerih pristnost je bila preverjena s SAML-jem.

      Vrednost za pravilnik mora biti izražena v sekundah.</translation>
<translation id="9035964157729712237">ID-ji razširitev, ki naj bodo izvzete s seznama prepovedanih</translation>
<translation id="9038058011835642205">Določa seznam spletnih mest, ki so nameščene brez obveščanja in poseganja uporabnika ter jih uporabnik ne more odmestiti ali onemogočiti.

      Vsak element na seznamu pravilnika je predmet z obveznim članom, »url«, in dvema neobveznima članoma, »default_launch_container« in »create_desktop_shortcut«. »url« mora biti URL spletne aplikacije za namestitev, »launch_container« mora biti »window« ali »tab«, ki pokaže, kako naj se spletna aplikacija po namestitvi odpira, član »create_desktop_shortcut« pa mora biti nastavljen na »true«, če naj bo bližnjica na namizju ustvarjena v sistemih Linux in Windows. Če je izpuščen član »default_launch_container«, se aplikacija privzeto odpira na zavihku. Ne glede na vrednost člana »default_launch_container« uporabniki lahko spremenijo, v katerem vsebniku se bo odpirala aplikacija. Če je izpuščen član »create_desktop_shortcuts«, bližnjice na namizju ne bodo ustvarjene.</translation>
<translation id="9038839118379817310">Omogočanje povezave Wi-Fi</translation>
<translation id="9039822628127365650">Če je ta pravilnik nastavljen, določa dolžino časa, po katerem je uporabnik samodejno odjavljen, seja pa se konča. Uporabnik je obveščen o preostalem času s časovnikom, prikazanem v sistemski vrstici.

      Če ta pravilnik ni nastavljen, dolžina seje ni omejena.

      Če nastavite ta pravilnik, ga uporabniki ne morejo spremeniti ali preglasiti.

      Vrednost pravilnika mora biti navedena v milisekundah. Vrednosti so v obsegu od 30 sekund do 24 ur.</translation>
<translation id="9050853837490399534">Ta pravilnik nadzira, ali naj bo naprava posodobljena na delovno različico Quick Fixa.

      Če je vrednost pravilnika nastavljena na žeton, ki preslika v delovno različico Quick Fixa, bo naprava posodobljena na ustrezno delovno različico Quick Fixa, če posodobitve ne blokira drug pravilnik.

      Če ta pravilnik ni nastavljen ali njegova vrednost ne preslika v delovno različico Quick Fixa, naprava ne bo posodobljena na delovno različico Quick Fixa. Če naprava že uporablja delovno različico Quick Fixa in pravilnik ni več nastavljen ali njegova vrednost ne preslika več v delovno različico Quick Fixa, bo naprava posodobljena v običajno različico, če posodobitve ne blokira drug pravilnik.</translation>
<translation id="9072600218500597787">Konfigurira zahtevana imena domen gostiteljev, ki bodo veljala za gostitelje oddaljenega dostopa, in prepreči uporabnikom njihovo spreminjanje.

          Če je ta nastavitev omogočena, se lahko gostitelji delijo samo z računi, registriranimi v enem od določenih imen domene.

          Če je ta nastavitev onemogočena ali ni nastavljena, se lahko gostitelji delijo s poljubnim računom.

          Ta nastavitev preglasi pravilnik RemoteAccessHostDomain, če je na voljo.

          Glejte tudi RemoteAccessHostClientDomainList.</translation>
<translation id="9077227880520270584">Časovnik za samodejno prijavo lokalnega računa v napravi</translation>
<translation id="9084985621503260744">Navedite, ali videodejavnost vpliva na upravljanje napajanja</translation>
<translation id="9088433379343318874">Omogočanje ponudnika vsebine za zaščitene uporabnike</translation>
<translation id="9088444059179765143">Konfiguriranje načina samodejnega zaznavanja časovnega pasu</translation>
<translation id="9096086085182305205">Seznam dovoljenih strežnikov za preverjanje pristnosti</translation>
<translation id="9105265795073104888">Aplikacijam za Android je dan na voljo samo podnabor nastavitev strežnika proxy. Aplikacije za Android se lahko prostovoljno odločijo, da bodo uporabljale strežnik proxy. V to jih ni mogoče prisiliti.</translation>
<translation id="9106865192244721694">Omogočanje WebUSB-ja na teh spletnih mestih</translation>
<translation id="9112727953998243860">Datoteka s konfiguracijami tiskalnikov v podjetjih</translation>
<translation id="9112897538922695510">Omogoča registracijo seznama rutin za obravnavo protokolov. Ta pravilnik je lahko samo priporočen. Lastnost |protocol| mora biti nastavljena na shemo, kot je »mailto«, in lastnost |url| mora biti nastavljena na vzorec URL aplikacije, ki obravnava shemo. Vzorec lahko vsebuje »%s«. Če ga, ta nadomesti obravnavani URL.

          Rutine za obravnavo protokola, registrirane s pravilnikom, so združene z rutinami, ki jih registrira uporabnik, oboje pa je na voljo za uporabo. Uporabnik lahko preglasi rutine za obravnavo protokola, nameščene s pravilnikom, tako da namesti novo privzeto rutino za obravnavo protokola, vendar ne more odstraniti rutine za obravnavo protokola, registrirane s pravilnikom.</translation>
<translation id="9123211093995421438">Določa najmanjše število dovoljenih mejnikov sistema <ph name="PRODUCT_OS_NAME" />, za katero je dovoljena povrnitev, z začetkom pri trenutno veljavni stabilni različici.

      Privzeta vrednost je 0 za naprave potrošnikov in 4 (približno pol leta) za včlanjene naprave v poslovnih okoljih.

      Z nastavitvijo tega pravilnika preprečite, da bi zaščita pred povrnitvijo veljala za vsaj toliko mejnikov.

      Nastavitev tega pravilnika na nižjo vrednost ima trajni učinek: naprave MORDA ne bo mogoče povrniti na prejšnje različice, tudi potem ko pravilnik ponastavite na višjo vrednost. 

      Dejanske možnosti povrnitve so lahko odvisne tudi od vezja in nujnih popravkov ranljivosti.</translation>
<translation id="9126014181388780690">»Omogočanje Pomočniku Google, da dostopa do vsebine zaslona«</translation>
<translation id="913195841488580904">Blokiranje dostopa do seznama spletnih naslovov</translation>
<translation id="9135033364005346124">Omogoči proxy <ph name="CLOUD_PRINT_NAME" /></translation>
<translation id="9136399279941091445">Intervali zunaj delovnega časa, ko pravilniki za napravo niso aktivni</translation>
<translation id="9147029539363974059">Pošiljanje sistemskih dnevnikov v strežnik za upravljanje, kar skrbnikom omogoča
      nadziranje sistemskih dnevnikov.

      Če je ta pravilnik omogočen, se sistemski dnevniki pošiljajo. Če je
      onemogočen ali ni nastavljen, se sistemski dnevniki ne pošiljajo.</translation>
<translation id="9150416707757015439">Ta pravilnik je zastarel. Uporabite pravilnik »IncognitoModeAvailability«.
      Ta v brskalniku <ph name="PRODUCT_NAME" /> omogoča način brez beleženja zgodovine.

      Če je ta nastavitev omogočena ali ni konfigurirana, lahko uporabniki odprejo spletne strani v načinu brez beleženja zgodovine.

      Če je ta nastavitev onemogočena, uporabniki ne morejo odpreti spletnih strani v načinu brez beleženja zgodovine.

      Če ta pravilnik ni nastavljen, bo to omogočeno in uporabnik bi lahko uporabljal način brez beleženja zgodovine.</translation>
<translation id="915194831143859291">Če je ta pravilnik onemogočen ali ni nastavljen, bo <ph name="PRODUCT_OS_NAME" /> uporabniku dovolil zaustaviti napravo.
      Če je ta pravilnik omogočen, bo <ph name="PRODUCT_OS_NAME" /> sprožil vnovični zagon, ko uporabnik zaustavi napravo. <ph name="PRODUCT_OS_NAME" /> nadomesti vse gumbe za zaustavitev v uporabniškem vmesniku z gumbi za vnovični zagon. Če uporabnik zaustavi napravo z gumbom za vklop, se naprava ne bo samodejno zagnala znova, tudi če je pravilnik omogočen.</translation>
<translation id="9152473318295429890">Omogočeni kontekstni predlogi sorodnih spletnih strani</translation>
<translation id="9153446010242995516">Povrnite na ciljno različico in ostanite na njej, če je različica operacijskega sistema novejša kot ciljna. S povrnitvijo poskusite prenesti konfiguracijo na ravni naprave (vključno z omrežnimi poverilnicami), če je to mogoče, vendar ne izvedite povrnitve s popolnim Powerwashem, tudi če obnovitev podatkov ni mogoča (ker ciljna različica ne podpira obnovitve podatkov ali zaradi spremembe, ki ni združljiva s prejšnjo različico).
          Podprto v brskalniku <ph name="PRODUCT_OS_NAME" /> različice 75 in novejših. Pri starejših odjemalcih ta vrednost pomeni, da je povrnitev onemogočena.</translation>
<translation id="9158929520101169054">Omogočanje prijave z več računi v brskalniku</translation>
<translation id="9159126470527871268">Obvesti uporabnike, da je treba zaradi uveljavitve posodobitve na čakanju znova zagnati brskalnik <ph name="PRODUCT_NAME" /> ali napravo <ph name="PRODUCT_OS_NAME" />.

      Ta nastavitev pravilnika omogoči obvestila, ki uporabnika obvestijo, da je priporočen ali obvezen vnovičen zagon brskalnika ali naprave. Če pravilnik ni nastavljen, brskalnik <ph name="PRODUCT_NAME" /> uporabnika glede potrebnega vnovičnega zagona obvesti prek manjših sprememb menija, medtem ko ga naprava <ph name="PRODUCT_OS_NAME" /> obvesti o tem prek obvestila v sistemski vrstici. Če je pravilnik nastavljen na »Recommended« (priporočeno), je uporabniku prikazano ponavljajoče se opozorilo, da je priporočen vnovičen zagon. Uporabnik lahko opozorilo opusti in tako odloži vnovičen zagon. Če je pravilnik nastavljen na »Required« (obvezno), je uporabniku prikazano ponavljajoče se opozorilo, da bo po izteku obdobja za obveščanje vsiljen vnovičen zagon brskalnika. To obdobje privzeto traja sedem dni za brskalnik <ph name="PRODUCT_NAME" /> in štiri dni za napravo <ph name="PRODUCT_OS_NAME" /> ter ga je mogoče konfigurirati v nastavitvi pravilnika <ph name="RELAUNCH_NOTIFICATION_PERIOD_POLICY_NAME" />.

      Uporabniška seja je po vnovičnem zagonu brskalnika/naprave obnovljena.</translation>
<translation id="9165792353046089850">Omogoča nastavitev, ali lahko spletna mesta dostopajo do povezanih naprav USB. Dostop je mogoče v celoti blokirati ali pa je uporabnik vprašan, ko želi spletno mesto dostopati do povezanih naprav USB.

          Ta pravilnik je mogoče preglasiti za določene vzorce URL-jev, ki uporabljajo pravilnika »WebUsbAskForUrls« in »WebUsbBlockedForUrls«.

          Če ta pravilnik ni nastavljen, je uporabljeno »3« in uporabnik lahko to spremeni.</translation>
<translation id="9167719789236691545">Onemogoči Google Drive v aplikaciji Datoteke za <ph name="PRODUCT_OS_NAME" /></translation>
<translation id="9185107612228451403">Konfigurira pravilnike, povezane z razširitvami. Uporabnik ne sme namestiti razširitev s seznama blokiranih, razen če so na seznamu dovoljenih. Lahko tudi vsilite brskalniku <ph name="PRODUCT_NAME" />, da samodejno namesti razširitve tako, da jih navedete v pravilniku <ph name="EXTENSION_INSTALL_FORCELIST_POLICY_NAME" />. Razširitve, za katere vsilite namestitev, so nameščene ne glede na to, ali so navedene na seznamu blokiranih.</translation>
<translation id="9187743794267626640">Onemogoči vpenjanje zunanjega pomnilnika</translation>
<translation id="9197740283131855199">Odstotek prilagoditve zakasnitve zatemnitve zaslona, če je uporabnik dejaven po zatemnitvi</translation>
<translation id="9200828125069750521">Parametri za slikovni URL, ki uporablja POST</translation>
<translation id="920209539000507585">Vsiljena nastavitev v pogovornem oknu za tiskanje, da so glave in noge vklopljene ali izklopljene.

      Če pravilnik ni nastavljen, se lahko uporabnik odloči, ali želi natisniti glave in noge.

      Če je pravilnik onemogočen, možnost za glave in noge v pogovornem oknu za predogled tiskanja ni izbrana in uporabnik tega ne more spremeniti.

      Če je pravilnik omogočen, je možnost za glave in noge v pogovornem oknu za predogled tiskanja izbrana in uporabnik tega ne more spremeniti.</translation>
<translation id="9217154963008402249">Pogostost omrežnih paketov za spremljanje</translation>
<translation id="922540222991413931">Konfiguriranje virov za namestitev razširitev, aplikacij in uporabniških skriptov</translation>
<translation id="924557436754151212">Uvoz shranjenih gesel privzetega brskalnika pri prvem zagonu</translation>
<translation id="926146562923985266">Ta pravilnik nadzira ukaz za odpiranje URL-jev v brskalniku <ph name="PRODUCT_NAME" /> pri preklopu iz Internet Explorerja.

      Če dodatek za Internet Explorer »Podpora za starejše brskalnike« ni nameščen, ta pravilnik nima vpliva.

      Če ta pravilnik ni nastavljen, Internet Explorer pri zagonu brskalnika <ph name="PRODUCT_NAME" /> iz Internet Explorerja samodejno zazna pot do izvedljive datoteke brskalnika <ph name="PRODUCT_NAME" />.

      Če je ta pravilnik nastavljen, se uporablja za zagon brskalnika <ph name="PRODUCT_NAME" /> pri zagonu brskalnika <ph name="PRODUCT_NAME" /> iz Internet Explorerja.

      Ta pravilnik je mogoče nastaviti na pot do izvedljive datoteke ali na ${chrome} za samodejno zaznavanje Chromove lokacije za namestitev.</translation>
<translation id="930930237275114205">Nastavi imenik uporabniških podatkov za <ph name="PRODUCT_FRAME_NAME" /></translation>
<translation id="943865157632139008">Omogoča nastavitev privzetega upodabljalnika HTML-ja, ko je nameščen <ph name="PRODUCT_FRAME_NAME" />.
          Privzeta nastavitev je, da upodabljanje izvaja gostiteljski brskalnik, vendar lahko to preglasite in določite, da <ph name="PRODUCT_FRAME_NAME" /> privzeto upodablja strani HTML.</translation>
<translation id="944817693306670849">Nastavitev velikosti predpomnilnika</translation>
<translation id="966854160628341653">Nadzira, ali <ph name="PRODUCT_OS_NAME" /> omogoča ustvarjanje novih uporabniških računov. Če je ta pravilnik onemogočen, se uporabniki, ki še nimajo računa, ne morejo prijaviti.

      Če je pravilnik omogočen ali ni nastavljen, je mogoče ustvariti nove uporabniške račune, če <ph name="DEVICE_USER_WHITELIST_POLICY_NAME" /> uporabniku ne preprečuje prijave.</translation>
<translation id="981346395360763138">Googlove lokacijske storitve so onemogočene</translation>
<translation id="982497069985795632">Omogočanje preverjanja črkovanja</translation>
<translation id="991560005425213776">Pošiljanje uporabniškega imena in imena datoteke izvornim tiskalnikom</translation>
</translationbundle>